String

1. 字符串的字符使用Unicode字符编码，不管是字母还是汉子都占两个字节

两种创建String对象的区别

方式一：直接复制 String s = "hsp";
方式二：调用构造器 String s2 = new String("hsp");

1. 方式一：先从常量池查看是否有"hsp"数据空间，如果有，直接指向；如果没有则重新创建然后指向。s最终指向的是常量池的空间地址
2. 方式二：现在堆中创建空间，里面维护了value属性，执行常量池的hsp空间。如果常量池没有"hsp"，重新创建，如果有，直接通过value指向。最终指向的是堆中的空间地址

String a = "abc";
String b = "abc";
System.out.println(a.equals(b)); // true
System.out.println(a == b); // true

String a = "hsp"; // a指向常量池
String b = new String("hsp"); // b指向堆中的对象
System.out.println(a.equals(b)); // true
System.out.println(a == b); // false
// 当调用intern方法时，如果池已经包含与equals(Object)方法确定的相当于此String对象的字符串，则返回来自池的字符串。 否则，此String对象将添加到池中，并返回对此String对象的引用。 b.intern()方法最终返回的是常量池的地址
System.out.println(a == b.intern()); // true
System.out.println(b == b.intern()); // false

String s1 = "hspedu"; // 
String s2 = "java"; // 
String s4 = "java"; // 
String s3 = new String("java"); // 
System.out.println(s2 == s3);//false
System.out.println(s2 == s4);//true
System.out.println(s2.equals(s3)); // true
System.out.println(s1 == s2); // false

Person p1 = new Person();
p1.name = "hspedu";
Person p2 = new Person();
p2.name = "hspedu";
System.out.println(p1.name.equals(p2.name)); // true
System.out.println(p1.name == p2.name);//true
System.out.println(p1.name == "hspedu");//true

String s1 = new String("bcde");
String s2 = new String("bcde");
System.out.println(s1 == s2); // false

字符串特性

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

// 1. 以下语句创建了几个对象 2个常量池中字符串常量对象
String s1 = "hello";
s1 = "haha";

// 创建了几个对象 1个 编译器会优化 ==>等价于 String a = "helloabc";
String a = "hello" + "abc";

String a = "hello";
String b = "abc";
String c = a+b;
String d = "helloabc";
String e = "hello" + "abc";
System.out.println(c == d);// false
System.out.println(d == e);// true
// 创建了几个对象 3个对象 分析String c = a + b;怎么执行的
//1. 创建一个StringBuilder
//2. 执行sb.append("hello");
//3. 执行sb.append("abc");
//4. 调用sb.toString();
//5. 最后其实c指向堆中的对象(String) value[] -> 池中 "helloabc"

String s1 = "hspedu";
String s2 = "java";
String s5 = "hspedujava";
Strring s6 = (s1 + s2).intern();
System.out.println(s5 == s6); // true
System.out.println(s5.equals(s6)); // true

public class Test1 {
    String str = new String("hsp");
    final char[] ch = {'j', 'a', 'v', 'a'};
    public void change(String str, char[] ch) {
        str = "java";
        ch[0] = 'h';
    }

    public static void main(String[] args) {
        Test1 ex = new Test1();
        ex.change(ex.str, ex.ch);
        System.out.print(ex.str + "and");
        System.out.println(ex.ch);
        // ex.change中理解方法栈中指向的线断了，不影响main栈
        // hsp and hava
    }
}

String常用方法 不多说了

StringBuffer

String vs StringBuffer

1. String 保存的是字符串常量，里面的值不能更改，每次String类的实际更新实际上就是更改地址，效率较低 // private final char[] value
2. StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更改内容，不用每次更改地址，效率较高// char[] value 这个放在堆

StringBuffer构造器

1. StringBuffer() 构造一个其中不带字符的字符串缓冲区，其初始容量为16个字符
2. StringBuffer(CharSequence seq) 构造一个字符串缓冲器，它包含与指定的CharSequence相同的字符
3. StringBuffer(int capacity) 构造一个不带字符，但具体指定初始容量的字符串缓冲区。即对char[]大小进行指定
4. StringBuffer(String str) 构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容，初始化为当前字符串长度+16

// String -> StringBuffer
String s = "hello";
StringBuffer b1 = new StringBuffer(s);// 返回的才是StringBuffer对象对String本身没有影响
StringBuffer b2 = new StringBuffer();
b2.append(s);
// StringBuffer -> String
String s2 = b1.toString();
String s3 = new String(b1);

StringBuffer类常见方法

1. 增 append
2. 删 delete(start, end) 将start --- end间的内容删除，不包含end
3. 改 replace(Start, end, string) 将start --- end间的内容替换掉，不包含end
4. 查 indexOf 查不到-1 返回第一次索引所在位置
5. 插 insert insert(index, string) 插入到索引位置，索引后的内容后移
6. 获取长度 length s.length()

String str = null; // ok
StringBuffer sb = new StringBuffer(); // ok
sb.append(str); // 调用父类的appendNull 将null转为"null"字符串
System.out.println(sb.length()); // 4
System.out.println(sb); // null

StringBuffer sb1 = new StringBuffer(str); // super(str.length() + 16) 空指针异常
System.out.println(sb1);

StringBuilder

1. 一个可变的字符序列。此类提供一个与StringBuffer兼容的API，但不保证同步(线程不安全)。该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议有限采用该类，因为在大多数实现中，它比StringBuffer要快
2. 在StringBuilder上的主要操作是append和insert方法，可重载这些方法以接受任意类型的数据

String、StringBuilder、StringBuffer比较

1. StringBuffer和StringBuilder 非常类似、均代表可变的字符序列，而且方法也一样
2. String：不可变字符序列，效率低，但是复用率高
3. StringBuffer：可变字符序列、效率较高(增删)、线程安全
4. StringBuilder：可变字符序列、效率最高、线程不安全
5. String使用注意说明：
   1. String s = "a"; // 创建了一个字符串
   2. s += "b"; // 实际上原来的"a"字符串对象已经丢弃，现在又产生了一个新的字符串s+"b"(也就是ab)。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象留在内存中，降低使用效率。如果这样的操作在循环中，会极大影响程序的性能