String源码分析

概述

在分析String的源码之前，打算先介绍一点关于JVM的内存分布，这样有助于我们更好地去理解String的设计：

Method Area：方法区，当虚拟机装载一个class文件时，它会从这个class文件包含的二进制数据中解析类型信息，然后把这些类型信息（包括类信息、常量、静态变量等）放到方法区中，该内存区域被所有线程共享，本地方法区存在一块特殊的内存区域，叫常量池（Constant Pool）。
Heap：堆是Java虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域，Java中的。
Stack：栈，又叫堆栈或者虚拟机栈。JVM为每个新创建的线程都分配一个栈。也就是说,对于一个Java程序来说，它的运行就是通过对栈的操作来完成的。栈以帧为单位保存线程的状态。JVM对栈只进行两种操作：以帧为单位的压栈和出栈操作。我们知道,某个线程正在执行的方法称为此线程的当前方法。
Program Count Register：程序计数器，又叫程序寄存器。JVM支持多个线程同时运行，当每一个新线程被创建时，它都将得到它自己的PC寄存器（程序计数器）。如果线程正在执行的是一个Java方法（非native），那么PC寄存器的值将总是指向下一条将被执行的指令，如果方法是 native的，程序计数器寄存器的值不会被定义。 JVM的程序计数器寄存器的宽度足够保证可以持有一个返回地址或者native的指针。
Native Stack：本地方法栈，存储本地方方法的调用状态。

常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。Java把内存分为堆内存跟栈内存，前者主要用来存放对象，后者用于存放基本类型变量以及对象的引用。

正文

继承关系

先看一下文档中的注释。

• Strings are constant; their values can not be changed after they are created.
  Stringbuffers support mutable strings.Because String objects are immutable they can be shared. Forexample:
• String 字符串是常量，其值在实例创建后就不能被修改，但字符串缓冲区支持可变的字符串，因为缓冲区里面的不可变字符串对象们可以被共。

通过注释跟继承关系，我们知道String被final修饰，而且一旦创建就不能更改，并且实现了CharSequence,Comparable以及Serializable接口。

final：

• 修饰类:当用final修饰一个类时，表明这个类不能被继承。也就是说，String类是不能被继承的，
• 修饰方法：把方法锁定，以防任何继承类修改它的含义。
• 修饰变量：修饰基本数据类型变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

String类通过final修饰，不可被继承，同时String底层的字符数组也是被final修饰的，char属于基本数据类型，一旦被赋值之后也是不能被修改的，所以String是不可变的。

CharSequence

CharSequence翻译过来就是字符串，String我们平常也是叫作字符串，但是前者是一个接口，下面看一下接口里面的方法：

    int length();
    char charAt(int index);
    CharSequence subSequence(int start, int end);
    public String toString();
    }

方法很少，并没有看到我们常见的String的方法，这个类应该只是一个通用的接口，那么翻一翻它的实现类

CharSequence的实现类里面出现了我们很常见的StringBuilder跟StringBuffer,先放一放，一会儿再去研究他们俩。

成员变量

private final char value[];//final字符数组，一旦赋值，不可更改
private int hash;  //缓存String的 hash Code，默认值为 0
private static final ObjectStreamField[] serialPersistentFields =new ObjectStreamField[0];//存储对象的序列化信息

构造方法

空参数初始化

 public String(){
  this.value = "".value;
}
//将数组的值初始化为空串，此时在栈内存中创建了一个引用，在堆内存中创建了一个对象
//示例代码
String str = new String()
str = "hello";

• 1.先创建了一个空的String对象
• 2.接着又在常量池中创建了一个”hello”,并赋值给第二个String
• 3.将第二个String的引用传递给第一个String

这种方式实际上创建了两个对象

String初始化

public String(String original){
  this.value = original.value;
  this.hash = original.hash;
}
//代码示例
String str=new String("hello")

创建了一个对象

字符数组初始化

public String(char value[]){
//将传过来的char拷贝至value数组里面
    this.value = Arrays.copyOf(value, value.length);
}

字节数组初始化

不指定编码

public String(byte bytes[]){
  this(bytes, 0, bytes.length);
}
public String(byte bytes[], int offset, int length){
  checkBounds(bytes, offset, length);
    this.value = StringCoding.decode(bytes, offset, length);
}

static char[] decode(byte[] ba, int off, int len){
    String csn = Charset.defaultCharset().name();
  try{ //use char set name decode() variant which provide scaching.
         return decode(csn, ba, off, len);
  } catch(UnsupportedEncodingException x){
   warnUnsupportedCharset(csn);
  }
  try{
  //默认使用 ISO-8859-1 编码格式进行编码操作
    return decode("ISO-8859-1", ba, off, len);  } catch(UnsupportedEncodingException x){
    //异常捕获}

指定编码

String(byte bytes[], Charset charset)
String(byte bytes[], String charsetName)
String(byte bytes[], int offset, int length, Charset charset)
String(byte bytes[], int offset, int length, String charsetName)

byte 是网络传输或存储的序列化形式，所以在很多传输和存储的过程中需要将 byte[] 数组和String进行相互转化，byte是字节，char是字符，字节流跟字符流之间转化肯定需要指定编码，不然很可能会出现乱码， bytes 字节流是使用 charset 进行编码的，想要将他转换成 unicode 的 char[] 数组，而又保证不出现乱码，那就要指定其解码方式

通过”SB”构造

···
public String(StringBuffer buffer) {
synchronized(buffer) {
this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
}
}
public String(StringBuilder builder) {
this.value = Arrays.copyOf(builder.getValue(), builder.length());
}
···
很多时候我们不会这么去构造，因为StringBuilder跟StringBuffer有toString方法，如果不考虑线程安全，优先选择StringBuilder。

equals方法

  public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

• 1.先判断两个对象的地址是否相等
• 1. 再判断是否是String类型
• 3.如果都是String类型，就先比较长度是否相等，然后在比较值

hashcode方法

    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

• 1.如果String的length==0或者hash值为0，则直接返回0
• 2.上述条件不满足，则通过算法s[0]31^(n-1) + s[1]31^(n-2) + … + s[n-1]计算hash值
  我们知道，hash值很多时候用来判断两个对象的值是否相等，所以需要尽可能保证唯一性，前面在分析HashMap原理的时候曾经提到过，冲突越少查询的效率也就越高。

intern方法

 public native String intern();

• Returns a canonical representation for the string object. A pool of strings, initially empty, is maintained privately by the class . When the intern method is invoked, if the pool already contains a string equal to this object as determined by the method, then the string from the pool is returned. Otherwise, this object is added to the pool and a reference to this object is returned. It follows that for any two strings { s} and { t}, { s.intern() == t.intern()} is { true}if and only if {s.equals(t)} is { true}.
• 返回一个当前String的一个固定表示形式。String的常量池，初始化为空，被当前类维护。当此方法被调用的时候，如果常量池中包含有跟当前String值相等的常量，这个常量就会被返回。否则，当前string的值就会被加入常量池，然后返回当前String的引用。如果两个String的intern()调用==时返回true,那么equals方法也是true.

翻译完了，其实就是一句话，如果常量池中有当前String的值，就返回这个值，如果没有就加进去，返回这个值的引用，看起来很厉害的样子。

String对“+”的重载

我们知道，”+”跟”+=”是Java中仅有的两个重载操作符，除此之外，Java不支持其它的任何重载操作符，下面通过反编译来看一下Java是如何进行重载的：

public static void main(String[] args) {
     String str1="wustor";
     String str2= str1+ "Android";
}

反编译Main.java，执行命令 javap -c Main，输出结果

可能看不懂所有的代码，但是我们看到了StringBuilder,然后看到了wustor跟Android，以及调用了StringBuilder的append方法。既然编译器已经在底层为我们进行优化，那么为什么还要提倡我们有StringBuilder呢？
我们仔细观察一下上面的第三行代码，new 了一个StringBuilder对象，如果有是在一个循环里面，我们使用”+”号进行重载的话就会创建多个StringBuilder的对象，而且，即时编译器都帮我们优化了，但是编译器事先是不知道我们StringBuilder的长度的，并不能事先分配好缓冲区，也会加大内存的开销，而且使用重载的时候根据java的内存分配也会创建多个对象，那么为什么要使用StringBuilder呢，我们稍后会分析。

switch

• 1.首先调用String的HashCode方法,拿到相应的Code
• 2.通过这个code然后给每个case唯一的标识
• 3.通过标识来执行相应的操作

我觉得挺好奇，所以接着查看一下如果是char类型的看看switch是怎么转换的

    public static void main(String[] args) {
        char ch = 'a';
        switch (ch) {
            case 'a':
                System.out.println("hello");
                break;
            case 'b':
                System.out.println("world");
                break;
            default:
                break;
        }
    }

基本上跟String差不多，就不多解释了，由此可以看出，Java对String的Switch支持实际上也还是对int类型的支持。

StringBuilder

由于String对象是不可变的，所以在重载的时候会创建多个对象，而StringBuilder对象是可变的，可以直接使用append方法来进行拼接，下面看看StringBuilder的拼接。

public final class StringBuilder extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{

     // 空的构造方法
    public StringBuilder () {
        super(16);
    }
    //给予一个初始化容量
    public StringBuffer(int capacity) {
        super(capacity);
    }
    //使用String进行创建
    public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }
  @Override
    public StringBuilder append(CharSequence s) {
        super.append(s);
        return this;
    }

我们看到StringBuilder都是在调用父类的方法，而且通过继承关系，我们知道它是AbstractStringBuilder 的子类，那我们就继续查看它的父类，AbstractStringBuilder 实现了Appendable跟CharSequence 接口，所以它能够跟String相互转换

成员变量

    char[] value;//字符数组
    int count;//字符数量

构造方法

    AbstractStringBuilder() {
    }
   AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

可以看到AbstractStringBuilder只有两个构造方法，一个为空实现，还有一个为指定字符数组的容量，如果事先知道String的长度，并且这个长度小于16，那么就可以节省内存空间。他的数组和String的不一样，因为成员变量value数组没有被final修饰所以可以修改他的引用变量的值，即可以引用到新的数组对象。所以StringBuilder对象是可变的

append方法

通过图片可以看到，append有很多重载方法，其实原理都差不多，我们拿char举例子

  @Override
    public AbstractStringBuilder append(char c) {
        ensureCapacityInternal(count + 1);//检测容量
        value[count++] = c;
        return this;
    }
    //判断当前字节数组的容量是否满足需求
    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0)
        //目前所需容量超出value数组的容量，进行扩容
            expandCapacity(minimumCapacity);
    }
    //开始扩容
    void expandCapacity(int minimumCapacity) {
    //将现有容量扩充至value数组的2倍多2
        int newCapacity = value.length * 2 + 2;
        if (newCapacity - minimumCapacity < 0)
          //如果扩容后的长度比需要的长度还小，则跟需要的长度进行交换
            newCapacity = minimumCapacity;
        if (newCapacity < 0) {
            if (minimumCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        //将数组扩容拷贝
        value = Arrays.copyOf(value, newCapacity);
    }

insert方法

insert也有很多重载方法，下面同样以char为例

    public AbstractStringBuilder insert(int offset, char c) {
        //检测是否需要扩容
        ensureCapacityInternal(count + 1);
        //拷贝数组
        System.arraycopy(value, offset, value, offset + 1, count - offset);
        //进行赋值
        value[offset] = c;
        count += 1;
        return this;
    }

StringBuffer

跟StringBuilder差不多，只不过在所有的方法上面加了一个同步锁而已，不再赘述。

equals与==

equals方法：由于String重新了Object的equas方法，所以只要两个String对象的值一样，那么就会返回true.
==:这个比较的是内存地址，下面通过大量的代码示例，来验证一下刚才分析的源码

其他常用方法

valueOf() 转换为字符串
trim() 去掉起始和结尾的空格
substring() 截取字符串
indexOf() 查找字符或者子串第一次出现的地方
toCharArray()转换成字符数组
getBytes()获取字节数组
charAt() 截取一个字符　
length() 字符串的长度
toLowerCase() 转换为小写

总结

• String被final修饰，一旦被创建，无法更改
• String类的所有方法都没有改变字符串本身的值，都是返回了一个新的对象。
• 如果你需要一个可修改的字符串，应该使用StringBuilder或者 StringBuffer。
• 如果你只需要创建一个字符串，你可以使用双引号的方式，如果你需要在堆中创建一个新的对象，你可以选择构造函数的方式。
• 在使用StringBuilder时尽量指定大小这样会减少扩容的次数，有助于提升效率。