String类
-
String对象用于保存字符串，也就是一组字符序列
-
字符串常量对象是用双引号括起的字符序列，例如 “Kerwin”
-
字符串的字符使用Unicode字符编码，一个字符（不区分字母还是汉字）占两个字节
-
String类较常用构造方法
String s1 = new String();
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(char[] ,int startIndex,int count);
String 实现了Serializable和Comparable 接口，说明String可以串行化，String对象可以比较大小
可串行化：可以在网络传输
- String是final 类，不能被其他的类继承
- String有属性private final char value[]; 用于存放字符串内容
- 一定要注意： value 是一个final类型，赋值之后不可修改；
- 这里的不可修改是指地址不可修改，不是指字符串内容不可修改，即value不能指向新的地址，但是单个字符内容是可以变化
final char[] value = {'a','b','c'};
value[0]= 'H';//这样修改value数组中的值是可以的，不会报错
char[] value2 = {'t','o','m'};//再创建一个char数组
// value = value2;//此时就会报错，不能再value指向新的数组了
//但是，如果把上面的final去掉，则上面的语句不会报错
创建String 对象的两种方式
-
直接赋值String s = “essence”；
-
先从常量池查看是否有“essence”数据空间，如果有，直接指向；如果没有则重新创建，
然后指向，s 最终指向的是常量池中的空间地址
-
-
调用构造器String s = new String(“essence”)；
-
先在堆中创建空间，里面维护了value属性，指向了常量池中的“essence”空间，如果常量池中没有“essence”，
重新创建，如果有，直接通过value指向，最终指向的是堆中的空间地址
-
练习
//输出如下
true //String已经重写了equals方法，所以二者内容相同，返回true
true //a和b二者都是先到常量池去看有没有“abc”,发现有，则二者指向的地址是一样的，所以return true
//输出如下
true //重写equals后，比较的是内容，二者内容相同，所以true
false //二者指向的地址不同
true
false
String a = "hsp";// a 指向常量池中的“hsp”;
String b = new String("hsp");//b 指向堆中的对象，堆中对象的value再指向常量池中的“hsp”;
System.out.println(a.equals(b));//此时重写之后，比较的是字符串内容，返回true
System.out.println(a==b);//a指向的是常量池中的“hsp”,b是指向堆的，堆中有个对象，对象中有个value。
//value指向常量池中的“hsp”,而a、b指向的对象不同，所以return false
System.out.println(a==b.intern());
//a的内容是“hsp”,b.intern()会去看对象b的内容是什么，是hsp,它就到常量池中看，有没有一个字符串也是hsp
// 之前已经放进去了hsp到常量池中，此时是有的，如果有的话，它就直接把这个hsp返回，此时再比较，
//二者都是hsp,自然就相等，返回true了
System.out.println(b==b.intern());
//此中的b指向的是堆中的对象，而b.intern()则指向的是常量池中的“hsp”,
//二者不一样，所以return false
//拓展普及
当调用intern方法时，如果池中已经包含了一个等于此String对象的字符串(用equals(Object)方法确定)，则返回池中的字符串，
否则，将该String对象添加到池中，并返回此String对象的引用
//b.intern()方法最终返回的是常量池的地址（对象）
//输出如下
false
//二者指向的对象不同，前者指向常量池中的“Java”，而后者指向堆，堆中的value指向常量池中的“Java”
true
//二者的内容相同,所以指向常量池中的同一位置，so相等
true
//equals比较的是内容，二者内容相同，所以true
false
//二者内容都不同，就要各自在常量池中创建，二者指向常量池中的指向不同
//输出如下
true
//equals比较内容，所以相等
true
//二者的name指向的都是常量池中的“hspedu”,指向相同，so true
true
//前者指向常量池中的“hspedu”,后者本就是在常量池中，so true
false
//二者是指向两个不同的对象，指向不同，无非二者的name属性值相同罢了
字符串的特性
说明：
- String是一个final类，代表不可变的字符序列
- 字符串是不可变的，一个字符串对象一旦被分配，其内容是不可变的
//千万不要认为第二个语句是把常量池中的“hello”给直接覆盖替换了，
//第二个语句，它会先看常量池中有没有“haha”,如果有，那就直接指向，反之，
//它就会在常量池中创建“haha”,然后让s1重新指向“haha”,原先指向“hello”的那条线就莫得了
//综上，在常量池中创建了两个对象
//String a = "hello" + "abc",这个语句编译器会将其优化为String a = "helloabc"
//所以，综上，创建了一个对象
//分析
1.编译器不傻，做一个优化，判断创建的常量池对象，是否有引用指向
//如果创建了3个，那么单个的hello、abc，没人用，你说创建它干什么
2.String a = "hello"+"abc"; ---> String a = "helloabc";
//注意，此中的String c = a+b 和 String "hello"+"abc"是不一样的哈
String c = a + b;
//剖析底层执行流程
1.创建一个StringBuilder sb = StringBuilder();
2.执行 sb.append("hello");
3.sb.append("abc");
4.String c = sb.toString();// toString()方法底层仍然是new
5.最后，其实是c指向堆中的String类型对象，其中的value数组再指向池中的"helloabc"
//所以，综上创建了3个对象，a、b指向常量池中对象，c指向堆
如果此时再来句String d = "helloabc";试问下面这句的返回值
System.out.println(d==c);
//答案是false,因为c指向的是堆中的对象，而d指向的是常量池中的"helloabc";
//重要规则：
String c = "ab" + "cd"; 常量相加，看的是池；String c1 = a + b ;变量相加，是在堆中;
再来多问一句：
String d = "helloabc";
System.out.println(d==c);//此时返回的就是true哟，因为二者都是指向池的；
//输出入下
true
true
解析：
//s6是指向常量池中的hspedujava
//
hsp and hava
/**
new String("hsp") 这一行首先在常量池中查找是否有 "hsp" 字符串。如果没有，
则在常量池中创建 "hsp"。
然后通过 new String("hsp") 在堆中创建一个新的 String 对象，并将该对象的值设为 "hsp"，
并且 str 引用指向这个堆中的 String 对象。inal char[] ch = {'j', 'a', 'v', 'a'}
创建了一个字符数组 ch，该数组存储在堆中。数组的内容为 {'j', 'a', 'v', 'a'}，
ch 引用指向这个堆中的数组。调用 ex.change(ex.str, ex.ch); 时，
ex.str 和 ex.ch 被传递到 change 方法中。
在 Java 中，参数传递是按值传递的。对于引用类型，传递的是引用的副本。
在 change 方法中，str 变量指向了一个新的字符串 "java"，
这个字符串查找常量池中是否有 "java"，如果没有，则在常量池中创建 "java" 字符串，
并让 str 变量指向这个常量池中的 "java"。
需要注意的是，这里 change 方法中的 str 是 ex.str 的副本，
对它的修改不会影响 ex.str 原本的引用。
因此，ex.str 仍然指向堆中那个值为 "hsp" 的 String 对象。
ch[0] = 'h'; 这行代码修改了数组 ch 的第一个元素，将其从 'j' 改为 'h'。
由于 ch 是一个引用，传递的是引用的副本，但它仍然指向堆中的同一个数组，
因此这个修改会影响到 ex.ch 数组。
最终，ex.ch 的内容变为 {'h', 'a', 'v', 'a'}。
因为在 change 方法中对 str 的修改没有影响到原始的 ex.str，
所以此时输出语句中ex.str 仍然是 "hsp"。
而ex.ch 数组被修改过，因此其内容为 {'h', 'a', 'v', 'a'}，打印时会输出 "hava"。
因此，最后的输出结果是 hsp and java */
