数据类型汇总

基本数据类型

8种基本数据类型

public class TypeDemo1 {
    public static void main(String[] args) {
        // 目标：掌握8种基本数据类型，用来定义变量。
        // 1、整型
        byte number = 98;
        System.out.println(number);

        short number2 = 9000;

        int number3 = 12323232; // 默认

        // 注意：随便写一个整型字面量，默认是int类型的，73642422442424虽然没有超过long的范围，但是它超过了本身int的范围了。
        // 如果希望随便写一个整型字面量是long类型的，需要在其后面加上L/l
        long number4 = 73642422442424L;

        // 2、浮点型
        //注意:
        //随便写一个小数字面量，默认当成double类型对待的，
        //如果希望这个小数是float类型的，需要在后面加上：F/f
        float score1 = 99.5F;
        double score2 = 99.8; // 默认定义方案。

        // 3、字符型
        char ch1 = 'a';
        char ch2 = '中';
        char ch3 = '国';

        // 4、布尔型
        boolean b1 = true;
        boolean b2 = false;

        // 引用数据类型：String.
        // String代表的是字符串类型，定义的变量可以用来记住字符串。
        String name = "黑马";
        System.out.println(name);
    }
}

基本数据类型转换

引用数据类型转换

String类

String类概述

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！

String类的特点

字符串不可变，它们的值在创建后不能被更改
虽然 String 的值是不可变的，但是它们可以被共享
字符串效果上相当于字符数组( char[] )，但是底层原理是字节数组( byte[] )

String类的构造方法

常用的构造方法

| 方法名 | 说明 |
| —————————————- | ————————————————————- |
| public String() | 创建一个空白字符串对象，不含有任何内容 |
| public String(char[] chs) | 根据字符数组的内容，来创建字符串对象 |
| public String(byte[] bys) | 根据字节数组的内容，来创建字符串对象 |
| String s = “abc”; | 直接赋值的方式创建字符串对象，内容就是abc |

示例代码

public class StringDemo01 {
    public static void main(String[] args) {
        //public String()：创建一个空白字符串对象，不含有任何内容
        String s1 = new String();
        System.out.println("s1:" + s1);

        //public String(char[] chs)：根据字符数组的内容，来创建字符串对象
        char[] chs = {'a', 'b', 'c'};
        String s2 = new String(chs);
        System.out.println("s2:" + s2);

        //public String(byte[] bys)：根据字节数组的内容，来创建字符串对象
        byte[] bys = {97, 98, 99};
        String s3 = new String(bys);
        System.out.println("s3:" + s3);

        //String s = “abc”;	直接赋值的方式创建字符串对象，内容就是abc
        String s4 = "abc";
        System.out.println("s4:" + s4);
    }
}

创建字符串对象两种方式的区别

通过构造方法创建

通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同
直接赋值方式创建

以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护

字符串的比较

==号的作用

比较基本数据类型：比较的是具体的值
比较引用数据类型：比较的是对象地址值

`equals`方法的作用

方法介绍

1	public boolean equals(String s) 比较两个字符串内容是否相同、区分大小写

示例代码

public class StringDemo02 {
    public static void main(String[] args) {
    //构造方法的方式得到对象
        char[] chs = {'a', 'b', 'c'};
        String s1 = new String(chs);
        String s2 = new String(chs); 
        //直接赋值的方式得到对象
        String s3 = "abc";
        String s4 = "abc";

        //比较字符串对象地址是否相同
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s3 == s4);
        System.out.println("--------");

        //比较字符串内容是否相同
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));
        System.out.println(s3.equals(s4));
}
}

常用的方法：

>public char charAt(int index)  //返回指定索引处的 char 值。
>public char[] toCharArray() //将此字符串转换为一个新的字符数组。 
>public static String valueOf(char[] data)  //返回 char 数组参数的字符串表示形式。
>public boolean equals(Object anObject) //将此字符串与指定的对象比较。当且仅当该参数不为 null，并且是与此对象表示相同字符序列的 String 对象时，结果才为 true。 
>public int compareTo(String anotherString) //按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。
>public int compareTo(String anotherString) //按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。
>public String substring(int beginIndex,int endIndex) //返回一个新字符串，它是此字符串的一个子字符串。
>public String concat(String str) //将指定字符串连接到此字符串的结尾。  和StringBuilder的append一样
>public boolean contains(CharSequence s) //当且仅当此字符串包含指定的 char 值序列时，返回 true
>public String toLowerCase(Locale locale) //使用给定 Locale 的规则将此 String 中的所有字符都转换为小写
>public String toUpperCase(Locale locale) //使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
>public String trim() //返回字符串的副本，忽略前导空白和尾部空白。

StringBuilder

public class Test{
    public static void main(String[] args){
        StringBuilder sb = new StringBuilder("itehima");
        
        //1.拼接内容
        sb.append(12);
        sb.append("黑马");
        sb.append(true);
        
        //2.append方法，支持临时编程
        sb.append(666).append("黑马2").append(666);
        System.out.println(sb); //打印：12黑马666黑马2666
        
        //3.反转操作
        sb.reverse();
        System.out.println(sb); //打印：6662马黑666马黑21
        
        //4.返回字符串的长度
        System.out.println(sb.length());
        
        // 返回字符串的位置的字符
        public char charAt(int index)
        // 删除指定位置
        StringBuilder sb = new StringBuilder("爸爸的脸蛋有很多褶皱");
        sb.delete(3, 4);
        System.out.println(sb); // 输出结果为：爸爸的蛋有很多褶皱
        
		// 插入
        StringBuilder sb = new StringBuilder("《摔跤吧！爸爸》");
        sb.insert(3, "了");
        System.out.println(sb); // 输出结果为：《摔跤了吧！爸爸》

        // 返回字符串的索引位置
        public int indexOf(String str)
            
        // 截取子串
        public String substring(int start , int end)
        
         // 替换
        StringBuilder sb = new StringBuilder("春眠不觉晓，处处闻啼鸟。");
        sb.replace(8, 11, "蚊子咬");
        System.out.println(sb); // 输出结果为：春眠不觉晓，处处蚊子咬。
        
         //容量和长度
		//StringBuilder默认的初始容量是16，可用带参构造器来自定义初始容量。当字符个数达到了当前容量，则容量会自动提升，容量提升的规律为：新容量 = 旧容量 * 2 + 2。
		int capacity() //返回当前字符序列的容量。
		int length() //返回当前已存储的字符的个数。
            
        StringBuilder sb = new StringBuilder(6);
        sb.append("执子之手，方知子丑。");
        System.out.println(sb.capacity()); // 转出结果为：26
        System.out.println(sb.length()); // 转出结果为：10

            
        //5.StringBuilder还可以转换为字符串
        String s = sb.toString();
        System.out.println(s); //打印：6662马黑666马黑21
    }
}

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
sb.insert(5, ","); // 在位置5插入逗号
sb.delete(11, 17); // 删除指定范围内的字符
sb.replace(5, 6, "!"); // 替换指定位置的字符
String result = sb.toString();
System.out.println(result); // 输出: Hello, World!

StringJoiner

接下来，我们学习一个类叫做StringJoiner，学习这个类干嘛用呢？是因为我们前面使用StringBuilder拼接字符串的时，代码写起来还是有一点麻烦，而StringJoiner号称是拼接神器，不仅效率高，而且代码简洁。StringJoiner添加时是.add()，StringBuilder是.append(),主要用于处理需要以某种分隔符连接元素的场景，例如构建 CSV、SQL 语句等。

public class Test{
    public static void main(String[] args){
        StringJoiner s = new StringJoiner(",");
        s.add("java1");
        s.add("java2");
        s.add("java3");
        System.out.println(s); //结果为： java1,java2,java3
        
        //参数1：间隔符
        //参数2：开头
        //参数3：结尾
        StringJoiner s1 = new StringJoiner(",","[","]");
        s1.add("java1");
        s1.add("java2");
        s1.add("java3");
        System.out.println(s1); //结果为： [java1,java2,java3]
    }
}

StringJoiner merge(StringJoiner other): 将另一个 StringJoiner 的内容合并到当前 StringJoiner。

常见类型转换

// 数字转换为字符串
int   a = 332;
String str = String.valueOf(a);
//字符串转换为数字
String str = "abcd";
int a = Integer.parseInt(str);
//字符串转化为字符数组
String str = " acbd";
char[] c = str.toCharArray();
//字符数组转化为字符串
char[] c = {'a','b','c'};
String str = String.valueOf(c);
String str = new String(c)

使用案例讲解

数组都有一个.length的方法，注意这里没有小括号

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        int a = 0;
        int b = 0;
        
        for(int i = 0; i<tokens.length ; i++){
            if(tokens[i].equals("+")){
               a = stack.pop();
               b = stack.pop();
               stack.push(a+b);
            }
            else if(tokens[i].equals("-")){
               a = stack.pop();
               b = stack.pop();
               stack.push(b-a);
            }
            else if(tokens[i].equals("*")){
               a = stack.pop();
               b = stack.pop();
               stack.push(a*b);
            }
            else if(tokens[i].equals("/")){
               a = stack.pop();
               b = stack.pop();
               stack.push(b/a);
            }
            else{
                stack.push(Integer.parseInt(tokens[i]));
        }
        }
        a = stack.pop();
        return a;
    }
}

`Integer`

valueOf:
static Integer valueOf(int i): 返回一个表示指定整数值的 Integer 实例。
static Integer valueOf(String s): 返回一个保存指定值的 Integer 对象。

intValue:
int intValue(): 将 Integer 对象的值以 int 类型返回。
    
compareTo:
int compareTo(Integer anotherInteger): 比较两个整数，返回值为 0（相等）、负数（小于）或正数（大于）。
    
equals:
boolean equals(Object obj): 比较两个对象是否相等。

parseInt:
static int parseInt(String s): 将字符串解析为带符号的十进制整数。

toString:
String toString(): 将 Integer 对象的值转换为字符串。
其他常量:

MAX_VALUE: 表示 int 类型的最大值。
MIN_VALUE: 表示 int 类型的最小值。
SIZE: 表示以二进制补码形式表示的指定 int 值的位数。
TYPE: 表示基本类型 int 的 Class 实例
    
    
Integer num1 = Integer.valueOf(42);
Integer num2 = Integer.parseInt("123");

int sum = num1 + num2.intValue();
System.out.println("Sum: " + sum);

if (num1.equals(num2)) {
    System.out.println("num1 and num2 are equal.");
}

System.out.println("MAX_VALUE: " + Integer.MAX_VALUE);
System.out.println("MIN_VALUE: " + Integer.MIN_VALUE);

从Java 9开始，Integer 类引入了一些新的静态方法，例如 sum, max, min 等，以提供更多对整数的处理支持。