java常用类（上）

public class Test1 {
    public static void main(String[] args) {
        int n=10;
        //手动装箱  int->Integer
        Integer x=Integer.valueOf(n);
        //手动拆箱  Integer->int
        int y=x.intValue();
        //自动装箱
        int a=20;  //底层调用的是 Integer.valueOf(20);
        Integer integer=a;
        //自动拆箱
        int a2=integer; //底层调用的是 intValue()方法
    }
}

1.4Integer创建机制

请看如下代码，试着输出运行结果

public class Test2 {
    public static void main(String[] args) {
        Integer s1=new Integer(10);
        Integer s2=new Integer(10);
        System.out.println( s1==s2 );

        Integer n1=100;
        Integer n2=100;
        System.out.println( n1==n2 );

        Integer m1=128;
        Integer m2=128;
        System.out.println( m1==m2 );
    }
}

运行结果：false true false。

解释：

（1）对于第一种创建方式new Integer() 因为new在堆上开辟了新的空间，s1和s2是两个不同的对象，==对于引用数据类型比较的是地址，故为false.

（2）第二种创建方式

源码：

这里的cache是一个存储器，Integer类里把-128到127范围内的数字全部创建了一个对象存在cache了，所以装箱的时候在这个范围的话直接返回存储器里的对象了，不用每次都new新的堆空间。

对于n1、n2在-128~127范围内，没有开辟新的空间，故其相等；而对于m1、m2不在-128~127范围内，需要new一个空间，是两个不同的对象，故为false。

1.5Integer比较问题

  public static void main(String[] args) {

        Integer n1=129;
        int n2=129;
        Integer n3=129;
        System.out.println(n1==n2);
        System.out.println(n1==n3);
        
    }

结论：

（1）只要有基本数据类型int，比较的就是数值，否则为空间地址。

（2）对于Integer integer=int 装箱方式，int在-128~127范围内不会new新空间，否则将会new新空间。

（3）==比较引用数据类型比较的是空间地址是否相等。

二、String

2.1基本介绍

（1）String对象用于保存字符串，也就是一组字符序列

（2）字符串常量对象是用双引号括起来的字符序列；

（3）字符串的字符使用Unicode字符编码，一个字符（不分字母还是汉字）占两个字节；

（4）String类的构造方法很多；

（5）String类实现了接口Serializable,即String可以串行化：可以在网络传输；

String类实现了接口Comparable,即String对象可以比较大小。

（6）String是final类，不能被其他的类继承

（7）String有属性private final char value[]，用于存放字符串内容，同时，value是一个final类型的属性，不可以被修改。

2.2 String对象的创建方式

方式一：直接赋值

String str1="hello";

方式二：调用构造器

String str2=new String("hello")

创建机制理解：

方式一：先从常量池查看是否有"hello"数据空间，如果有，直接指向；如果没有，则重新创建，然后指向最终的常量池的空间，str1最终指向的是常量池中的地址

方式二：先在堆中创建空间，里面维护了value属性，指向常量池的"hello"数据空间，如果常量池也没有"hello"，则重新创建；如果有，直接通过value指向，str2最终指向的是堆中的空间的地址。

2.3 String比较问题

补充知识点：

（1）当调用intern方法时，如果池已经包含与equals(Object)方法确定的相当于此String对象的字符串，则返回来自池的字符串。否则，此String对象将添加到池中，并返回对此String对象的引用。即str.intern()最终返回的是常量池的地址。

（2）String类中的equals方法是重写过的，比较的是值。其源码如下：

例题：

    public static void main(String[] args) {
        String str1="hello";
        String str2=new String("hello");
        System.out.println(str1==str2);
        System.out.println(str1.equals(str2));
        System.out.println(str1==str2.intern());
        System.out.println(str2==str2.intern());
    }

答案为 false true true false

2.4字符串特性

2.4.1介绍

（1）String是一个final类，代表不可变的字符序列。

（2）字符串是不可变的，一个字符串对象一旦分配，其内容是不可变的。

请看如下代码，试问其分别创建了几个对象？

①

  String str="hello";
  str="world";

创建了两个对象：hello、world

②

String str="hello"+"world";

创建了一个对象：helloworld;

解释：String str="hello"+"world"编译时在底层优化等价于String str="helloworld"。

③

String a="hello";
String b="world";
String c=a+b;

创建了3个对象，其执行流程为：

2.4.2总结：

String str1="ab"+"cd;常量相加，看的是常量池；

String str2=a+b;变量相加，是在堆中

2.4.3例题：

把运行结果发到评论区

public class Test6 {
    public static void main(String[] args) {
        A a = new A();
        a.exchange(a.str,a.ch);
        System.out.print(a.str+" and ");
        System.out.println(a.ch);
    }
}

class A{
    String str="hello";
    final char[] ch={'j','a','v','a'};
    public void exchange(String str,char[]ch){
        str="abc";
        ch[0]='z';
    }
}

2.5 String常用方法

**①equals:**区分大小写，判断内容是否相等

②equalsIgnoreCase:忽略大小写，判断内容是否相等

**③length:**获取字符的个数，字符串长度

④indexOf:获取字符在字符串中第一次出现的索引（下标），索引从0开始，如果找不到，返回-1

⑤lastIndexOf:获取字符在字符串中最后一次出现的索引（下标），索引从0开始，如果找不到，返回-1

**⑥subString:**截取指定范围的字符串

**⑦trim:**去前后空格

**⑧charAt:**获取某所引出的字符，注意不能使用Str[index]这种方式

**⑨replace：**替换字符串中的字符

**⑩compareTo:**比较两个字符串的大小

**⑪toCharArray:**将字符串转换为字符数组

**⑫format：**格式字符串,%s字符串，%c字符，%d整形，%f浮点型

**⑬split:**分割字符串，对于某些分割字符，我们要转义，例如：\ ->\\

在使用String类方法时，有看不懂的，建议看源码（ctrl+左键进入源码）

三、StringBuffer

3.1基本介绍

（1）java.lang.StringBuffer代表可变的字符串序列，可以对字符串内容进行增删

（2）StringBuffer是个容器。

（3）很多方法与String相同，但StringBuffer是可变长度的。

3.2StringBuffer比较String

（1）String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上是更改地址，效率较低

（2）StringBuffer保存的是字符串常量，里面的值可以更改，每次StringBuffer的更新实际上可以更改内容，不用每次更新地址，效率较高。

3.3StringBuffer的构造器

（1）StringBuffer()

构造一个其中不带字符的字符串缓冲区，其初始容量为16个字符

（2）StringBuffer(CharSequence seq)

构造一个字符串缓冲区，它包含与指定的CharSequence相同的字符

（3）StringBuffer(int capacity)

构造一个不带字符，但具有指定初始容量的字符串缓冲区，即对char[]大小进行指定

（4）StringBuffer(String str)

构造一个字符缓冲区，并将其内容初始化为指定的字符串内容

3.4String和StringBuffer相互转换

（1）String->StringBuffer

①使用构造器

String str="hello";
StringBuffer sb=new StringBuffer(str);

②使用append方法

String str="hello";
StringBuffer sb=new StringBuffer();
sb=sb.append(str);

（2）StringBuffer->String

①使用StringBuffer提供的toString方法

StringBuffer sb=new StringBuffer("hello");
String str=sb.toString();

②使用构造器

StringBuffer sb=new StringBuffer("hello");
String str=new String(sb);

3.5 StringBuffer类常见方法

**①append：**拼接追加字符串

**②delete：**删除指定字符串

**③replace(start ,end,String)：**将start~end间的内容替换掉，不含end,即[start,end)。

**④indexOf：**查找子串在字符串第一次出现的索引，索引从0开始，找不到返回-1

**⑤insert：**在指定位置插入字符串

⑥length:获取字符的个数，字符串长度

四、StringBuilder

4.1基本介绍

（1）StringBuilder的直接父类是AbstractStringBuilder，StringBuilder实现了Serializable接口，即StringBulider的对象可以串行化；在父类中AbstractStringBuilder有属性char[]value,不是final类型，该value数组存放字符串内容，引出存放在堆中的。

（2）StringBuffer是一个final类，不能被继承

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

（4）StringBuilder是一个可变的字符序列，提供一个与StringBuffer兼容的API，但不保证同步（StringBuilder线程不安全），该类被设计用作StringBuffer的一个简单替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先使用该类，现实中，它比StringBuffer快

（5）在StringBuilder上的主要操作是append和insert方法，可重载这些方法，以接受任意类型数据。

（6）StringBuilder 的方法，没有做互斥的处理,即没有synchronized 关键字,因此在单线程的情况下使用

4.2 StringBuilder常用方法

StringBuilder有与StringBuffer兼容的API，可以往看StringBuffer类常见方法

4.3 String、StringBuffer、StringBuilder的比较

（1）StringBuffer和StringBuilder非常类似，均代表可变的字符序列，而且方法也一样。

（2）String是不可变字符序列，效率低，但是复用率高

（3）StringBuffer是可变字符序列，效率较高（增删），线程安全

（4）StringBuilder是可变字符序列，效率最高，线程不安全。

（5）String使用注意事项

String s="a";
s+="b;

执行上诉代码时，原来的"a"已经丢弃了，现在又产生了一个字符串s+"b"(也就是ab);

如果多次执行这些改变字符串内容的操作，会导致大量副本字符串对象留在内存中，减低效率，如果这样的操作放到循环中，会极大影响程序的性能。所以，如果我们对String做大量修改时，不要使用String.

4.4 String、StringBuffer、StringBuilder的使用选择

（1）如果字符串存在大量的修改操作，一般使用StringBuffer或StringBuilder；

（2）如果字符串存在大量的修改操作，并在单线程的情况下，使用StringBuilder；

（3）如果字符串存在大量的修改操作，并在多线程的情况下，使用StringBuffer；

（4）如果字符串存在少量的修改操作，并被多个对象引用，使用String。

结语

感谢您的耐心阅读，希望这篇博客能够为您带来新的视角和启发。如果您觉得内容有价值，不妨动动手指，给个赞👍，让更多的朋友看到。同时，点击关注🔔，不错过我们的每一次精彩分享。若想随时回顾这些知识点，别忘了收藏⭐，让知识触手可及。您的支持是我们前进的动力，期待与您在下一次分享中相遇！

路漫漫其修远兮，吾将上下而求索。