String StringBuffer和StringBuilder

一、总述

String是字符串常量，StringBuffer和StringBuilder是字符串变量；StringBuffer线程安全而StringBuilder是不安全的

二、String与两者的区别

String：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    private final char value[];
}

String是不可变类，由final修饰，其底层结构char[ ]也是final，并且其中每个方法都没有对value的内容进行改动，一旦创建就不可修改。

String a = "idea";
a = a+"good";

如a = "good"+a，并不是在a的原地址上修改，而是创建了一个新的"ideagood"对象，并把引用给a。

StringBuffer和StringBuilder：

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

 

public final class StringBuilder extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence

StringBuffer和StringBuilder都继承自AbstractStringBuilder。

abstract class AbstractStringBuilder implements Appendable, CharSequence {
   char[] value;
}

其底层char[ ]数组并未被final修饰是字符串变量，上述a = "good"+a，实际操作为a = new StringBuffer(a).append("good").toString，它的修改是在原地址上进行的。

三、StringBuffer和StringBuilder区别

AbstractStringBuilder的append方法，ensureCapacityInternal( )函数会对char[ ]数组容量进行校验，不够会进行扩容：

 public AbstractStringBuilder append(char[] str) {
    int len = str.length;
    ensureCapacityInternal(count + len);
    System.arraycopy(str, 0, value, count, len);
    count += len;
    return this;
}

StringBuffer的所有public方法均采用Sychronized修饰，因此线程安全，但相比之下效率低于StringBuilder

@Override
public synchronized StringBuffer append(char[] str) {
   toStringCache = null;
   super.append(str);
   return this;
}

StringBuilder直接使用父类方法，不具备线程安全，但单线程下效率可观

@Override
public StringBuilder append(char[] str) {
   super.append(str);
   return this;
}

四、HashSet的唯一性问题

Set接口存入对象具有唯一性，但也存在问题：

 HashSet<StringBuilder> set2 = new HashSet<>();
StringBuilder sb1 = new StringBuilder("abc");
StringBuilder sb2 = new StringBuilder("abc");
System.out.println(sb1 == sb2);//false

set2.add(sb1);
set2.add(sb2);

Iterator<StringBuilder> it2 = set2.iterator();
while (it2.hasNext())
System.out.println(it2.next());//"abc"   "abc

sb1和sb2内容相同的不同对象，HashSet存入两个相同的值，打破了唯一性；

HashSet<String> set1 = new HashSet<>();
String s1 = new String("abc");
String s2 = "abc";
System.out.println(s1 == s2);//"false"
set1.add(s1);
set1.add(s2);
Iterator<String> it1 = set1.iterator();
while (it1.hasNext())
System.out.println(it1.next());//"abc"

s1和s2内容相同的不同对象，但set中只存入了一个值。

原因：HashSet底层是HashMap，而HashMap对对象的判断：

if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))
    break;

是通过hashcode和equals( )方法，String重写了hash函数和equals方法，不再是根据对象地址进行计算和判断，而是根据对象内容进行计算，因此s1和s2虽然地址不同，但hashcode相同，equals为true。而StringBuilder没有重写这两个方法，因此sb1和sb2尽管内容相同，因为地址不同，所以hashcode不同，equals为false。

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

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