String源码阅读

1 为什么String是不可变对象，而StringBuffer是可变对象，而StringBuffer的初始长度是多少？StringBuilder和StringBuffer的区别是什么？
可以由源码得到 String的char数组是final类型，所以一旦初始化就不可变，StringBuffer的初始长度是16。StringBuilder是线程不安全的，StringBuffer是线程安全的，因为源码中，StringBuffer的方法多被synchronized修饰，而StringBuilder没有，但是StringBuilder类在单线程中的性能比StringBuffer高，这也是引入它的原因。

 public final class String{ private final char value[];    /** Cache the hash code for the string */    private int hash; // Default to 0  } public final class StringBuffer{  /**     * The value is used for character storage.     */    char[] value;    /**     * The count is the number of characters used.     */    int count; public StringBuffer() {        super(16);    }}

2 char什么时候扩充长度呢
StringBuffer的append方法，可见如果初始长度是16，此时append一个String，长度会扩充为16*2+2，如果还达不到要求的最小长度，就直接将char字符数组的长度设置成Integer.MAX_VALUE，

public AbstractStringBuilder append(String str) {        if (str == null) str = "null";        int len = str.length();        ensureCapacityInternal(count + len);        str.getChars(0, len, value, count);        count += len;        return this;    }    /**     * This method has the same contract as ensureCapacity, but is     * never synchronized.     */    private void ensureCapacityInternal(int minimumCapacity) {        // overflow-conscious code        if (minimumCapacity - value.length > 0)            expandCapacity(minimumCapacity);    }    /**     * This implements the expansion semantics of ensureCapacity with no     * size check or synchronization.     */    void expandCapacity(int minimumCapacity) {        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);    }

3 String是重写了equals方法和hashcode方法的，这两者的区别是什么？
equals方法原本是“==”的含义，而hashcode则是返回对象的内存地址，从原则上讲，每个对象的hashcode都是不同的，而在String中，被改写成比较每个字符是不是相同。而一般情况下，equals方法重写，hashcode方法也是要被重写的，那么这两者有什么区别呢？
hashcode相同说明两个类在同一个篮子里，hashCode的存在主要是用于查找的快捷性。hashcode同，两个对象不一定相同，如果两个对象相同，就是适用于equals(Java.lang.Object) 方法，要求这两个对象的hashCode一定要相同。
以下是从别人的回帖中拷贝过来的.

1.hashcode是用来查找的，如果你学过数据结构就应该知道，在查找和排序这一章有  例如内存中有这样的位置  0  1  2  3  4  5  6  7    而我有个类，这个类有个字段叫ID,我要把这个类存放在以上8个位置之一，如果不用hashcode而任意存放，那么当查找时就需要到这八个位置里挨个去找，或者用二分法一类的算法。  但如果用hashcode那就会使效率提高很多。  我们这个类中有个字段叫ID,那么我们就定义我们的hashcode为ID％8，然后把我们的类存放在取得得余数那个位置。比如我们的ID为9，9除8的余数为1，那么我们就把该类存在1这个位置，如果ID是13，求得的余数是5，那么我们就把该类放在5这个位置。这样，以后在查找该类时就可以通过ID除 8求余数直接找到存放的位置了。  2.但是如果两个类有相同的hashcode怎么办那（我们假设上面的类的ID不是唯一的），例如9除以8和17除以8的余数都是1，那么这是不是合法的，回答是：可以这样。那么如何判断呢？在这个时候就需要定义 equals了。  也就是说，我们先通过 hashcode来判断两个类是否存放某个桶里，但这个桶里可能有很多类，那么我们就需要再通过 equals 来在这个桶里找到我们要的类。  那么。重写了equals()，为什么还要重写hashCode()呢？  想想，你要在一个桶里找东西，你必须先要找到这个桶啊，你不通过重写hashcode()来找到桶，光重写equals()有什么用啊  

4 String的hashcode和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;    }    //String s = "AB"     //s.hashcode()=2081    //2081 = 31*65+66 65是A的ASCII码     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;    }

一个例子程序，同时重写equals和hashcode方法才能得到hashset两个相同的对象，若果只重写equals，不重写hashcode方法，也不会得到相同的对象，相同的对象到底比较的是什么？

package JavaGrammer;import java.util.HashSet;import java.util.Set;public class HashTest {      private int i;      public int getI() {          return i;      }      public void setI(int i) {          this.i = i;      }      @Override    public int hashCode() {          return i % 10;      }    @Override    public boolean equals(Object object) {          if (object == null) {              return false;          }          if (object == this) {              return true;          }          if (!(object instanceof HashTest)) {              return false;          }          HashTest other = (HashTest) object;          if (other.getI() == this.getI()) {              return true;          }          return false;      }    public final static void main(String[] args) {          HashTest a = new HashTest();          HashTest b = new HashTest();          a.setI(1);          b.setI(1);          Set<HashTest> set = new HashSet<HashTest>();          set.add(a);          set.add(b);          System.out.println(a.hashCode() == b.hashCode());          System.out.println(a.equals(b));          System.out.println(set);      }  }

运行结果

truetrue[JavaGrammer.HashTest@1]

如果不重写hashcode方法

package JavaGrammer;import java.util.HashSet;import java.util.Set;public class HashTest {      private int i;      public int getI() {          return i;      }      public void setI(int i) {          this.i = i;      }     /* @Override    public int hashCode() {          return i % 10;      }*/    @Override    public boolean equals(Object object) {          if (object == null) {              return false;          }          if (object == this) {              return true;          }          if (!(object instanceof HashTest)) {              return false;          }          HashTest other = (HashTest) object;          if (other.getI() == this.getI()) {              return true;          }          return false;      }    public final static void main(String[] args) {          HashTest a = new HashTest();          HashTest b = new HashTest();          a.setI(1);          b.setI(1);          Set<HashTest> set = new HashSet<HashTest>();          set.add(a);          set.add(b);          System.out.println(a.hashCode() == b.hashCode());          System.out.println(a.equals(b));          System.out.println(set);      }  }

输出结果

falsetrue[JavaGrammer.HashTest@1e3cd51, JavaGrammer.HashTest@bc8e1e]

最后可以参考程序来自于博客关于hashcode的使用