【零基础 快速学Java】韩顺平 零基础30天学会Java--- 常用类(2024JavaReview)

包装类

包装类的分类（针对八种基本数据类型相应的引用类型—包装类）（有了类的特点，就可以调用类中的方法）（实现了接口 Serializable【String 可以串行化:可以在网络传输】）（实现了接口 Comparable [String 对象可以比较大小]）

包装类和基本数据的转换（jdk5 前的手动装箱和拆箱方式，jdk5 以后(含jdk5)的自动装箱和拆箱方式）

/**
 * @创建人 wdl
 * @创建时间 2024/9/2
 * @描述
 */
public class Integer01 {
    public static void main(String[] args) {
        //演示 int <--> Integer 的装箱和拆箱
        //jdk5 前是手动装箱和拆箱
        //手动装箱 int->Integer
        int n1 = 100;
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);

        //手动拆箱
        //Integer -> int
        int i = integer.intValue();


        //jdk5 后，就可以自动装箱和自动拆箱
        int n2 = 200;
        //自动装箱 int->Integer
        Integer integer2 = n2; //底层使用的是
        Integer.valueOf(n2);
        //自动拆箱 Integer->int
        int n3 = integer2; //底层仍然使用的是 intValue()方法
    }
}

课堂测试题（Java 会在三元运算符中自动提升返回值的类型）

包装类型和 String 类型的相互转换（String.valueOf(i)，Integer.parseInt(str4)）

/**
 * @创建人 wdl
 * @创建时间 2024/9/2
 * @描述
 */
public class WrapperVSString {
    public static void main(String[] args) {
        //包装类(Integer)->String
         Integer i = 100;//自动装箱
        //方式 1
        String str1 = i + "";
        //方式 2   必须是包装类才能调用相应的函数
        String str2 = i.toString();
        //方式 3
        String str3 = String.valueOf(i);



        //String -> 包装类(Integer)
        String str4 = "12345";
        Integer i2 = Integer.parseInt(str4);//使用到自动装箱
        Integer i3 = new Integer(str4);//构造器

        System.out.println("ok~~");


    }
}

Integer 类和 Character 类的常用方法

/**
 * @创建人 wdl
 * @创建时间 2024/9/2
 * @描述
 */
public class WrapperMethod {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE); //返回最小值
        System.out.println(Integer.MAX_VALUE);//返回最大值

        System.out.println(Character.isDigit('a'));//判断是不是数字
        System.out.println(Character.isLetter('a'));//判断是不是字母
        System.out.println(Character.isUpperCase('a'));//判断是不是大写
        System.out.println(Character.isLowerCase('a'));//判断是不是小写


        System.out.println(Character.isWhitespace('a'));//判断是不是空格
        System.out.println(Character.toUpperCase('a'));//转成大写
        System.out.println(Character.toLowerCase('A'));//转成小写

    }
}

Integer 类面试题

new Interger出来的一定不一样

/**
 * @创建人 wdl
 * @创建时间 2024/9/2
 * @描述
 */
public class WrapperExercise02 {
    public static void main(String[] args) {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);    //False
        //所以，这里主要是看范围 -128 ~ 127 就是直接返回
        /*
        老韩解读
        //1. 如果 i 在 IntegerCache.low(-128)~IntegerCache.high(127),就直接从数组返回
        //2. 如果不在 -128~127,就直接 new Integer(i)
        public static Integer valueOf(int i) {
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
        */
        Integer m = 1; //底层 Integer.valueOf(1); -> 阅读源码
        Integer n = 1;//底层 Integer.valueOf(1);
        System.out.println(m == n); //T
        //所以，这里主要是看范围 -128 ~ 127 就是直接返回
        //，否则，就 new Integer(xx);
        Integer x = 128;//底层 Integer.valueOf(1);
        Integer y = 128;//底层 Integer.valueOf(1);
        System.out.println(x == y);//False

    }
}

只要有基本数据类型，判断的是值是否相同

String 类（String 是 final 类，不能被其他的类继承）（String 是不可变对象，即一旦创建，字符串的内容就不能被改变。当你对字符串进行修改时，实际上是在创建一个新的字符串对象，而不是修改原来的对象）

String 类的理解和创建对象（String 对象用于保存字符串，也就是一组字符序列）（字符串的字符使用 Unicode 字符编码，一个字符(不区分字母还是汉字)占两个字节）

/**
 * @创建人 wdl
 * @创建时间 2024/9/3
 * @描述
 */
public class String01 {
    public static void main(String[] args) {
        //1.String 对象用于保存字符串，也就是一组字符序列
        //2. "jack" 字符串常量, 双引号括起的字符序列
        //3. 字符串的字符使用 Unicode 字符编码，一个字符(不区分字母还是汉字)占两个字节
        //4. String 类有很多构造器，构造器的重载
        //	常用的有 String	s1 = new String(); //
        //String	s2 = new String(String original);
        //String	s3 = new String(char[] a);
        //String	s4 =	new String(char[] a,int startIndex,int count)
        //String s5 = new String(byte[] b)

        //5. String 类实现了接口 Serializable【String 可以串行化:可以在网络传输】
        //	接口 Comparable [String 对象可以比较大小]

        //6. String 是 final 类，不能被其他的类继承
        //7. String 有属性 private final char value[]; 用于存放字符串内容
        //8. 一定要注意：value 是一个 final 类型， 不可以修改(需要功力)：即 value 不能指向
        //	新的地址，但是单个字符内容是可以变化


        String name = "jack";
        name = "tom";
        final char[] value = {'a','b','c'};
        char[] v2 = {'t','o','m'};
        value[0] = 'H';
        //value = v2; 不可以修改 value 地址


    }
}

创建 String 对象的两种方式和其区别（重要）

1)方式一:直接赋值 String s=“hspedu”;（s最终指问的是常量池的空间地址）

2)方式二:调用构造器 String s= new String("hspedu”)（s最终指问的是堆中的空间地址）（如果常量池没有"hsp”，重新创建，如果有，直接通过value指向）

测试题

1,2. 两种创建方式地址的区别

3. 对象中属性的字符串指向的是常量池中的空间

字符串的特性（常量相加，看的是池 VS 变量相加,是在堆中）

1)String是一个final类，代表不可变的字符序列
2)字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的

1.编译器对两个字符串常量相加做了优化

2.常量相加（在池中）和变量相加（在堆中）的区别

3. 字符串变量（要想修改其值，必须传引用）和final char[]类型的变量

注：

ex在栈里，str是属性，先会在堆里有个地址（否则str会在栈中）

Java—值传递和引用传递（其实只有值传递）

为什么String是不可变的

final修饰的字段意味着引用不可变，这对char[] value数组意味着两个事情：

1. 引用不可变：value这个变量的引用不能指向其他的数组。
2. 内容不可直接修改：尽管final并不阻止我们改变数组元素（如果没有其他机制保护），但String通过设计没有提供任何方法来允许外部代码直接访问和修改这个数组。

String 类的常见方法

1. equals , 区分大小写，判断内容是否相等。 equalslgnoreCase //忽略大小写的判断内容是否相等

String str2 = "Hello";
	System.out.println(str1.equals(str2));//

2. length ,获取字符的个数，字符串的长度

System.out.println("王东梁".length());

3. indexOf ,获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到,返回-1 lastlndexOf //获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1

String s1 = "wer@terwe@g";
	int index = s1.indexOf('@');
	System.out.println(index);// 3
	System.out.println("weIndex=" + s1.indexOf("we"));//0
	// lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从 0 开始，如果找不到，返回-1
	s1 = "wer@terwe@g@";
	index = s1.lastIndexOf('@');
	System.out.println(index);//11
	System.out.println("ter 的位置=" + s1.lastIndexOf("ter"));//4

4. substring ,截取指定范围的子串[begin,end)

String name = "hello,张三";
	//下面 name.substring(6) 从索引 6 开始截取后面所有的内容
 	System.out.println(name.substring(6));//截取后面的字符
	//name.substring(0,5)表示从索引 0 开始截取，截取到索引 5-1=4 位置
	System.out.println(name.substring(2,5));//llo

5. trim ,（独有）去前后空格

6. charAt, 获取某索引处的字符,注意不能使用Str[index]这种方式,,此方法也不能改变字符串里面的字符

7. toUpperCase/toLowerCase（独有）

// 1.toUpperCase 转换成大写
        String s = "heLLo";
        System.out.println(s.toUpperCase());//HELLO
        // 2.toLowerCase
        System.out.println(s.toLowerCase());//hello

8. concat,（独有） 把两个字符串连接起来

//3.concat拼接字符串
	Strings1="宝玉";
	s1=s1.concat("林黛玉").concat("薛宝钗").concat("together");
	System.out.println(s1);//宝玉林黛玉薛宝钗together

9. replace , 替换字符串中的字符

s1="宝玉 and 林黛玉 林黛玉 林黛玉";
	//在s1中，将所有的林黛玉替换成薛宝钗
	//解读:s1.replace()方法执行后，返回的结果才是替换过的.
	//注意对s1没有任何影响
	Strings11=s1.replace("宝玉","jack");
	System.out.println(s1);//宝玉and林黛玉林黛玉林黛玉
	System.out.println(s11);//jackand林黛玉林黛玉林黛玉

10. split , （独有）分割字符串,对于某些分割字符，我们需要转义比如|\\等

String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦";
        //解读：
        // 1. 以 , 为标准对 poem 进行分割 , 返回一个数组
        // 2. 在对字符串进行分割时，如果有特殊字符，需要加入 转义符 \
        String[] split = poem.split(",");
        poem = "E:\\aaa\\bbb";
        split = poem.split("\\\\");
        System.out.println("==分割后内容===");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }

11. compareTo ,（独有） 比较两个字符串的大小（逐个字符比较）（如果前者大，则返回正数，后者大，则返回负数，如果相等，返回0 ）

// compareTo 比较两个字符串的大小，如果前者大，
        // 则返回正数，后者大，则返回负数，如果相等，返回 0
        // 解读
        // (1) 如果长度相同，并且每个字符也相同，就返回 0
        // (2) 如果长度相同或者不相同，但是在进行比较时，可以区分大小
        //	就返回 if (c1 != c2) {
        //	return c1 - c2;
        //	}
        // (3) 如果前面的部分都相同，就返回 str1.len - str2.len
        String a = "jcck";// len = 3
        String b = "jack";// len = 4
        System.out.println(a.compareTo(b)); // 返回值是 'c' - 'a' = 2 的值

12. toCharArray ，（独有）转换成字符数组

s = "happy";
        char[] chs = s.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            System.out.println(chs[i]);
        }

13. format，（独有） 格式字符串, %s 字符串 %c 字符 %d 整型 %.2f 浮点型（String.format(formatStr, name, age, score, gender);）

String name = "john";
        int age = 10;
        double score = 56.857;
        char gender = '男';
        //将所有的信息都拼接在一个字符串.
        String info = "我的姓名是" + name +
                "年龄是" + age +
                ",成绩是" + score +
                "性别是" + gender + "。希望大家喜欢我！ ";

        System.out.println(info);


        //老韩解读
        //1. %s , %d , %.2f %c 称为占位符
        //2. 这些占位符由后面变量来替换
        //3. %s 表示后面由 字符串来替换
        //4. %d 是整数来替换
        //5. %.2f 表示使用小数来替换，替换后，只会保留小数点两位, 并且进行四舍五入的处理
        //6. %c 使用 char 类型来替换
        String formatStr = "我的姓名是%s " +
                "年龄是%d，" +
                "成绩是%.2f 性别是%c.希望大家喜欢我！";

        String info2 = String.format(formatStr, name, age, score, gender);

        System.out.println("info2=" + info2);

StringBuffer类（可变长度的，因为 StringBuffer 字符内容是存在 char[] value, (增加/删除)不用每次都更换地址(即不是每次创建新对象)， 所以效率高于 String）

• java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删（原因如图）
• 很多方法与String相同，但StringBuffer是可变长度的。
• 在父类中 AbstractStringBuilder 有属性 char[] value,不是 final,该 value 数组存放字符串内容，引出存放在堆中的
• 不用每次都更换地址(即不是每次创建新对象)， 所以效率高于 String

String VS StringBuffer

更新的是地址VS更新的是内容

String 和 StringBuffer 相互转换

/**
 * @创建人 wdl
 * @创建时间 2024/9/3
 * @描述
 */
public class StringAndStringBuffer {
    public static void main(String[] args) {
        // StringBuffer ->String
        StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育");
        //方式 1 使用 StringBuffer 提供的 toString 方法
        String s = stringBuffer3.toString();
        //方式 2: 使用构造器来搞定
        String s1 = new String(stringBuffer3);

        // String——>StringBuffer
        String str = "hello tom";
        //方式 1 使用构造器
        //注意： 返回的才是 StringBuffer 对象，对 str 本身没有影响
        StringBuffer stringBuffer = new StringBuffer(str);
        //方式 2 使用的是 append 方法
        StringBuffer stringBuffer1 = new StringBuffer();
        stringBuffer1 = stringBuffer1.append(str);
    }
}

StringBuffer 类常见方法

增，append

s.append(',');// "hello,"
        s.append("张三丰");//"hello,张三丰"
        s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏 100true10.5"
        System.out.println(s);//"hello,张三丰赵敏 100true10.5"

删，delete（begin，end）,[begin,end)

/*
         *删除索引为>=start && <end 处的字符
         *解读: 删除 11~14 的字符 [11, 14)
         */
        s.delete(11, 14);
        System.out.println(s);//"hello,张三丰赵敏 true10.5"

改, replace(int start, int end, String str),[begin,end)

//解读，使用 周芷若 替换 索引 9-11 的字符 [9,11)
        s.replace(9, 11, "周芷若");
        System.out.println(s);//"hello,张三丰周芷若 true10.5"

查, indexOf

//查找指定的子串在字符串第一次出现的索引，如果找不到返回-1
        int indexOf = s.indexOf("张三丰");
        System.out.println(indexOf);//6

插, insert(int offset, String str),原来索引为offset 的内容自动后移

//解读，在索引为 9 的位置插入 "赵敏",原来索引为 9 的内容自动后移
        s.insert(9, "赵敏");
        System.out.println(s);//"hello,张三丰赵敏周芷若 true10.5"

转换为字符串

法一：先转换为String

法二：getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)，[begin,end)

StringBuffer stringBuffer = new StringBuffer("stringBuffer");
        char[] bufferCharArray = new char[stringBuffer.length()];
        stringBuffer.getChars(0, stringBuffer.length(), bufferCharArray, 0);

测试题

StringBuffer的append方法比直接用构造器增加更安全

/**
 * @创建人 wdl
 * @创建时间 2024/9/3
 * @描述
 */
public class StringBufferExercise01 {
    public static void main(String[] args) {
        String str = null;// ok
        StringBuffer sb = new StringBuffer(); //ok
        sb.append(str);//需要看源码 , 底层调用的是 AbstractStringBuilder 的 appendNull
        System.out.println(sb.length());//4

        System.out.println(sb);//null
        //下面的构造器，会抛出 NullpointerException
        StringBuffer sb1 = new StringBuffer(str);//看底层源码 super(str.length() + 16),str为null所以会出现空指针异常;
        System.out.println(sb1);

    }
}

stringBuffer的插入操作使用

/**
 * @创建人 wdl
 * @创建时间 2024/9/3
 * @描述
 */
public class StringBufferExercise02 {
    public static void main(String[] args) {
/*
输入商品名称和商品价格，要求打印效果示例, 使用前面学习的方法完成：
商品名	商品价格
手机	123,564.59	//比如 价格 3,456,789.88
要求：价格的小数点前面每三位用逗号隔开, 在输出。

思路分析
1.定义一个 Scanner 对象，接收用户输入的 价格(String)
2.希望使用到 StringBuffer 的 insert ，需要将 String 转成 StringBuffer
3.然后使用相关方法进行字符串的处理代码实现

*/
        //new Scanner(System.in)
        String price = "8123564.59";
        StringBuffer sb = new StringBuffer(price);
        //先完成一个最简单的实现 123,564.59
        //找到小数点的索引，然后在该位置的前 3 位，插入,即可
        //	int i = sb.lastIndexOf(".");
        //	sb = sb.insert(i - 3, ",");


        //上面的两步需要做一个循环处理,才是正确的
        for (int i = sb.lastIndexOf(".") - 3; i > 0; i -= 3) {
            sb = sb.insert(i, ",");
        }
        System.out.println(sb);//8,123,564.59
    }
}

StringBuilder 类

StringBuilder 常用方法

String、StringBuffer 和 StringBuilder 比较

区别

1. StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，而且方法也一样
2. String:不可变字符序列,效率低,但是复用率高。
3. StringBuffer:可变字符序列、效率较高(增删)、线程安全,看源码
4. StringBuilder:可变字符序列、效率最高(增删)、线程不安全
5. String使用注意说明:
   string s=“a”;//创建了一个字符串s+=“b”
   标签：Java,String,2024JavaReview,int,StringBuffer,System,println,out,顺平
   From： https://blog.51cto.com/u_15305087/11944999