码哥，String 还能优化啥？你是不是框我？

莫慌，明天给大家见识一下不一样的 String，从根上拿捏中转 G 点。

并且码哥分享一个例子：通过性能调优咱们能实现百兆内存轻松存储几十 G 数据。

String对象是咱们每天都「摸」的对象类型，然而她的性能问题咱们却总是疏忽。

爱她，不能只会简略一起游玩，要深刻理解String 的内心深处，做一个「心有猛虎，细嗅蔷薇」的暖男。

通过以下几点剖析，咱们一步步揭开她的衣裳，中转内心深处，晋升一个 Level，让 String 间接腾飞：

1. 字符串对象的个性；
2. String 的不可变性；
3. 大字符串构建技巧；
4. String.intern 节俭内存；
5. 字符串宰割技巧；

String 身材解密

想要深刻理解，就先从根本组成开始……

「String 缔造者」对 String 对象做了大量优化来节俭内存，从而晋升 String 的性能：

Java 6 及之前

数据存储在 char[]数组中，String通过 offset 和 count两个属性定位 char[] 数据获取字符串。

这样能够高效疾速的定位并共享数组对象，并且节俭内存，然而有可能导致内存透露。

共享 char 数组为啥可能会导致内存透露呢？

String(int offset, int count, char value[]) {
    this.value = value;
    this.offset = offset;
    this.count = count;
}

public String substring(int beginIndex, int endIndex) {
    //check boundary
    return  new String(offset + beginIndex, endIndex - beginIndex, value);
}

调用 substring() 的时候尽管创立了新的字符串，但字符串的值 value 依然指向的是内存中的 同一个数组，如下图所示：

如果咱们仅仅是用 substring 获取一小段字符，而原始 string字符串十分大的状况下，substring 的对象如果始终被援用。

此时 String 字符串也无奈回收，从而导致内存泄露。

如果有大量这种通过 substring 获取超大字符串中一小段字符串的操作，会因为内存泄露而导致内存溢出。

JDK7、8

去掉了 offset 和 count两个变量，缩小了 String 对象占用的内存。

substring 源码：

public String(char value[], int offset, int count) {this.value = Arrays.copyOfRange(value, offset, offset + count);
}

public String substring(int beginIndex, int endIndex) {
    int subLen = endIndex - beginIndex;
    return new String(value, beginIndex, subLen);
}

substring() 通过 new String() 返回了一个新的字符串对象，在创立新的对象时通过 Arrays.copyOfRange() 深度拷贝了一个新的字符数组。

如下图所示：

String.substring 办法不再共享 char[]数组的数据，解决了可能内存透露的问题。

Java 9

将 char[]字段改为 byte[]，新增 coder属性。

码哥，为什么这么改呢？

一个 char 字符占 2 个字节，16 位。存储单字节编码内的字符（占一个字节的字符）就显得十分节约。

为了节约内存空间，于是应用了 1 个字节占 8 位的 byte 数组来寄存字符串。

勤俭节约的女神，谁不爱……

新属性 coder 的作用是：在计算字符串长度或者应用 indexOf（）办法时，咱们须要依据编码类型来计算字符串长度。

coder 的值别离示意不同编码类型：

• 0：示意应用 Latin-1（单字节编码）；
• 1：应用UTF-16。

String 的不可变性

理解了 String 的根本组成之后，发现 String 还有一个比外在更性感的个性，她被 final 关键字润饰，char 数组也是。

咱们晓得类被 final 润饰代表该类不可继承，而 char[]被 final+private 润饰，代表了 String 对象不可被更改。

String 对象一旦创立胜利，就不能再对它进行扭转。

final 润饰的益处

安全性

当你在调用其余办法时，比方调用一些零碎级操作指令之前，可能会有一系列校验。

如果是可变类的话，可能在你校验过后，它的外部的值又被扭转了，这样有可能会引起重大的零碎解体问题。

高性能缓存

String不可变之后就能保障 hash值得唯一性，使得相似 HashMap容器能力实现相应的 key-value 缓存性能。

实现字符串常量池

因为不可变，才得以实现字符串常量池。

字符串常量池指的是在创立字符串的时候，先去「常量池」查找是否创立过该「字符串」；

如果有，则不会开拓新空间创立字符串，而是间接把常量池中该字符串的援用返回给此对象。

创立字符串的两种形式：

• String str1 =“码哥字节”;
• String str2 = new String(“码哥字节”);

当代码中应用第一种形式创立字符串对象时，JVM 首先会查看该对象是否在字符串常量池中，如果在，就返回该对象援用。

否则新的字符串将在常量池中被创立，并返回该援用。

这样能够 缩小同一个值的字符串对象的反复创立，节约内存。

第二种形式创立，在编译类文件时，” 码哥字节 ” 字符串将会放入到常量构造中，在类加载时，“码哥字节 ” 将会在常量池中创立；

在调用 new 时，JVM 命令将会调用 String 的构造函数，在堆内存中创立一个 String 对象，同时该对象指向「常量池」中的“码哥字节”字符串，str 指向刚刚在堆上创立的 String 对象；

如下图：

什么是对象和对象援用呀？

str 属于办法栈的字面量，它指向堆中的 String 对象，并不是对象本。

对象在内存中是一块内存地址，str 则是指向这个内存地址的援用。

也就是说 str 并不是对象，而只是一个对象援用。

码哥，字符串的不可变到底指的是什么呀？

String str = "Java";
str = "Java,yyds"

第一次赋值「Java」，第二次赋值「Java,yyds」，str 值的确扭转了，为什么我还说 String 对象不可变呢？

这是因为 str 只是 String 对象的援用，并不是对象自身。

真正的对象仍然还在内存中，没有被扭转。

优化实战

理解了 String 的对象实现原理和个性，是时候要深刻女神心田，结合实际场景，如何更上一层楼优化 String 对象的应用。

大字符串如何构建

既然 String 对象是不可变，所以咱们在频繁拼接字符串的时候是否意味着创立多个对象呢？

String str = "癞蛤蟆撩青蛙" + "长的丑" + "玩的花";

是不是认为学生成「癞蛤蟆撩青蛙」对象，再生成「癞蛤蟆撩青蛙长的丑」对象，最初生成「癞蛤蟆撩青蛙长得丑玩的花」对象。

理论运行中，只有一个对象生成。

这是为什么呢？

尽管代码写的俊俏，然而编译器主动优化了代码。

再看上面例子：

String str = "小青蛙";

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

下面的代码编译后，你能够看到编译器同样对这段代码进行了优化。

Java 在进行字符串的拼接时，偏差应用 StringBuilder，这样能够进步程序的效率。

String str = "小青蛙";

for(int i=0; i<1000; i++) {str = (new StringBuilder(String.valueOf(str))).append(i).toString();}

即使如此，还是循环内反复创立 StringBuilder对象。

敲黑板

所以做字符串拼接的时候，我倡议你还是要显示地应用 String Builder 来晋升零碎性能。

如果在多线程编程中，String 对象的拼接波及到线程平安，你能够应用 StringBuffer。

使用 intern 节俭内存

间接看intern() 办法的定义与源码：

intern() 是一个本地办法，它的定义中说的是，当调用 intern 办法时，如果字符串常量池中曾经蕴含此字符串，则间接返回此字符串的援用。

否则将此字符串增加到常量池中，并返回字符串的援用。

如果不蕴含此字符串，先将字符串增加到常量池中，再返回此对象的援用。

什么状况下适宜应用 intern() 办法？

Twitter 工程师曾分享过一个 String.intern() 的应用示例，Twitter 每次公布音讯状态的时候，都会产生一个地址信息，以过后 Twitter 用户的规模预估，服务器须要 20G 的内存来存储地址信息。

public class Location {
    private String city;
    private String region;
    private String countryCode;
    private double longitude;
    private double latitude;
}

思考到其中有很多用户在地址信息上是有 重合 的，比方，国家、省份、城市等，这时就能够将这部分信息独自列出一个类，以缩小反复，代码如下：

public class SharedLocation {

  private String city;
  private String region;
  private String countryCode;
}

public class Location {

  private SharedLocation sharedLocation;
  double longitude;
  double latitude;
}

通过优化，数据存储大小减到了 20G 左右。

但对于内存存储这个数据来说，仍然很大，怎么办呢？

Twitter 工程师应用 String.intern() 使重复性十分高的地址信息存储大小从 20G 降到几百兆，从而优化了 String 对象的存储。

外围代码如下：

SharedLocation sharedLocation = new SharedLocation();
sharedLocation.setCity(messageInfo.getCity().intern());
sharedLocation.setCountryCode(messageInfo.getRegion().intern());
sharedLocation.setRegion(messageInfo.getCountryCode().intern());

弄个简略例子不便了解：

String a =new String("abc").intern();
String b = new String("abc").intern();

System.out.print(a==b);

输入后果：true。

在加载类的时候会在常量池中创立一个字符串对象，内容是「abc」。

创立部分 a 变量时，调用 new Sting() 会在堆内存中创立一个 String 对象，String 对象中的 char 数组将会援用常量池中字符串。

在调用 intern 办法之后，会去常量池中查找是否有等于该字符串对象的援用，有就返回援用。

创立 b 变量时，调用 new Sting() 会在堆内存中创立一个 String 对象，String 对象中的 char 数组将会援用常量池中字符串。

在调用 intern 办法之后，会去常量池中查找是否有等于该字符串对象的援用，有就返回援用给局部变量。

而刚在堆内存中的两个对象，因为没有援用指向它，将会被垃圾回收。

所以 a 和 b 援用的是同一个对象。

字符串宰割有妙招

Split() 办法应用了正则表达式实现了其弱小的宰割性能，而正则表达式的性能是十分不稳固的。

应用不失当会引起回溯问题，很可能导致 CPU 居高不下。

Java 正则表达式应用的引擎实现是 NFA（Non deterministic Finite Automaton，确定型有穷自动机）自动机，这种正则表达式引擎在进行字符匹配时会产生回溯（backtracking），而一旦产生回溯，那其耗费的工夫就会变得很长，有可能是几分钟，也有可能是几个小时，工夫长短取决于回溯的次数和复杂度。

所以咱们应该谨慎应用 Split() 办法，咱们能够用 String.indexOf() 办法代替 Split() 办法实现字符串的宰割。

总结与思考

咱们从 String 进化历程把握了她的组成，一直的扭转成员变量节约内存。

她的不可变性从而实现了字符串常量池，缩小同一个字符串的反复创立，节约内存。

但也是因为这个个性，咱们在做长字符串拼接时，须要显示应用 StringBuilder，以进步字符串的拼接性能。

最初，在优化方面，咱们还能够应用 intern 办法，让变量字符串对象重复使用常量池中雷同值的对象，进而节约内存。

最初，出一个问题给大家，欢送在评论区留言，点赞对多的将获取码哥赠送的书籍。

通过三种不同的形式创立了三个对象，再顺次两两匹配，每组被匹配的两个对象是否相等？代码如下：

String str1 = "abc";
String str2 = new String("abc");
String str3 = str2.intern();
assertSame(str1 == str2);
assertSame(str2 == str3);
assertSame(str1 == str3)

公 zhong 号后盾回复：「String」获取答案。