String字符串性能优化的几种方案

本文涉及的产品
日志服务 SLS,月写入数据量 50GB 1个月
简介: String字符串是系统里最常用的类型之一,在系统中占据了很大的内存,因此,高效地使用字符串,对系统的性能有较好的提升。

原创/朱季谦


String字符串是系统里最常用的类型之一,在系统中占据了很大的内存,因此,高效地使用字符串,对系统的性能有较好的提升。

针对字符串的优化,我在工作与学习过程总结了以下三种方案作分享:

一.优化构建的超大字符串

  验证环境:jdk1.8

  反编译工具:jad

1.下载反编译工具jad,百度云盘下载:

链接:https://pan.baidu.com/s/1TK1_N769NqtDtLn28jR-Xg

提取码:ilil

2.验证

先执行一段例子1代码:

publicclasstest3 {
publicstaticvoidmain(String[] args) {
Stringstr="ab"+"cd"+"ef"+"123";
     }
 }

执行完成后,用反编译工具jad进行反编译:jad -o -a -s d.java test.class

反编译后的代码:

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.// Jad home page: http://www.kpdus.com/jad.html// Decompiler options: packimports(3) annotate // Source File Name:   test.javapackageexample;
publicclasstest  {
publictest()
      {
//    0    0:aload_0         //    1    1:invokespecial   #1   <Method void Object()>//    2    4:return               }
publicstaticvoidmain(Stringargs[])
     {
Stringstr="abcdef123";
//    0    0:ldc1            #2   <String "abcdef123">//    1    2:astore_1        //    2    3:return               }
 }

案例2:

publicclasstest1 {
publicstaticvoidmain(String[] args)
     {
Strings="abc";
Stringss="ok"+s+"xyz"+5;
System.out.println(ss);
     }
 }

用反编译工具jad执行jad -o -a -s d.java test1.class进行反编译后:

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.// Jad home page: http://www.kpdus.com/jad.html// Decompiler options: packimports(3) annotate // Source File Name:   test1.javapackageexample;
importjava.io.PrintStream;
publicclasstest1 {
publictest1()
     {
//    0    0:aload_0         //    1    1:invokespecial   #1   <Method void Object()>//    2    4:return               }
publicstaticvoidmain(Stringargs[])
     {
Strings="abc";
//    0    0:ldc1            #2   <String "abc">//    1    2:astore_1        Stringss= (newStringBuilder()).append("ok").append(s).append("xyz").append(5).toString();
//    2    3:new             #3   <Class StringBuilder>//    3    6:dup             //    4    7:invokespecial   #4   <Method void StringBuilder()>//    5   10:ldc1            #5   <String "ok">//    6   12:invokevirtual   #6   <Method StringBuilder StringBuilder.append(String)>//    7   15:aload_1         //    8   16:invokevirtual   #6   <Method StringBuilder StringBuilder.append(String)>//    9   19:ldc1            #7   <String "xyz">//   10   21:invokevirtual   #6   <Method StringBuilder StringBuilder.append(String)>//   11   24:iconst_5        //   12   25:invokevirtual   #8   <Method StringBuilder StringBuilder.append(int)>//   13   28:invokevirtual   #9   <Method String StringBuilder.toString()>//   14   31:astore_2        System.out.println(ss);
//   15   32:getstatic       #10  <Field PrintStream System.out>//   16   35:aload_2         //   17   36:invokevirtual   #11  <Method void PrintStream.println(String)>//   18   39:return               }
 }

根据反编译结果,可以看到内部其实是通过StringBuilder进行字符串拼接的。

再来执行例3的代码:

publicclasstest2 {
publicstaticvoidmain(String[] args) {
Strings="";
Randomrand=newRandom();
for (inti=0; i<10; i++) {
s=s+rand.nextInt(1000) +" ";
          }
System.out.println(s);
      }
 }

用反编译工具jad执行jad -o -a -s d.java test2.class进行反编译后,发现其内部同样是通过StringBuilder来进行拼接的:

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.// Jad home page: http://www.kpdus.com/jad.html// Decompiler options: packimports(3) annotate // Source File Name:   test2.javapackageexample;
importjava.io.PrintStream;
importjava.util.Random;
publicclasstest2  {
publictest2()
     {
//    0    0:aload_0         //    1    1:invokespecial   #1   <Method void Object()>//    2    4:return               }
publicstaticvoidmain(Stringargs[])
     {
Strings="";
//    0    0:ldc1            #2   <String "">//    1    2:astore_1        Randomrand=newRandom();
//    2    3:new             #3   <Class Random>//    3    6:dup             //    4    7:invokespecial   #4   <Method void Random()>//    5   10:astore_2        for(inti=0; i<10; i++)
//*   6   11:iconst_0        //*   7   12:istore_3        //*   8   13:iload_3         //*   9   14:bipush          10//*  10   16:icmpge          55s= (newStringBuilder()).append(s).append(rand.nextInt(1000)).append(" ").toString();
//   11   19:new             #5   <Class StringBuilder>//   12   22:dup             //   13   23:invokespecial   #6   <Method void StringBuilder()>//   14   26:aload_1         //   15   27:invokevirtual   #7   <Method StringBuilder StringBuilder.append(String)>//   16   30:aload_2         //   17   31:sipush          1000//   18   34:invokevirtual   #8   <Method int Random.nextInt(int)>//   19   37:invokevirtual   #9   <Method StringBuilder StringBuilder.append(int)>//   20   40:ldc1            #10  <String " ">//   21   42:invokevirtual   #7   <Method StringBuilder StringBuilder.append(String)>//   22   45:invokevirtual   #11  <Method String StringBuilder.toString()>//   23   48:astore_1        //   24   49:iinc            3  1//*  25   52:goto            13System.out.println(s);
//   26   55:getstatic       #12  <Field PrintStream System.out>//   27   58:aload_1         //   28   59:invokevirtual   #13  <Method void PrintStream.println(String)>//   29   62:return               }
 }

综上案例分析,发现字符串进行“+”拼接时,内部有以下几种情况:

1.“+”直接拼接的是常量变量,如"ab"+"cd"+"ef"+"123",内部编译就把几个连接成一个常量字符串处理;

2. “+”拼接的含变量字符串,如案例2:"ok" + s + "xyz" + 5,内部编译其实是new 一个StringBuilder来进行来通过append进行拼接;

3.案例3循环过程,实质也是“+”拼接含变量字符串,因此,内部编译时,也会创建StringBuilder来进行拼接。

对比三种情况,发现第三种情况每次做循环,都会新创建一个StringBuilder对象,这会增加系统的内存,反过来就会降低系统性能。

因此,在做字符串拼接时,单线程环境下,可以显性使用StringBuilder来进行拼接,避免每循环一次就new一个StringBuilder对象;在多线程环境下,可以使用线程安全的StringBuffer,但涉及到锁竞争,StringBuffer性能会比StringBuilder差一点。

这样,起到在字符串拼接时的优化效果。

2.如何使用String.intern节省内存?

在回答这个问题之前,可以先对一段代码进行测试:

1.首先在idea设置-XX:+PrintGCDetails -Xmx6G -Xmn3G,用来打印GC日志信息,设置如下图所示:

2.执行以下例子代码:

publicclasstest4 {
publicstaticvoidmain(String[] args) {
finalintMAX=10000000;
System.out.println("不用intern:"+notIntern(MAX));
//      System.out.println("使用intern:"+intern(MAX));      }
privatestaticlongnotIntern(intMAX){
longstart=System.currentTimeMillis();
for (inti=0; i<MAX; i++) {
intj=i%100;
Stringstr=String.valueOf(j);
         }
returnSystem.currentTimeMillis() -start;
     }
/*private static long intern(int MAX){long start = System.currentTimeMillis();for (int i = 0; i < MAX; i++) {int j = i % 100;String str = String.valueOf(j).intern();}return System.currentTimeMillis() - start;}*/

未使用intern的GC日志:

1 不用intern:354
2 [GC (System.gc()) [PSYoungGen: 377487K->760K(2752512K)] 377487K->768K(2758656K), 0.0009102 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
3 [Full GC (System.gc()) [PSYoungGen: 760K->0K(2752512K)] [ParOldGen: 8K->636K(6144K)] 768K->636K(2758656K), [Metaspace: 3278K->3278K(1056768K)], 0.0051214 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
4 Heap
5  PSYoungGen      total 2752512K, used 23593K [0x0000000700000000, 0x00000007c0000000, 0x00000007c0000000)
6   eden space 2359296K, 1% used [0x0000000700000000,0x000000070170a548,0x0000000790000000)
7   from space 393216K, 0% used [0x0000000790000000,0x0000000790000000,0x00000007a8000000)
8   to   space 393216K, 0% used [0x00000007a8000000,0x00000007a8000000,0x00000007c0000000)
9  ParOldGen       total 6144K, used 636K [0x0000000640000000, 0x0000000640600000, 0x0000000700000000)
10   object space 6144K, 10% used [0x0000000640000000,0x000000064009f2f8,0x0000000640600000)
11  Metaspace       used 3284K, capacity 4500K, committed 4864K, reserved 1056768K
12   class space    used 359K, capacity 388K, committed 512K, reserved 1048576K
根据打印的日志分析:没有使用intern情况下,执行时间为354ms,占用内存为24229k;
使用intern的GC日志:
1 使用intern:1515
2 [GC (System.gc()) [PSYoungGen: 613417K->1144K(2752512K)] 613417K->1152K(2758656K), 0.0012530 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
3 [Full GC (System.gc()) [PSYoungGen: 1144K->0K(2752512K)] [ParOldGen: 8K->965K(6144K)] 1152K->965K(2758656K), [Metaspace: 3780K->3780K(1056768K)], 0.0079962 secs] [Times: user=0.02 sys=0.00, real=0.01 secs] 
4 Heap
5  PSYoungGen      total 2752512K, used 15729K [0x0000000700000000, 0x00000007c0000000, 0x00000007c0000000)
6   eden space 2359296K, 0% used [0x0000000700000000,0x0000000700f5c400,0x0000000790000000)
7   from space 393216K, 0% used [0x0000000790000000,0x0000000790000000,0x00000007a8000000)
8   to   space 393216K, 0% used [0x00000007a8000000,0x00000007a8000000,0x00000007c0000000)
9  ParOldGen       total 6144K, used 965K [0x0000000640000000, 0x0000000640600000, 0x0000000700000000)
10   object space 6144K, 15% used [0x0000000640000000,0x00000006400f1740,0x0000000640600000)
11  Metaspace       used 3786K, capacity 4540K, committed 4864K, reserved 1056768K
12   class space    used 420K, capacity 428K, committed 512K, reserved 1048576K

日志分析:没有使用intern情况下,执行时间为1515ms,占用内存为16694k;

综上所述:使用intern情况下,内存相对没有使用intern的情况要小,但在节省内存的同时,增加了时间复杂度。我试过将MAX=10000000再增加一个0的情况下,使用intern将会花费高达11秒的执行时间,可见,在遍历数据过大时,不建议使用intern。

因此,使用intern的前提,一定要考虑到具体的使用场景。

到这里,可以确定,使用String.intern确实可以节省内存。

接下来,分析一下intern在不同JDK版本的区别。

在JDK1.6中,字符串常量池在方法区中,方法区属于永久代。

在JDK1.7中,字符串常量池移到了堆中。

在JDK1.8中,字符串常量池移到了元空间里,与堆相独立。

分别在1.6、1.7、1.8版本执行以下一个例子:

publicclasstest5 {
publicstaticvoidmain(String[] args) {
Strings1=newString("ab");
s.intern();
Strings2="ab";
System.out.println(s1==s2);
Strings3=newString("ab")+newString("cd");
s3.intern();
Strings4="abcd";
System.out.println(s4==s3);
     }
 }

1.6版本

执行结果:

fasle false

分析:

执行第一部分时:

1.代码编译时,先在字符串常量池里创建常量“ab";在调用new时,将在堆中创建一个String对象,字符串常量创建的“ab"存储到堆中,最后堆中的String对象返回一个引用给s1。

2.s.intern(),在字符串常量池里已经存在“ab”,便不再创建存放副本“ab";

3.s2="ab",s2指向的是字符串常量池里”ab",而s1指向的堆中的”ab",故两者不相等。

该示意图如下:

执行第二部分:

1.两个new出来相加的“abcd”存放在堆中,s3指向堆中的“abcd";

2.执行s3.intern(),在将“abcd"副本的存放到字符串常量池时,发现常量池里没有该”abcd",因此,成功存放;

3.s4="abcd"指向的是字符串常量池里已有的“abcd"副本,而s3指向的是堆中的"abcd",副本"abcd"的地址和堆中“abcd"地址不相同,故为false;

1.7版本

false true

执行第一部分:这一部分与jdk1.6基本类似,不同在于,s1.intern()返回的是引用,而不是副本。

执行第二部分:

1.new String("ab")+new String("cd"),先在常量池里生成“ab"和”cd",再在堆中生成“abcd";

2.执行s3.intern()时,会把“abcd”的对象引用放到字符串常量池里,发现常量池里还没有该引用,故可成功放入。当String s4="abcd",即把字符串常量池中”abcd“的引用地址赋值给s4,相当于s4指向了堆中”abcd"的地址,故s3==s4为true。

1.8版本

false true

参考网上一些博客,在1.8版本当中,使用intern()时,执行原理如下:

若字符串常量池中,包含了与当前对象相当的字符串,将返回常量池里的字符串;若不存在,则将该字符串存放进常量池里,并返回字符串的引用。

 

综上所述,可见三种版本当中,使用intern时,若字符串常量池里不存在相应字符串时,存在以下区别:

例如:

String s1=new String("ab"); s.intern();

jdk1.6:若字符串常量池里没有“ab",则会在常量池里存放一个“ab"副本,该副本地址与堆中的”ab"地址不相等;

jdk1.7:若字符串常量池里没有“ab",会将“ab”的对象引用放到字符串常量池里,该引用地址与堆中”ab"的地址相同;

jdk1.8:若字符串常量池中包含与当前对象相当的字符串,将返回常量池里的字符串;若不存在,则将该字符串存放进常量池里,并返回字符串的引用。

3.如何使用字符串的分割方法?

在简单进行字符串分割时,可以用indexOf替代split,因为split的性能不够稳定,故针对简单的字符串分割,可优先使用indexOf代替;

相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
目录
相关文章
|
3月前
|
安全 Java API
【Java字符串操作秘籍】StringBuffer与StringBuilder的终极对决!
【8月更文挑战第25天】在Java中处理字符串时,经常需要修改字符串,但由于`String`对象的不可变性,频繁修改会导致内存浪费和性能下降。为此,Java提供了`StringBuffer`和`StringBuilder`两个类来操作可变字符串序列。`StringBuffer`是线程安全的,适用于多线程环境,但性能略低;`StringBuilder`非线程安全,但在单线程环境中性能更优。两者基本用法相似,通过`append`等方法构建和修改字符串。
64 1
|
4天前
|
索引 Python
String(字符串)
String(字符串)。
11 3
|
26天前
|
NoSQL Redis
Redis 字符串(String)
10月更文挑战第16天
36 4
|
1月前
|
canal 安全 索引
(StringBuffer和StringBuilder)以及回文串,字符串经典习题
(StringBuffer和StringBuilder)以及回文串,字符串经典习题
33 5
|
1月前
|
存储 JavaScript 前端开发
JavaScript 字符串(String) 对象
JavaScript 字符串(String) 对象
41 3
|
2月前
|
存储 C++
C++(五)String 字符串类
本文档详细介绍了C++中的`string`类,包括定义、初始化、字符串比较及数值与字符串之间的转换方法。`string`类简化了字符串处理,提供了丰富的功能如字符串查找、比较、拼接和替换等。文档通过示例代码展示了如何使用这些功能,并介绍了如何将数值转换为字符串以及反之亦然的方法。此外,还展示了如何使用`string`数组存储和遍历多个字符串。
|
3月前
|
C# 开发者 UED
WPF开发者必备秘籍:深度解析文件对话框使用技巧,打开与保存文件原来如此简单!
【8月更文挑战第31天】在WPF应用开发中,文件操作是常见需求。本文详细介绍了如何利用`Microsoft.Win32`命名空间下的`OpenFileDialog`和`SaveFileDialog`类来正确实现文件打开与保存功能。通过示例代码展示了如何设置文件过滤器、初始目录等属性,并使用对话框进行文件读写操作。正确使用文件对话框能显著提升用户体验,使应用更友好易用。
76 0
|
3月前
|
API C# 开发者
WPF图形绘制大师指南:GDI+与Direct2D完美融合,带你玩转高性能图形处理秘籍!
【8月更文挑战第31天】GDI+与Direct2D的结合为WPF图形绘制提供了强大的工具集。通过合理地使用这两种技术,开发者可以创造出性能优异且视觉效果丰富的WPF应用程序。在实际应用中,开发者应根据项目需求和技术背景,权衡利弊,选择最合适的技术方案。
146 0
|
3月前
|
存储 JSON NoSQL
揭秘Redis字符串String的隐藏技能!从基础到进阶,让你的数据存储操作秒变高大上!
【8月更文挑战第24天】Redis中的字符串类型作为其基石,不仅能够存储从简单文本到复杂格式如JSON的各种数据,还能通过多样化的命令实现包括但不限于自增自减、设置过期时间等高级功能,极大提升了其实用性和灵活性。例如,使用`SET`命令可添加或更新键值对,`GET`获取值,`DEL`删除键;同时,`INCR`和`DECR`支持对整数值的原子性增减操作,非常适合实现计数器等功能;通过`EXPIRE`命令设置过期时间,则适用于需要限时存储的应用场景。尽管名为“字符串”,但实际上还可存储图片、音频文件的Base64编码等形式的数据,为开发者提供了强大而灵活的工具。
48 0
|
3月前
|
存储 Java