读书笔记-String

Posted Mosthink

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了读书笔记-String相关的知识,希望对你有一定的参考价值。

【String】就是对char[]数组进行封装的对象,由三部分组成:

1, char数组:它是String对象所表示的字符串的超集;

2, 3, offset和count,表示了String对象表示的字符串在char数组中的起始段;

String是特定设计的,包含以下三个特点:

1, 不变性: 不变模式immutable,节省了同步和锁等待的消耗;

2, 针对【常量池】的优化:

变量 内存空间 常量池

String str1 = “abc” ———————>

String str2 = “abc” ———————> abc

String str3 = new String(“abc”) —-> str实例 ———>

注意:str1 == str3.intern()是true;str2, str2直接指向常量池中的”abc”,不拷贝;

3,类的final定义;

String的两个构造方法:

public String(char value[]) {

    this.value = Arrays.copyOf(value, value.length);

}

String(char[] value, boolean share) {

    this.value = value;

}

第一个构造方法会构造全新的char[]数组;

第二个构造方法共享了原来的char[]数组;

【内存泄漏】第二个包可见的共享char[]数组的构造方法会导致内存泄露

这个构造方法是空间换时间的策略(很有可能理解为时间换空间,因为share了空间,但这里大多数情况下是阻止大空间的GC);

调用这个构造方法,会使得原始的char[]数组无法被GC,假如原char[]很大,按新的String对象只引用了其中很小的一部分,这就是subString(begin, end)的潜在风险,因为这个方法使用了这个包可见的构造方法返回了新的共享了旧的char[]数组的String对象:

new String(offset + beginIndex, endIndex-beginIndex, value);

包可见的构造方法,客户代码虽然无法使用,但调用以下方法则间接调用了这个构造方法:

Integer.toString;

Long.toString;

String.concat;

String.replace;

String.subString;

String.toLower;

String.toUpper;

String.valueOf;

比如:

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

String str2 = str.subString(1, 5);

1000000个字符常驻内存,无法GC,因为5个字符串的使用;

【字符串分割】

String.split提供【正则表达式】分割功能:

“a;b,c:d”.split(“[;|,|:]”);

StringTokenizer是分割字符串的迭代器:

StringTokenizer st = new StringTokenizer(orignalString, “;”);

while(st.hasMoreTokens())

st.nextToken();

用String.indexOf和String.subString来分割字符串:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
while(true) {

    String splitStr = null;

    int j = orignalStr.indexOf(‘;‘);

    if(j < 0)

        break;

    splitStr = orignalStr.subString(0, j);

    orignalStr = orignalStr.subString(j + 1); //更新string
}

分割性能:split < StringTokenizer < indexOf&subString


【字符串查找】

indexOf(char c)与charAt(int index)是String互补的方法;

用startWith和endsWith进行字符串;

用charAt实现startWith:

if(origStr.charAt(0) == ‘a’ && origStr.charAt(1) == ‘b’ && origStr.char(2) == ‘c’);

用charAt实现endsWith:

if(origStr.charAt(len - 1) == ‘c’ && origStr.charAt(len - 2) == ‘b’ && origStr.char(len - 3) == ‘a’);

charAt性能高于startWith和endsWith;


【字符串连接 + += concat StringBuilder StringBuffer】

静态字符串(String常量)的连接操作,会在编译期被编译器直接运算优化:

String result = “abc + “and” + “123”; 的性能高于

StringBuilder builder = new StringBuilder();

builder.append(“abc”);

因为静态字符串的+操作在编译期就被运算了,运行期只存在”abcand123”一个字符串,并非:

“abc”, “and”, “123”, “abcand”, “abcand123”;

动态字符串(String变量)的连接操作,会在编译期被编译器转换为StringBuilder实现,循环中的局部变量也不例外:

所以,

String str1 = “abc”;

String str2 = “and”;

String str3 = “append”;

String result = str1 + str2 + str3;

的字节码等同于:

String result = (new StringBuilder(String.valueOf(str1))).append(str2).append(str3).toString();

所以,其实用+操作和StringBuilder的性能是一样的 ;

但编译器把+转换为StringBuilder时不够聪明,经常会过多new StringBuilder的对象:

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

str = str + i;

会被编译器转换为:

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

str = (new StringBuilder(String.valueOf(str))).append(i).toString();

所以应该显式使用StringBuilder而不是依靠编译器转换为StringBuilder实现:

StringBuilder sb = new StringBuilder();

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

sb.append(i);

StringBuffer是线程安全的,理论上性能略低于StringBuilder;

StringBuilder和StringBuffer就是变长的char[]数组,跟所有变长数组一样,指定合适capacity可以节省扩容的消耗,提高性能:

StringBuffer(int capacity) StringBuilder(int capacity);

字符串连接的效率:StringBuilder >> concat > +

以上是关于读书笔记-String的主要内容,如果未能解决你的问题,请参考以下文章

读书笔记-String

《第一行代码》读书笔记-1

[读书笔记]C#学习笔记八:StringBuilder与String详解及参数传递问题剖析

2016寒假读书笔记1-----20135204

读书笔记 - Effective Java05. 避免创建不必要的对象

读书笔记《大型网站系统与Java中间件实践》第一章1.2.2.3 同步陷阱