字符串优化处理

    public static void main(String[] args) {
        String str1 = "aaa";
        String str2 = "aaa";
        String str3 = new String("aaa");

        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        System.out.println(str1 == str3.intern());
    }

true
false
true

Process finished with exit code 0

public String substring(int beginIndex)
public String substring(int beginIndex, int endIndex)

    if (beginIndex < 0){

        throw new StringIndexOutOfBoundsException(beginIndex);

    }

    if (endIndex > count){

        throw new StringIndexOutOfBoundsException(beginIndex);

    }

    if (beginIndex > endIndex){

        throw new StringIndexOutOfBoundsException(endIndex - beginIndex);

    }

    return ((beginIndex == 0) && (endIndex == count)) ? this : new String(offset + beginIndex, endIndex - beginIndex, value);

}

在方法的最后一行，返回一个新建的String对象。查看String的构造函数：
```java

    this.value = value;

    this.offset = offset;

    this.count = count;

}

源码注释中说明，这是一个包作用域的构造函数，其目的是为了能高效且快速的共享String内的char数组对象。但在这种通过偏移量来截取字符串的方法中，String的原生内容value数组被复制到新的子字符串中。设想，如果原始字符串很大，截取的字符串长度却很短，那么截取的子字符串中包含了原生字符串的所有内容，并占据了响应的内存空间，而仅仅通过偏移量和长度来决定自己的实际取值。这种算法提高了运算速度却浪费了大量的内存空间。
（String的这个构造函数使用了以空间换时间的策略，浪费了内存空间，却提高了字符串的生成速度。）
以下以一个实例来说明该方法的弊端：
```java

public static void main(String[] args) {

    List<String> handler = new ArrayList<>();

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

        HugeStr h = new HugeStr();

        //ImprovedHugeStr imp = new ImprovedHugeStr();

        handler.add(h.getSubString(1, 5));

    }

}

static class HugeStr{

    // 一个很长的String

    private String str = new String(new char[10000000]);

    // 截取字符串，有溢出

    public String getSubString(int begin, int end){

        return str.substring(begin, end);

    }

}

static class ImprovedHugeStr{

    private String str = new String(new char[10000000]);

    // 截取子字符串，并重新生成

    public String getSubString(int begin, int end){

        return new String(str.substring(begin, end));

    }

}

HugeStr.getSubString()在不到1000次的时候就出现了内存溢出。
而ImprovedHugeStr能够很好的工作的关键是因为它使用没有内存泄漏的String构造函数重新生成String对象，使得由subString（）方法返回的，存在内存泄漏问题的String对象失去所有的强引用，从而被垃圾回收器识别为垃圾对象进行回收，保证了系统内存的稳定。

#### 字符串分割和查找
-------------------------------------------
字符串分割和查找也是字符串处理中最常用的方法之一。字符串分割将一个原始字符串，根据某个分隔符，切割成一组小字符串。String对象的split（）方法便实现了这个功能：
```java

以上代码是split（）函数的原型，它提供了非常强大的字符串分割功能。传入参数可以是一个正则表达式，从而进行复杂逻辑的字符串分割。
比如字符串“a;b,c:d”,分别使用了分号、逗号、冒号分隔了各个字符串，这时，如果需要将这些分隔符去掉，只保留字母内容，只需要使用正则表达式即可：
```java

对正则表达式的支持，使split（）函数本身具有强大的功能，强当地使用，可以起到事半功倍的效果。但是，就简单的字符串分割功能而言，它的性能表现却不尽人意。

##### 最原始的字符串分割
使用以下代码生成一个String对象，并存放在str变量中。
```java

    StringBuffer sb = new StringBuffer();

    for (int i = 0; i < 1000; i++){

        sb.append(i);

        sb.append(";");

    }

    str = sb.toString();

然后，使用split根据";"对字符串进行分割：

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

        str.split(";");

    }

    System.out.println("对str进行10000次分割用时cost:" + (System.currentTimeMillis() - start));

执行结果：
```java

在我的计算机上执行上述分割，共用时462毫秒。是否有更快的发方法完成类似的简单字符串分割呢？来看一个StringTokenizer类。

##### 使用效率更高的StringTokenizer类分割字符串
StringTokenizer类时JDK中提供的专门用来处理字符串分割字串的工具类。它的典型构造函数如下：
```java

其中str参数是要分割处理的字符串，delim是分割符号。当一个StringTokenizer对象生成后，可以通过nextToken（）方法便可以得到下一个分割的字符串。通过hasMoreTokens（）方法可以得到是否有更多的子字符串需要处理。使用StringTokenizer完成上述例子中的分割任务：
```java

    StringTokenizer stringTokenizer = new StringTokenizer(str, ";");

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

        while (stringTokenizer.hasMoreTokens()) {

            stringTokenizer.nextToken();

        }

    }

    stringTokenizer = new StringTokenizer(str, ";");

    System.out.println("StringTokenizer对str进行10000次分割用时cost:" + (System.currentTimeMillis() - start2));

运行结果：
```java

同样在我的计算机上，使用StringTokenizer分割用时只有13毫秒。即使在这段代码中StringTokenizer对象被不断创建并销毁，但其效率仍然明显高于split（）方法。

##### 更优化字符串分割方法
字符串分割是否还能有继续优化的余地呢？有的！那就是自己手动完成字符串分割的算法。为了完成这个算法，我们需要使用String的两个方法indexOf()和subString().在前面我们提到过，subString（）是采用时间换取空间技术，因此它的执行速度相对会很快，只要处理好内存溢出问题，便可大胆使用。
而indexOf（）函数是一个执行速度非常快的方法，它的原型如下：
```java

它返回指定字符在String对象中的位置。
下面我们开始完成自定义分割算法，并同样对str对象进行处理。方法同样执行1万次。
```java

    for (int i = 0; i < 2; i++){

        while (true){

            String splitStr = null;

            // 找分割符的位置

            int j = str.indexOf(";");

            // 没有分隔符存在

            if (j<0)

                break;

            // 找到分隔符，截取字符串

            splitStr = str.substring(0, j);

            // 剩下需要处理的字符串

            str = str.substring(j+1);

        }

    }

    System.out.println("自定义分割算法对str进行10000次分割用时cost:" + (System.currentTimeMillis() - start));

执行结果：
```java

看到我们自定义的分割算法耗时只用了2毫秒。这也说明了indexOf()和subString（）执行速度非常之快，很适合作为高频函数使用。

#### 高效率的charAt()方法
-----------------------------------------------
在上述例子中indexOf()方法是用于检索字符串中index位置的字符，它具有很高的效率，String还提供了一个同样高效，但是作用相反的方法，通过位置检索字符：charAt（），其原型如下：
```java

在软件开发过程中，经常会遇到这样的问题：判断一个字符串的开始和结束子串是否等于某个字串。如：判断字符串str，是否以“Java”开头,以“JDK”结尾。
判断以什么开头：
```java

判断以什么结尾：
```java

但即使是这样的内置函数，其效率也是远远低于charAt（）方法的。来验证下：
```java

    // 初始化一个大字符串

    String str = null;

    StringBuffer sb = new StringBuffer();

    for (int i = 0; i < 100000; i++){

        sb.append(i);

    }

    str = sb.toString();

    // 使用startWith() & endWith()

    long start1 = System.currentTimeMillis();

    for (int i=0; i <100000; i++){

        str.startsWith("Java");

        str.endsWith("Jdk");

    }

    System.out.println("使用startWith() & endWith()执行100000用时cost:" + (System.currentTimeMillis() - start1));

    // 使用charWith()方法

    long start2 = System.currentTimeMillis();

    int len = str.length();

    for (int i=0; i <100000; i++){

        // charAt()判断是否“Java”开头

        if (str.charAt(0) == 'J' && str.charAt(1) == 'a' && str.charAt(2) == 'v' && str.charAt(3) == 'a' );

        // charAt()判断是否“Jdk”结尾

        if (str.charAt(len-1) == 'J' && str.charAt(len-2) == 'd' && str.charAt(len-3) == 'k');

    }

    System.out.println("使用charWith()执行100000用时cost:" + (System.currentTimeMillis() - start2));

}

执行结果：
```java