JDK源码阅读（二）：String源码分析

/*
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:
*/
public final class String implements java.io.Serializable, 
        Comparable<String>, CharSequence 

接口中的方法
    length(): int
    charAt(): char
    subSequence(int,int):CharSwquence 
    toString(): String 
    chars(): IntStream
    codePoints(): IntStream

 public String() {
     this.value = "".value;
 }

String str=new String("abc");
1.先创建一个空的String对象
2.常量池中创建一个abc,并赋值给第二个String
3.将第二个String的引用传递给第一个String
注:如果常量池中有abc,则不用创建,直接把引用传递给第一个String

public String(String original) {
    this.value = original.value;
    this.hash = original.hash;
}

案例:  String str=new String("str");  

public String(char value[]) {
    this.value = Arrays.copyOf(value, value.length);
}

注:将传过来的char数组copy到value数组里

public String(byte bytes[]) {
        this(bytes, 0, bytes.length);
    }

public String(byte bytes[], int offset, int length, Charset charset) {
        if (charset == null)
            throw new NullPointerException("charset");
        checkBounds(bytes, offset, length);
        this.value =  StringCoding.decode(charset, bytes, offset, length);
    }

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[]数组,
而又保证不出现乱码,那就要指定其解码方法

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

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;
    }

String重写了父类Object的equals方法
    先判断地址是否相等(地址相等的情况下,肯定是一个值,直接返回true)
    在判断是否是String类型,不是则返回false
    如果都是String,先判断长度,
    再比较值,把值赋给char数组,遍历两个char数组比较
   

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;
    }

如果String的length==0或者hash值为0,则直接返回0
如果上述条件不满足,则通过算法计算hash值

public native String intern();
注:方法注释会有写到,意思就是调用方法时,
如果常量池有当前String的值,就返回这个值,没有就加进去,返回这个值的引用

String str1="a";
String str2="b";
String str3="ab";
String str4 = str1+str2;
String str5=new String("ab");
System.out.println(str5==str3);//堆内存比较字符串池
 //intern如果常量池有当前String的值,就返回这个值,没有就加进去,返回这个值的引用
System.out.println(str5.intern()==str3);//引用的是同一个字符串池里的
System.out.println(str5.intern()==str4);//变量相加给一个新值，所以str4引用的是个新的
System.out.println(str4==str3);//变量相加给一个新值，所以str4引用的是个新的
false
true
false
false
重点: --两个字符串常量或者字面量相加，不会new新的字符串,其他相加则是新值,(如 String str5=str1+"b";)
因为在jvm翻译为二进制代码时，会自动优化，把两个值后边的结果先合并，再保存为一个常量。

public final class StringBuilder  extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence{
    
    //空构造，初始大小16
    public StringBuilder() {
        super(16);
    }
    
    //给予一个初始化容量
    public StringBuilder(int capacity) {
        super(capacity);
    }
    
    //使用String进行创建
    public StringBuilder(String str) {
        super(str.length() + 16);
        append(str);
    }
    
    //String创建和CharSequence类型创建,额外多分配16个字符的空间，
    //然后调用append将参数字符添加进来,(字符串缓冲区)
    public StringBuilder(CharSequence seq) {
        this(seq.length() + 16);
        append(seq);
    }
}
我们可以看到方法内部都是在调用父类的方法,
通过继承关系,我们是知道它的父类是AbstractStringBuilder,
父类里实现类Appendable跟CharSequence 接口，所以它能够跟String相互转换

 AbstractStringBuilder() {
    }
    
AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }
父类里是只有两个构造方法,一个为空实现,一个为指定字符数组的容量,
如果事先知道String的长度小于16,就可以节省内存空间,
他的数组和String的不一样,因为成员变量value数组没有被final修饰,
所以可以修改他的引用变量的值,即可以引用到新的数组对象,
所以StringBuilder对象是可变的

append有很多重载方法,原理都差不多
我们以String举例

//传入要追加的字符串
public AbstractStringBuilder append(String str) {
        //判断字符串是否为null
        if (str == null)        
            return appendNull();
            
        //不为null,获得它的长度
        int len = str.length(); 
        
        //调用方法，把原先长度+追加字符串长度的和传入方法
        ensureCapacityInternal(count + len);    
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }
    
    
    
    //判断是否满足扩展要求
private void ensureCapacityInternal(int minimumCapacity) {
        // 和-原先字符串长度是否>0  肯定是大于0的
        if (minimumCapacity - value.length > 0)
            //调用复制空间的方法，和当参数
            expandCapacity(minimumCapacity);
    }
    
    
    //开始扩充
void expandCapacity(int minimumCapacity) {
        //先把原先长度复制2倍多2
        int newCapacity = value.length * 2 + 2;
        
        //判断newCapacity-和是否<0
        if (newCapacity - minimumCapacity < 0)
            //小于0的情况就是你复制的长度不够，那就把和的长度给复制的长度
            newCapacity = minimumCapacity;
            
            //正常逻辑怎么着都走不到这一步，新长度肯定是大于0
        if (newCapacity < 0) {
            if (minimumCapacity < 0) // overflow
                throw new OutOfMemoryError();
            newCapacity = Integer.MAX_VALUE;
        }
        
        //将数组扩容拷贝
        value = Arrays.copyOf(value, newCapacity);
    }
    

insert同样有很多重载方法，下面以char和String为例
insert的ensureCapacityInternal(count + 1);和上面一样，不做讲解了

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;
    }
    
    
public AbstractStringBuilder insert(int offset, String str) {
        //判断要插入的坐标是否在字符串内，不再则报数组下标越界
        if ((offset < 0) || (offset > length()))
            throw new StringIndexOutOfBoundsException(offset);
        //判断要插入的是否为null
        if (str == null)
            str = "null";
        //获得要插入的字符串长度    
        int len = str.length();
        //检查是否满足扩充条件
        ensureCapacityInternal(count + len);
        //拷贝数组
        System.arraycopy(value, offset, value, offset + len, count - offset);
        str.getChars(value, offset);
        count += len;
        return this;
    }

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

跟StringBuilder差不多，只不过在所有的方法上面加了一个同步锁

String类重写了父类equals的方法
我们先看下父类的
//直接判断地址
public boolean equals(Object obj) {
        return (this == obj);
    }
    
    
再看下String类的equals
public boolean equals(Object anObject) {
    //地址相等肯定为true,就不用继续往下走了
        if (this == anObject) {
            return true;
        }
    //地址不相等的情况下，比较两个字符的内容是否一样
    //把字符串方法char[]数组里，遍历比较
        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;
    }

基本数据类型比较值
引用数据类型比较地址值
    （对象的引用，在堆空间，String在字符串池，newString在堆空间）

String被final修饰，一旦创建无法更改，每次更改则是在新创建对象
StringBuilder和StringBuffer则是可修改的字符串

StringBuilder和StringBuffer的区别
    StringBuffer 被synchronized 修饰，同步，线程安全
    StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
    如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer。
    
原文链接：https://juejin.im/post/5c0fb9bbe51d451dd867a96a