Java之String对象

String 对象

String 构造方法

• public String() 创建一个空白字符串对象，不含任何内容
• public String(char[] chs) 根据字符数组的内容，来创建字符串对象
• public String(byte[] bys) 根据字节数组的内容，来创建字符串对象
• String s = "abc" 直接赋值的方法创建字符串对象，内容就是 abc
• 推荐使用直接赋值的方法创建字符串对象

构建 String 对象的两种方法比较

• 通过构造函数创建，创建的对象是放在堆内存中的
• 通过字符串赋值的方法创建的对象是存放在字符串常量池中的

String s1 = "abc";
String s3 = "abc";
String s2 = new String(“abc");
String s4 = new String(“abc");

System.out.println(s1==s2); // false
System.out.println(s1==s3); // true
System.out.println(s1.equals(s3)); // true
System.out.println(s2==s4); // false
System.out.println(s2.equals(s4)); // true

//通过==比较的是对象的值，通过equals()比较的是对象内容
//s1存放在常量池中，它的值就是内容"abc"
//s2存放在堆内存中，它的值是堆中的地址，内容是"abc"
//所以要是比较通过构造方法构造的对象的内容需要用equals()，用==比较的是地址值，通常用来判断两个引用是否指向同一个对象
//通过赋值的对象进行比较内容的话直接用==                       

String 对象的特点

• 通过 new 创建的字符串对象（前三种），每一次 new 都会申请一个内存空间，即使内容相同，但地址是不同的
• 通过直接赋值的方法创建字符串对象，只要字符序列完全相同（顺序，大小写都相同），无论在程序中出现几次，都会只创建一个对象，用一个内存地址
• String对象是不可变的，在String类中每一个看起来会修改String对象内容的方法，实质都是创建了一个全新的String对象。

public class HelloWorld {
    public static void main(String[] args) {
        char[] chs = {'a', 'b', 'c'};
        byte[] bys = {97, 98, 99};
        String s1 = new String(chs);
        String s2 = new String(chs);
        String s3 = new String(bys);
        String s4 = "abc";
        String s5 = "abc";
      	//s5 += "def";
        System.out.println(s1 == s2);
        System.out.println(s4 == s5);
        System.out.println(s1 == s4);
        System.out.println("s1:" + s1);
        System.out.println("s3:" + s3);
        System.out.println("s4:" + s4);
        System.out.println(s1.equals(s3));
        System.out.println(s4.equals(s5));
      	System.out.println(s4.equals(s5));
    }
}
//输出：
//false
//true
//false
//s1:abc
//s3:abc
//s4:abc
//true
//true

String 字符串的比较

不能直接用 == 进行比较，因为对于引用类型，该符号比较的是地址值是否相同，无法比较内容是否相同

那么对于字符串比较内容是否相同，是通过一个方法来实现 equals()

String 字符串常用方法

• s.length()
• s.charAt()
• s.equals()

//str.length()  字符串的长度
//str.charAt(index)  遍历字符串的每个字符，注意不能直接用索引，是错的,和数组不同
//char[] chs = {1, 2, 3}
//String s = new String(chs)
//注意：chs是字符数组，s是字符串对象
//str.equals()  比较两个字符串是否内容相同

StringBuilder

StringBuilder 是一个可变的字符串，我们可以把它看作是一个容器

StringBuilder 对象的值是可变的，对字符串的增加、插入、修改、删除等操作比String高效（不需多次创建新的对象）。

因此不建议在 for 循环中使用 String 类型运算 ”+“ 进行字符串拼接，因为这样循环执行多少次那么就会创建多少个对象，浪费空间，效率低下。

StringBuilder 和 String 的区别：

• StringBuilder ：内容是可变的
• String ：内容是不可变的

StringBuilder 的添加和反转方法（String 中没有的）

如果想对字符串进行拼接和反转，可以先转为 StringBuilder 类型，在调用方法，比较简单，再转回原来 String 类型

• sb.append(任意类型) ：添加数据并返回对象本身
• sb.reverse()

public class HelloWorld {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        StringBuilder sb2 = sb.append("hello");  //返回对象本身
        System.out.println("sb:" + sb);
        System.out.println("sb2:" + sb2);
        System.out.println(sb == sb2);
    }
}
//输出：
//hello
//hello
//true

public class HelloWorld {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("hello");
        sb.append("world");
        sb.append("java");
        sb.append(100);
        System.out.println("sb:" + sb);
    }
}
//输出：
//helloworldjava100

//链式调用：
public class HelloWorld {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("hello").append("world").append("java").append(100);
        System.out.println("sb:" + sb);
        sb.reverse();
        System.out.println("sb:" + sb);
    }
}
//输出：
//sb:helloworldjava100
//sb:001avajdlrowolleh

两种类型相互转化

• String s = sb.toString() ：StringBuilder 转换为 String
• StringBuilder sb = new StringBuilder(s) ： 通过构造方法将String 转换为StringBuilder