一、字符串相关的类
1.1 String 的特性
- String类：代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
- String是一个final类，代表不可变的字符序列。
- final修饰的类不能被继承
- 字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。
- String对象的字符内容是存储在一个字符数组value[]中的。
- 数据存储结构中，有链式存储结构和顺序存储结构两种。显然String底层选择了char型数组类型的顺序存储结构。
1.2 String部分源码
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];
/** Cache the hash code for the string */
private int hash; // Default to 0
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -6849794470754667710L;
....
}
从这部分源码中，我们就可以很好的理解“1.1 String 的特性”中的内容了！！！字符串，字符串，就是字符构建起来的串。
1.3 String再次理解
1.3.1 上代码
public class StringTest {
@Test
public void test1() {
// String name = "abc"; 字面量的定义方式
String name = "abc";
String des = "abc";
name = "hell world";
System.out.println("name:"+name);// hello world
System.out.println("des:"+des);// abc
}
@Test
public void test2() {
final int a = 2;
a = 3; // 编译不通过
}
}
第一个问题：为什么name = "hell world",编译成功，并能运行，不是说“它们的值在创建之后不能更改”吗？;而test2()中却编译失败？
首先，String属性引用类型，而int是基本类型。
引用类型变量存储地址值，而a是一个指向int类型的引用，指向2这个字面值。因此final int 修饰的变量就变为常量了，常量是不能修改其值的，所以test2()编译失败。
那么怎么理解String 底层存储使用final修饰的char型数组,更改其值为什么编译成功，并能运行？简单的JVM走一波。图一：
从图中我们可以看出：
- 常量池当中，是不会存储两个相同的字符串的。
- name、des存储的是地址值。name和des都指向0x8888这个地址
图二：
从图中我们可以看出：
- 这就很好解释了为什么输出结果是name为hello world 而des依然为abc。
- 同时也解释了“它们的值在创建之后不能更改”，原始的值“abc”的确没有被修改，而是在字符串常量池中重新创建了一份。
- 这也可以看出频繁的对字符串进行增删改操作的话，很耗费内存资源。
1.3.2 初步总结
- String:字符串，使用一对""引起来表示。
- String声明为final的，不可被继承。
- String实现了Serializable接口：表示字符串是支持序列化的。
- 实现了Comparable接口：表示String可以比较大小
- String内部定义了final char[] value用于存储字符串数据
- String:代表不可变的字符序列。简称：不可变性。
- 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
- 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
- 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
- 通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
- 字符串常量池中是不会存储相同内容的字符串的。
1.4 判断对错
@Test
public void test3() {
String s1="javaWeb";
String s2="javaWeb";
String s3 = new String("javaWeb");
String s4 = new String("javaWeb");
System.out.println(s1==s2);
System.out.println(s1==s3);
System.out.println(s1==s4);
System.out.println(s3==s4);
}
直观判断：
- s1==s2。在字符串常量池中相同的字符串只会存储一份，s1和s2存储相同的地址。所以为true
- s1==s3。他们分别指向不同地方，所以为false
- s1==s4。他们分别指向不同地方，所以为false
- s3==s4。只要是new便会在堆空间中开辟一份空间，JVM才不会管你new的内容是否和前面的相同。所以为false
集合JVM判断：
结合JVM图形就可以很清楚的明白到底为什么错，为什么对了。
1.5 判断对象的属性
public class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
@Test
public void test4() {
Person p1 = new Person("Tom", 12);
Person p2 = new Person("Tom", 12);
System.out.println(p1.name==p2.name);// true?false?
}
显然为true，Tom存储在字符串常量池中,有且仅有一份。故p1.name==p2.name必然为true
再来：
@Test
public void test4() {
Person p1 = new Person("Tom", 12);
Person p2 = new Person("Tom", 12);
System.out.println(p1.name==p2.name);
p2.name="cxk";
System.out.println(p1.name==p2.name);// true?false
}
肯定是false， p2.name="cxk";会先在字符串常量池中查找，没有就在常量池中建一个， p2.name地址指向它即可。【字符串的不可变性】
1.6 拓展：
String s = new String("abc")；方式创建对象，在内存中创建了几个对象？
答：2个。一个是堆空间中new结构，另一个是char[ ]对应的常量池中的数据：”abc“;
来，搞一下这个。
public void test3(){ String s1 = "javaEE"; String s2 = "hadoop"; String s3 = "javaEEhadoop"; String s4 = "javaEE" + "hadoop"; String s5 = s1 + "hadoop"; String s6 = "javaEE" + s2; String s7 = s1 + s2; System.out.println(s3 == s4); System.out.println(s3 == s5); System.out.println(s3 == s6); System.out.println(s3 == s7); System.out.println(s5 == s6); System.out.println(s5 == s7); System.out.println(s6 == s7); String s8 = s6.intern(); System.out.println(s3 == s8); }- s3 == s4为true。字面量或者字面量之间的连接，指向同一个对象，在常量池中声明。
- s5、s6、s7都是字面量拼接变量或者变量拼接变量，他们不是在常量池中声明而是在堆中声明。可以把它想象为new，从而尽管内容相同，但是地址值却是是不相同的。
结论：
- 常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。 只要其中有一个是变量，结果就在堆中
- 如果拼接的结果调用intern()方法，返回值就在常量池中
1.7 面试题
代码一：
public class StringTest2 {
String str = new String("good");
char[] ch = {'t', 'e', 's', 't'};
public void change(String str, char ch[]) {
str = "test ok";
System.out.println("======"+str);
ch[0] = 'b';
}
public static void main(String[] args) {
StringTest2 ex = new StringTest2();
ex.change(ex.str, ex.ch);
System.out.print(ex.str + " and ");
System.out.println(ex.ch);
}
}
输出结果是多少？
解析：做这道题必须明白几个知识点
- java中方法参数的传递机制——值传递。
- 值传递。即将实际参数的副本（复制品）传入到方法内，而参数本身不受影响。
- 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参【原始值不受影响】
- 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参【因为传递副本为地址值，所以某些原始值会受影响，某些不会，如String类型具有不可变性】
- 值传递。即将实际参数的副本（复制品）传入到方法内，而参数本身不受影响。
- String类型具有不可变性。
分析：
代码二：
public class StringTest2 {
String str = new String("good");
char[] ch = {'t', 'e', 's', 't'};
public void change(String str, char ch[]) {
// 第二步：
//对于方法中的str，由于第一步的赋值操作，它的地址值和“String str = new String("good");”中的str一样，内容都为good。
//接下来方法中对它进行赋值操作“test ok”。
//由于String类型的不可变性（看源码类为final修饰，数据存储结构为也为final修饰的char型数组）,不可修改。
//因此JVM执行'str ="test ok";'时会在字符串常量池中新建一个“test ok”并且更新方法中str的地址值。
//至此两个str的地址值不同了，指向的内容也不同了。 可以看“代码三”中的对比结果。
str = "test ok";
// 第二步；
//对于方法中的ch，由于第一步的赋值操作，它的地址值和“char[] ch = {'t', 'e', 's', 't'};”中的ch一样，内容都为test。
//接下来，在方法中执行"ch[0] = 'b';" 数组中的第一个元素被赋值为b。由于是引用类型，此时类中成员变量char[] ch = {'t', 'e', 's', 't'};值也变为best。
ch[0] = 'b';
}
public static void main(String[] args) {
StringTest2 ex = new StringTest2();
// 第一步
// 传递的两个实参，参数一，实际上是把StringTest2类中成员变量str的地址值复制一份给StringTest2类中change方法中的形参变量str
// 同理，StringTest2类中成员变量ch（数组：也是引用类型）的地址值复制一份给StringTest2类中change方法中的形参变量ch[]
ex.change(ex.str, ex.ch);
System.out.print(ex.str + " and ");
System.out.println(ex.ch);
}
}
代码三：
public class StringTest2 {
String str = new String("good");
char[] ch = {'t', 'e', 's', 't'};
public void change(String str, char ch[]) {
System.out.print("赋值之前两个str的地址值比较为：");
System.out.println(this.str==str);
str = "test ok";
System.out.print("赋值之后两个str的地址值比较为：");
System.out.println(this.str==str);
System.out.println("====================分割线========================");
ch[0] = 'b';
}
public static void main(String[] args) {
StringTest2 ex = new StringTest2();
ex.change(ex.str, ex.ch);
System.out.print(ex.str + " and ");
System.out.println(ex.ch);
}
}
结果：