JAVA进阶: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,并赋值给第二个String3.将第二个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引用的是个新的falsetruefalsefalse重点: --两个字符串常量或者字面量相加，不会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类的equalspublic 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