JDK源码分析~String

public final class String
    implements java.io.Serializable
    , Comparable<String>
    , CharSequence {}

类定义：

String实现了3个接口 Serializable , Comparable<String>, CharSequence

Serializable：提供序列化支持

Comparable：实现compareTo(String s) 比较

CharSequence：实现 length()、charAt(int index)，subSequence(int start,int end)、3个方法

类属性：

    //final修饰的字符数组，用来储存字符串
    private final char value[];

    /** 储存该字符串的哈希值 */
    private int hash; // Default to 0

    /** 默认实现序列化所需要的serialVersionUID值 */
    private static final long serialVersionUID = -6849794470754667710L;

    //用ObjectStreamField[]定义一个序列化字段
    private static final ObjectStreamField[] serialPersistentFields =
        new ObjectStreamField[0];

由private final char value[];可见，被final修饰后，赋值给String 对象后字符串的值不可修改。

构造方法：

/**给定一个空值
   String str = new String();
   此时，字符串值value[]为""
*/
public String() {
   this.value = "".value;
}

/**给定一个字符串值
   String str = new String("hello");
   此时，字符串值value[]为"hello"
*/
public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
}

/**
   将一个字符数组的指定长度数量字符转化为字符串
*/
 public String(char value[], int offset, int count) {
        //判断选取位置是否小于边界0
        if (offset < 0) {
            //抛出数组越界异常
            throw new StringIndexOutOfBoundsException(offset);
        }
        //判断待转化的字符数量是否小于0
        if (count <= 0) {
            //小于0就抛出异常
            if (count < 0) {
                throw new StringIndexOutOfBoundsException(count);
            }
            //如果起始位置小于该字符数组长度
            if (offset <= value.length) {
                this.value = "".value;
                return;
            }
        }
        //如果待转换的字符数组从开头到结尾处长度越界则抛异常
        if (offset > value.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        //如果参数校验成功，则执行转换，将字符数组拷贝到String的value[]
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }

从上面分析得出结论：因为String 并不属于基本数据类型，但是" "里面的内容被当作String来处理，于是当给一个String类型变量赋值时，如果是首次赋值，则将其存入final char value[]中，这个字符串到字符数组的转换过程应该是由编译器自动完成，当二次赋值时，由于被final修饰，且String类的特殊性质，将会在堆中重新创建一个新的对象，将这个String的引用指向内存中的新对象，旧对象将会被回收

还由其他功能的构造方法

//将指定范围的int[]转换为字符串
public String(int[] codePoints, int offset, int count)

//将指定范围的字节数组转化为字符串 hibyte!=0 转换为16位unicode编码
public String(byte ascii[], int hibyte, int offset, int count)

//将指定范围的字节数组转化为指定字符集编码的字符串
public String(byte bytes[], int offset, int length, String charsetName)

//将字节数组转化为指定字符集编码的字符串
 public String(byte bytes[], Charset charset)

//将StringBuffer 转化为String字符串
public String(StringBuffer buffer)

//将StringBuider 转化为String字符串
public String(StringBuider buffer)

类方法：

/**
    因为value[]储存的就是字符串的值，
    所以char value[]的length属性就是字符串的长度
*/
public int length() {
    return value.length;
}

/**
    判断长度为0则字符串为空
*/
public boolean isEmpty() {
    return value.length == 0;
}

/**
    直接取字符串中字符数组的索引值则为该字符串对应长度处的字符
*/
public char charAt(int index) {
    if ((index < 0) || (index >= value.length)) {
        throw new StringIndexOutOfBoundsException(index);
    }
    return value[index];
}

/**
    调用StringCoding类的encode()方法，将字符串编码为字节数组
*/
public byte[] getBytes(String charsetName)
     throws UnsupportedEncodingException {
   if (charsetName == null) throw new NullPointerException();
       return StringCoding.encode(charsetName, value, 0, value.length);
}

下面看一下最常用的方法equals:

/**
  比较2个字符串对象内容是否相等
*/    
public boolean equals(Object anObject) {
        //如果2个对象相等，则他们指向的是内存中同一个字符串对象，值必相等
        if (this == anObject) {
            return true;
        }
        //判断下anObject 的值是否为String类型
        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++;
                }
                //比较通过，返回true
                return true;
            }
        }
        return false;
    }

比较compareTo

    public int compareTo(String anotherString) {
        //取字符串长度
        int len1 = value.length;
        int len2 = anotherString.value.length;
        //比较2个字符串长度取最小
        int lim = Math.min(len1, len2);
        //缓存值
        char v1[] = value;
        char v2[] = anotherString.value;
        int k = 0;
        //循环直至比较到不同的字符，返回该2个字符的ascill差值
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        //如果2个字符串是111222和111这种关系则返回长度差值
        return len1 - len2;
    }

字符串截取

/**
    从指定位置开始截取至字符串末尾
*/
public String substring(int beginIndex) {
        //截取长度起始点不能超左边界
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        //截取长度起始点不能超右边界
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        //返回一个新new的字符串
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
    }