String对象及其特点
- 不变性
String 对象一旦生成，则不能再对其进行改变，不变性可以泛化成不变模式，即一个对象创建之后就不会再发生改变。不变模式主要作用在于一个对象需要被多线程共享，当访问频繁的时候，可以省去锁和同步的等待时间，提高系统性能。 - 针对常量池优化
当两个 String 对象拥有相同值的时候，它们只引用常量池的同一个拷贝，当同一个字符串大量出现的时候，可以大幅度节省内存空间。 - 类的 final 定义
作为 final 类的 String 对象在系统中不可能有任何子类，这是对系统安全性对保护。
subString() 方法存在内存泄漏
subString() 是截取字符串常用的操作之一，但是这个方法在 JDK 中存在严重的内存泄漏问题，原因大家可以自行谷歌，下面介绍怎样优化处理：
import java.util.ArrayList;
import java.util.List;
public class SubStrLeakTest {
public static void main(String args[]) {
List handler = new ArrayList();
/**
* Huge不到1000 次 就oom
* 但是ImprovedHuge 不会
*/
for(int i = 0; i < 1000; i++) {
// HugeStr h = new HugeStr();选择一个执行
ImprovedHugeStr h = new ImprovedHugeStr();
handler.add(h.getSubString(1, 5));
}
}
static class HugeStr {
private String str = new String(new char[100000]);
public String getSubString(int begin, int end) {
return str.substring(begin, end);
}
}
static class ImprovedHugeStr {
private String str = new String(new char[100000]);
public String getSubString(int begin, int end) {
return new String(str.substring(begin, end));
}
}
}
使用ImprovedHugeStr能够很好的工作，不会出现内存泄漏，保证系统的安全稳定。
字符串的分割和查找
- 最原始的字符串分割 sqlit(String regex)
它提供了非常强大的字符串分割功能，传入的参数可以是正则表达式，从而进行复杂逻辑的字符串分割。但是在性能敏感的系统中频繁使用是不可取的。
//对字符串构造
StringBuffer sb = new StringBuffer();
for(int i = 0; i < 10000; i++){
sb.append("i");
sb.append(";");
}
orgStr = sb.toString();
//对字符串进行10000次分割
for(int i = 0; i < 10000; i++){
orgStr,split(";");//运行时间花费3703ms
}
- 使用效率更高的 StringTokenizer(String str, String delim)
str为需要分割的字符串，delim为分割符号,hasMoreTokens() 方法判断是否有更多的子字符串需要处理，nextToken() 得到下一个分割的字符串。
StringTokenizer st = new StringTokenizer(orgStr, ";");
for(int i = 0; i < 10000; i++){
while(st.hasMoreTokens()){
st.nextToken();
}
st = new StringTokenizer(orgStr, ";");
//执行时间2704ms
//StringTokenizer不断被创建，效率还是高于split()
}
- indexOf(char ch)
返回指定字符 ch 在字符串中的位置
自定义字符串分割算法如下：
String tmp = orgStr;
for(int i = 0; i < 10000; i++){
while(true){
String splitStr = null;
int j = tmp.indexOf(";");
if (j < 0) {
break;
}
splitStr = tmp.subString(0, j);
tmp = tmp.subString(j + 1);
}
tmp = orgStr;
}
使用这种算法仅仅花费671ms，性能远远超过 split() 和 StringTokenizer()
- 高效率的 charAt() 方法
public char charAt(int index)
他返回指定位置 index 的字符，它的功能和 indexOf() 相反，效率和它一样高，在软件开发的过程中，经常会遇到这样的问题：判断一个字符串的开始和结束字符串是不是等于某个字串。常用的方法是：
//判断某个字串是不是开头
public boolean startsWith(String prefix)
//判断某个字串是不是结束
public boolean endsWith(String suffix)
这常用的方法其效率远远低于charAt()方法。判断orgStr是否以"abc"开始或结束,使用charAt() 方法实现：
int len = orgStr.lenth();
if(orgStr.charAt(0) == 'a'
&& orgStr.charAt(1) == 'b'
&& orgStr.charAt(2) == 'c');
if(orgStr.charAt(len-1) == 'a'
&& orgStr.charAt(len-2) == 'b'
&& orgStr.charAt(len-3) == 'c');
使用orgStr.stratsWith()和orgStr.endsWith()实现：
orgStr.stratsWith("abc");
orgStr.endsWith("abc");
第一段代码耗时15ms，第二段耗时32ms，在性能敏感的系统中，使用charAt()是个不错的选择。
StringBuffer 和 StringBuilder
- String 常量的累加操作
//第一段代码
String result = "String " + "and" + "String" + "append";
//第二段代码
StringBuilder result = new StringBuilder();
result.append("String");
result.append("and");
result.append("String");
result.append("append");
将两段代码循环5万次，得到第一段0ms，第二段15ms，原来设想第一段是先实现一个”Stringand“ + "String" + "append"，这样执行效率不如第二段，通过反编译得到：对于字符串的累加，Java在编译时就做了彻底充分的优化和计算，将多个连接操作的字符串在编译时合成一个单独的长字符串
- 构建超大的 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 StringBilder();
for(int i = 0; i < 10000; i++){
sb.append(i);
}
三段代码各自执行1万次循环，第一段耗时1062ms，第二段耗时360ms；第三段耗时0ms。这个例子表明：String的加法操作虽然会被优化，但编译器显然不够聪明，因此对于String 操作，类似于“+”和"+="的运算符应该尽量少用，其次concat() 方法效率比“+”要高，比StringBuilder要低。
- StringBuilder 和 StringBuffer 选哪个
在无需考虑线程安全的情况下可以使用性能相对较好的 StringBuilder，但若系统有线程安全要求，只能选择 StringBuffer - 容量参数
这两个字符串操作都可以指定容量
public StringBuilder(int capacity)
public StringBuffer(int capacity)
代码例子：
//下面两段选一段执行
StringBuilder sb = new StringBuilder(5888890);
StringBuffer sb = new StringBuffer(5888890);
for(int i = 0; i < 50000; i++){
sb.append(i);
}
如果能预先评估StringBuilder的大小，将能有效的节省这些操作，从而提高系统性能，指定容量的比没有指定的要更优一些。