字符串优化策略

1.String对象以及其特点
1）不变性
指的是String对象形成就不能对其进行改变。
2）针对常量池的优化
当两个String对象有相同的值的时候，他们只引用常量池中同一个拷贝。
3）类的final定义
final类型定义也是String对象的重要特点。这是对系统安全性的保护。
2.subString()方法的内存泄漏（存在于JDK1.7版本之前）
之前的subString实现方法。

   public String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > count) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    if (beginIndex > endIndex) {
        throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
    }
    return ((beginIndex == 0) && (endIndex == count)) ? this :
        new String(offset + beginIndex, endIndex - beginIndex, value);
    }

其中String构造方法是

    // Package private constructor which shares value array for speed.
    String(int offset, int count, char value[]) {
    this.value = value;
    this.offset = offset;
    this.count = count;
    }

这样的实现方式还是在引用之前的value，虽然以空间换取时间的策略赚取了效率，但浪费了内存空间，造成内存泄漏。
新的subString（）改成了如下形式：

  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.offset = 0;
        this.count = count;
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }

3.字符串分割和查找方法
1）初级分割方式split()
2）效率更高的StringTokenizer类
3）使用indexOf（）和subString（）以空间换取时间策略自定义字符串分割
4.StringBuffer和StringBuilder
因为String不可以更改，频繁修改String会降低性能，故可以使用JDK提供的创建和修改字符串的工具——StringBuffer和StringBuilder。
1）String常量的累加操作

String result="String"+"and"+"String"+"append"

  StringBuilder result=new StringBuilder();
  result.append("String");
  result.append("and");
  result.append("String");
  result.append("append");

方法一快于方法二，因为JVM在编译时就将方法一优化成了

String result="StringandStringappend"

2)String变量的累加操作

String str1="String";
String str2="and";
String str3="String";
String str4="append";
String result=str1+str2+str3+str4;

String str1="String";
String str2="and";
String str3="String";
String str4="append";
String s=
(new StringBuilder(String.valueOf(str1))).append(str2).append(str3).append(str4).toString();

方法一被编译器编译成使用StringBuilder做累加，所以上面两段代码运行效率没有差别。
3）构建超大的String对象

for(int i=0;i<10000;i++){
    str=str+i;
}

for(int i=0;i<10000;i++){
  result=result.concat(String.ValueOf(i));
}

StringBuilder sb=new StringBuilder();
for(int i=0;i<10000;i++){
  sb.append(i);
}

在这三种情况下的效率是：第一种慢于第二种，第二种远慢于第三种。耗时参考值是：1062ms、360ms、0ms。
情况一的代码在这时并没有被编译成StringBuilder的方案，而是

for(int i=0;i<CIRCLE;i++)
  str=(new StringBuilder(String.valueof(str))).append(i).toString();

4)StringBuffer与StringBuilder之间的抉择
两者之间并没有什么差别，因为都继承了AbstractStringBuilder抽象类，拥有几乎相同的对外接口，但是StringBuffer对几乎所有方法都做了同步，而StringBuilder没有。所以StringBuilder的效率略高于StringBuffer，但在多线程系统中StringBuilder没有办法保证线程安全，不能使用。
5)容量参数
无论是StringBuilder或者StringBuffer，在初始化时都可以设置一个容量参数。在不制定容量参数时，默认是十六个字节。在追加字符串的时候，如果需要容量超过实际char数组长度，则需要进行扩容。策略是大小翻倍。
所以如果知道需要使用的StringBuilder/StringBuffer的大小并设置好，可以省略翻倍的操作从而提升性能。