java.lang.String类

概述

String：代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现

• String声明为final，不可被继承
• 字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。
• String实现了Serializable接口：表示字符串是支持序列化的。
• 实现了Comparable接口：表示String可以比较大小
• String内部定义了private final char[] value用于存储字符串数据
• 通过字面量的方式（区别于用new String()给字符串赋值），此时的字符串值声明在字符串常量池中)。
• 字符串常量池中是不会存储相同内容（使用String类的equals()比较）的字符串的。

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

String的不可变 性

1. 当对字符串重新赋值时，需要重新指定内存区域赋值
2. 当对现在的字符串进行连接操作时，也需要重新指定内存区域赋值
3. 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

总结就是只要字符串值有更改，都需要重新指定内存区域赋值。若新值在内存区域已存在，则直接指向该区域，若没有则重新开辟空间

String对象的创建

建议去看API，以下展示集几种常用的

//字面量方式
String str = "hello";	

//本质上this.value = new char[0];
String s1 = new String(); 

//this.value = s.value;
String s2 = new String(String s); 

//this.value = Arrays.copyOf(value, value.length);
String s3 = new String(char[] a); 

//从字符数组a的startIndex位置截取count个字符
String s4 = new String(char[] a,int startIndex,int count);

从上面代码可以看出String实例化主要有两种方式

• 方式一：通过字面量定义的方式
• 方式二：通过new + 构造器的方式

//通过字面量定义的方式：此时的s1和s2的数据声明在方法区中的字符串常量池中。
String s1 = "javaEE";
String s2 = "javaEE";

//通过new + 构造器的方式:此时的s3和s4保存的是地址值，指向堆空间中的数据。
String s3 = new String("javaEE");
String s4 = new String("javaEE");

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

面试题

1. String s = new String("abc");方式创建对象，在内存中创建了几个对象？
   答：两个:一个是堆空间中new结构，另一个是char[]对应的常量池中的数据："abc"

2. String str1 = "abc" 与 String str2 = new String("abc");的区别？
   

3. 字符串拼接方式赋值的对比

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;
String s9 = s1 + s2;
 
System.out.println(s3 == s4);//true
System.out.println(s3 == s5);//false
System.out.println(s3 == s6);//false
System.out.println(s3 == s7);//false
System.out.println(s5 == s6);//false
System.out.println(s5 == s7);//false  
System.out.println(s6 == s7);//false
System.out.println(s7 == s9);//false

String s8 = s6.intern();//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”
System.out.println(s3 == s8);//true
****************************
String s1 = "javaEEhadoop";
String s2 = "javaEE";
String s3 = s2 + "hadoop";
System.out.println(s1 == s3);//false

final String s4 = "javaEE";//s4:常量
String s5 = s4 + "hadoop";
System.out.println(s1 == s5);//true

1. 常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2. 只要其中一个是变量，结果就在堆中，且不管变量名是否相同开辟的空间都不同。
3. 如果拼接的结果调用intern()方法，返回值就在常量池中
4. 若变量用final修饰就变成常量

3. 下列程序运行结果

public class StringTest {
String str = new String("good");
char[] ch = { 't', 'e', 's', 't' };
public void change(String str, char ch[]) {
str = "test ok";
ch[0] = 'b'; }
public static void main(String[] args) {
StringTest ex = new StringTest();
ex.change(ex.str, ex.ch);
System.out.print(ex.str);	//good 不可变性
System.out.println(ex.ch);	//best
} }

StringBuffer、StringBuilder

• StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
• StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]

StringBuffer与StringBuilder的内存解析

//以StringBuffer为例：
String str = new String();//char[] value = new char[0];
String str1 = new String("abc");//char[] value = new char[]{'a','b','c'};

StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
System.out.println(sb1.length());//0
sb1.append('a');//value[0] = 'a';
sb1.append('b');//value[1] = 'b';

StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];
System.out.println(sb2.length());	//3

扩容问题

如果要添加的数据长度大于16，那就需要扩容底层的数组。默认情况下，扩容为原来容量的2倍 + 2，同时将原数组中的元素复制到新的数组中。

开发中建议指定长度：StringBuffer(int capacity) 或 StringBuilder(int capacity)

三者的执行效率
从高到低排列：StringBuilder > StringBuffer > String

String、StringBuffer、StringBuilder三者的对比

abstract class AbstractStringBuilder implements Appendable, CharSequence {
   
    char[] value;	//value没有final修饰，可以扩容
    
    int count;		//count记录有效字符的个数
    AbstractStringBuilder() {
    }
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

• StringBuilder 和 StringBuffer可用方法一致
• StringBuilder 和 StringBuffer都继承于AbstractStringBuilder
• StringBuffer之所以是线程安全的，是因为方法用synchronized修饰
• StringBuilder 和 StringBuffer 支持链式调用

StringBuffer类不同于String，其对象必须使用构造器生成。有三个构造器

StringBuffer()		//初始容量为16的字符串缓冲区
StringBuffer(int size)		//构造指定容量的字符串缓冲区
StringBuffer(String str)	//将内容初始化为指定字符串内容

StringBuffer 和 StringBuilder的常用方法

StringBufferappend(xxx)	//提供了很多的append()方法，用于进行字符串拼接
StringBufferdelete(int start,int end)	//删除指定位置的内容
StringBufferreplace(intstart,intend,Stringstr)	//把[start,end)位置替换为str 
StringBufferinsert(int offset,xxx)	//在指定位置插入xxx
StringBufferreverse()	//把当前字符序列逆转