String类源码分析(JDK1.7)

以下学习根据JDK1.7String类源代码做注释

 

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
//String类是final的，也就是说String类不允许被继承，实现了Serializable接口(可以序列化和反序列化),Comparale(可以进行自定义的字符串比较) 
CharSequence(一个可读序列。此接口对许多不同种类的 char 序列提供统一的只读访问。StringBuilder 和StringBuffer也实现了这个接口)

private final char value[]; //用于存放string字符的数组
private int hash; //表示string字符的哈希值，默认为0

 

//默认构造方法，一般不用，因为String字符串是不可改变的        
    public String() {
            this.value = new char[0];
    }
//有参构造方法，使用已存在的一个字符串创建一个相同字符序列的字符串
    public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }    
 //使用一个字符数组创建一个字符串
    public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
        //使用Arrays类复制字符数组并赋值给String类声明的value
    }    
 
 //使用字符数组的一部分创建一个字符串对象 offset字符数组开始位置，count数组开始位置往后的长度  
    public String(char value[], int offset, int count) {
        if (offset < 0) {
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count < 0) {
            throw new StringIndexOutOfBoundsException(count);
        }
        // Note: offset or count might be near -1>>>1.
        if (offset > value.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }    

//将字节数组从offset开始，长度为length并以chatsetName编码转换成字符串
    public String(byte bytes[], int offset, int length, String charsetName)
            throws UnsupportedEncodingException {
        if (charsetName == null)
            throw new NullPointerException("charsetName");
        checkBounds(bytes, offset, length);
        this.value = StringCoding.decode(charsetName, bytes, offset, length);
    }

    //返回字符串的长度    
    public int length() {
        return value.length;
    }
//判断字符串长度是否为0
    public boolean isEmpty{
        retutn value.length==0
    
    }        
//根据下标获取字符
   public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }
    
    //equals 比较的是值
    public boolean equals(Object anObject) {
        if (this == anObject) {//如果是同一个对象，返回true
            return true;
        }
        if (anObject instanceof String) { //判断是否是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;
    }

//采用乘法hash算法，字符串相同hash值一定相同，hash值相同，不一定字符串相同
   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值乘31+该字符
            }
            hash = h;
        }
        return h;
    }