JAVA笔记（十六）：包装类、String类、StringBuffer、StringBuider

常用类

一、包装类 Wrapper

1、包装类的分类和继承关系

包装类的继承关系

2、包装类和基本数据的转换

public class Test {
    public static void main(String[] args) {
        int n1 = 10;
        //jdk5以前：手动装箱和拆箱
        //手动装箱 int->Integer
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);
        //自动装箱：int->Integer
        Integer integer3 = n1;  //底层还是Integer.valueOf(n1);

        //手动拆箱 Integer->int
        int i = integer.intValue();
        //自动拆箱Integer->int
        int i2 = integer3;     //底层还是integer3.intValue();
    }
}

3、包装类型和String类型的相互转换

1. 包装类型 -----> String类型
   Integer n = 10; //自动装箱

   • 方式1：String s1 = n.toString();
   • 方式2：String s2 = String.valueOf(n);
   • 方式3：String s3 = n + "";

2. String类型 -----> 包装类型

   • 方式1：Integer j1 = new Integer(s1); //构造器
   • 方式2：Integer j2 = Integer.valueOf(s2);
   • 方式3：Integer j3 = Integer.parseInt(s3); //parseInt返回int型，再自动装箱成Integer类

4、包装类方法

1. MIN_VALUE / MAX_VALUE

System.out.println(Integer.MIN_VALUE);//返回最小值
System.out.println(Integer.MAX_VALUE);//返回最大值

2. isDigit() / isLetter() / isUpperCase() / isLowerCase() / isWhitespace() /

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'));//判断是不是空格

3. toUpperCase() / toLowerCase()

System.out.println(Character.toUpperCase('a'));//转成大写
System.out.println(Character.toLowerCase('A'));//转成小写

5、练习

【第一题】

---

【第二题】
判断正误

public static void main(String[] args) {
	  Integer i = new Integer(1);
	  Integer j = new Integer(1);
	  System.out.println(i == j); //False (new出来的对象不相同）
	
	  Integer m = 1; //底层 Integer.valueOf(1)
	  Integer n = 1;
	  System.out.println(m == n); //true
	
	  Integer x = 128; //底层 Integer.valueOf(128)
	  Integer y = 128;
	  System.out.println(x == y); //false
}

原因：底层valueOf源码：

解释：

• 传入的参数如果在范围内，就不new一个对象（从cache数组中直接取Integer对象）。
• 超出范围，则会new

IntegerCache的范围：[-128 , 127]

---

【第三题】

二、String类⭐⭐⭐⭐⭐

1、String类的理解

1）String是final类，不能被其他的类继承
2）String中有属性 private final char value[]; 用于存放字符串内容
3）一定要注意：value是一个final类型，不可以修改（value的地址不可修改，但是value数组元素值可以修改）（本质是----final的是数组对象，对象不可以修改，但是对象内容可以修改）

2、String类的继承关系

3、String创建对象

1. 常用构造器：
   

2. 直接赋值创建和调用构造器创建的对比
   
   

4、练习题

【第一题】
判断正误

输出：

true
true //解释：a和b都指向常量池中"abc"的地方

---

【第二题】
判断正误
（intern方法的作用：返回字符串在常量池里的地址）

输出：

true
false //(a指向常量池，b指向堆里开辟的对象空间）
true //b.intern()返回的是"hsp"在常量池里的地址
false

---

【第三题】

输出：

true
true
true

false

---

【第四题】

String s1 = "hello"的对象是"hello"不是s1，s1只是引用

这里可以看到，"hello"对象的value，地址为492，指向的是[h,e,l,l,o]，这个指向是不能改变的。但可以通过value[0]='b'这种方式更改其中的值

---

进行s1=“haha"后，内存首先看"haha"是否已经存在于常量池中。没有则在其他地方创建一个"haha”。
所以"haha"对象的value，地址为494。

---

而s1作为一个引用，没有不能更改值的要求，所以被赋值成haha的地址
验证：

下面是对象的地址。上面的494 492是value地址

所以创建了两个对象：“hello"和"haha”

---

【第五题】

所以答案是1个

---

【第六题】

String a = "hello";
String b = "abc";
String c = a+b;  //这句话和String c = "hello" + "abc"不一样
创建了几个对象？
String d = "helloabc";
System.out.println(c == d); //真还是假？

创建了4个对象
String类型a对象
String类型b对象
StringBuilder类型的sb对象（在含变量的字符串拼接时调用new StringBuilder())
String类型对象（在含变量的字符串拼接时，拼接完成后由toString调用 new String()）

System.out.println(c == d); //false

---

小结：

---

【第七题】

输出：

hsp and hava

---

【第八题】

public class Test {
    public static void main(String[] args){
        String str = "abcdef";
public class Test {
    public static void main(String[] args){
        String str = "abcdef";
        try {
            str = reverse(str, -2, 4);
        } catch(RuntimeException e) {
            System.out.println(e.getMessage());
            return; //执行了这句，catch后面的语句就不会执行
        }
        System.out.println(str);
    }

    public static String reverse(String str, int start, int end) {
        //编程思想：！！！！
        //校验条件：写出正确的情况，然后取反
        if(!(str != null && start >=0 && end < str.length() && end > start)){
            throw new RuntimeException("参数设置不正确");
        }
        char[] chars = str.toCharArray();
        int i = start;
        int j = end;
        char temp = 0;
        //对称翻转
        while(i < j){
            temp = chars[i];
            chars[i] = chars[j];
            chars[j] = temp;
            i++;
            j--;
        }
        //char[]变String
        return new String(chars);
    }
}

5、String类的常见方法

1. equals //区分大小写，判断内容是否相等

2. equalsIgnoreCase //忽略大小写的判断内容是否相等

String str = "joG";
System.out.println(str.equalsIgnoreCase("jog"));  //true

3. length //获取字符的个数，字符串长度

4. indexOf //获取子串在字符串中第1次出现得索引，索引从0开始，如果找不到，返回-1

String str = "wer@terwe@gwe";
System.out.println(str.indexOf('@'));  //3
System.out.println(str.indexOf("we")); //0

5. lastIndexOf //获取子串在字符串中最后1次出现的索引，索引从0开始，如果找不到，返回-1

String str = "wer@terwe@gwe";
System.out.println(str.indexOf('@'));  //9
System.out.println(str.indexOf("we")); //11

6. substring //截取指定范围子串

String str = "hello,张三";
System.out.println(str.substring(6));  //从索引为6地方开始取，一直到结束。结果：张三
System.out.println(str.substring(2,4)); //取出索引为[2,4)的元素。（从2开始，截取到4-1=3的位置）结果：ll

7. trim //去除前后空格

String str = " hello 张三 ";
System.out.println(str.trim());  //hello 张三

8. charAt //获取某索引处的字符

9. toUpperCase //转换成大写

String str = "hello";
System.out.println(str.trim());  //HELLO

10. toLowerCase //转换成小写

String str = "HELLO";
System.out.println(str.trim());  //hello

11. concat //拼接字符串

String s1 = "宝玉";
s1 = s1.concat("林黛玉").concat("薛宝钗").concat("together").
System.out.println(s1);  //宝玉林黛玉薛宝钗together

12. replace //替换字符串中的字符
    注意：s1.replace()方法执行后，返回的结果才是替换过的

String s1 = "宝玉 and 薛宝钗 薛宝钗 薛宝钗";
str = s1.replace("薛宝钗","林黛玉"); //注意：s1.replace()方法执行后，返回的结果才是替换过的
System.out.println(str);  //宝玉 and 林黛玉 林黛玉 林黛玉
System.out.println(s1);  //宝玉 and 薛宝钗 薛宝钗 薛宝钗

13. split //分割字符串，对于某些分割字符串，我们需要 转义比如 | \\ 等

String poem = "春天来了，夏天来了，秋天来了，冬天来了";
String[] split = poem.split("，");  //以 ，为标准，对poem进行分割，返回一个数组

for (int i = 0; i < split.length; i++) {
    System.out.println(split[i]);
}

//输出：
春天来了
夏天来了
秋天来了
冬天来了

String poem = "E:\\aaa\\bbb";
//String[] split = poem.split("\\");  //报错，需要转义
String[] split = poem.split("\\\\");  //报错，需要转义

for (int i = 0; i < split.length; i++) {
    System.out.println(split[i]);
}

//输出：
E:
aaa
bbb

14. toCharArray //转换成字符数组

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

//chs:['h','e','l','l','o']

15. compareTo //比较两个字符串的大小，如果前者大，则返回正数，后者大，则返回负数，相等返回0
    

lim = min(len1,len2) //两个字符串长度更小的那个长度

先一个个字母比较，前者减后者

如果有不相同的，则return

如果比完了前面几个数都相同，则return 两个长度相减

//情况一
String str1 = "jack";
String str2 = "jafkk";
System.out.println(str1.compareTo(str2)); //-3  （c-f==-3）

//情况二
String str1 = "jack";
String str2 = "jacka";
System.out.println(str1.compareTo(str2)); //-1  （len1-len2 == -1）

16. format //格式字符串
    占位符有：

• %s 字符串
• %c 字符
• %d 整型
• %.2f 两位小数浮点型

 public static void main(String[] args) {
    String name = "john";
    int age = 20;
    double score = 98.3;
    char gender = '男';
    String info1 = "姓名:" + name + "年龄:" + age + "成绩:" + score + "性别:" + gender;
    String info2 = String.format("姓名:%s年龄:%d成绩:%.2f性别:%c", name,age,score,gender);
    System.out.println(info1);
    System.out.println(info2);
    
    //输出：
    姓名:john年龄:20成绩:98.3性别:男
    姓名:john年龄:20成绩:98.30性别:男
}

三、StringBuffer⭐⭐⭐

1、基本介绍

重点：StringBuffer中存放字符串的数组value不是final

2、StringBuffer继承关系图

3、StringBuffer和String的对比

4、StringBuffer的构造器

public static void main(String[] args) {
    //① 创建一个大小为 16 的char[]，用于存放字符内容
    StringBuffer stringBuffer = new StringBuffer();

    //② 通过构造器指定char[]大小
    StringBuffer stringBuffer1 = new StringBuffer(100);

    //③ 通过给一个String创建StringBuffer, char[] 大小就是 字符串长度+16
    StringBuffer stringBuffer2 = new StringBuffer("hello");
}

5、String和StringBuffer相互转换

1. String —> StringBuffer

String str1 = "hello";
//方式1 使用构造器
StringBuffer stringBuffer1 = new StringBuffer(str1);
//方式2 使用append方法
StringBuffer stringBuffer2 = new StringBuffer();
stringBuffer2 = stringBuffer1.append(str1);

2. StringBuffer —> String

StringBuffer stringBuffer3 = new StringBuffer("hello");
//方式1 使用StringBuffer提供的toString方法
String str2 = stringBuffer3.toString();
//方式2 使用构造器
String str3 = new String(stringBuffer3);

6、StringBuffer常见方法

1. append 增

StringBuffer s = new StringBuffer("hello");

s.append(',');
s.append("world");
s.append(10).append(true).append(9.9);
System.out.println(s);  //hello,world10true9.9

2. delete 删

StringBuffer s = new StringBuffer("hello world");

//删除[3,9)的字符
s.delete(3,9);
System.out.println(s);  //helld

3. replace 改

StringBuffer s = new StringBuffer("hello world");

//修改[0,5)的字符
s.replace(0, 5, "breatiful");
System.out.println(s);  //breatiful world

4. indexOf 查找

StringBuffer s = new StringBuffer("hello world");

//查找指定子串在字符串第一次出现的索引，如果找不到返回-1
//int indexOf = s.indexOf('w'); //报错，只能查找子串（字符串），不能查找字符
int indexOf1 = s.indexOf("w");
int indexOf2 = s.indexOf("aa");
System.out.println(indexOf1); //6
System.out.println(indexOf2); //-1

5. insert 插入

StringBuffer s = new StringBuffer("hello world");

//在指定位置插入字符串
s.insert(6, "beatiful ");//在索引为6的位置插入beatiful，原先索引为6的子串后移
System.out.println(s);  //hello beatiful world

6. length 长度

StringBuffer s = new StringBuffer("hello world");

System.out.println(s.length()); //11

7、练习题

【第一题】

---

【第二题】

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入商品名称：");
        String name = scanner.next();
        System.out.print("请输入商品价格：");
        StringBuffer price = new StringBuffer(scanner.next());
        System.out.println("商品名\t商品价格");

		//获取小数点的索引
        int index = price.lastIndexOf(".");
		//循环插入逗号
        for (int i = index-3; i > 0 ; i-=3) {
            price.insert(i, ",");
        }
        System.out.println(name + "\t\t" + price);
    }
}

四、StringBuilder⭐⭐⭐

1、基本介绍

2、StringBuilder继承关系图

3、StringBuilder常用方法

StringBuilder 和 StringBuffer均代表可变的字符序列，方法是一样的。所以使用和StringBuffer一样

4、String、StringBuffer和StringBuilder比较⭐⭐⭐⭐⭐

效率：
StringBuilder > StringBuffer > String

使用String+拼接时，每循环一次，就会重新new一个StringBuffer对象（底层源码）

public class Test {
    public static void main(String[] args) {
        long startTime = 0L;
        long endTime = 0L;

        String text = "";
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");

        //================StringBuffer=====================
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));

        //================StringBuilder=====================
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));

        //===================String=========================
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
        	//每循环一次，就会重新new一个StringBuffer对象
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));
    }
}

//结果

使用结论：