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

原创/朱季谦

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

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

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

  验证环境:jdk1.8

  反编译工具:jad

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

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

提取码:ilil

2.验证

先执行一段例子1代码:

1 public class test3 {
2     public static void main(String[] args) {
3         String str="ab"+"cd"+"ef"+"123";
4     }
5 }

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

 1 // Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.2 // Jad home page: http://www.kpdus.com/jad.html3 // Decompiler options: packimports(3) annotate 4 // Source File Name:   test.java5 package example;6 public class test7 {8     public test()9     {
10     //    0    0:aload_0         
11     //    1    1:invokespecial   #1   <Method void Object()>
12     //    2    4:return          
13     }
14     public static void main(String args[])
15     {
16         String str = "abcdef123";
17     //    0    0:ldc1            #2   <String "abcdef123">
18     //    1    2:astore_1        
19     //    2    3:return          
20     }
21 }

案例2:

1 public class test1 {
2     public static void main(String[] args)
3     {
4         String s = "abc";
5         String ss = "ok" + s + "xyz" + 5;
6         System.out.println(ss);
7     }
8 }

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

 1 // Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.2 // Jad home page: http://www.kpdus.com/jad.html3 // Decompiler options: packimports(3) annotate 4 // Source File Name:   test1.java5 6 package example;7 8 import java.io.PrintStream;9 
10 public class test1
11 {
12     public test1()
13     {
14     //    0    0:aload_0         
15     //    1    1:invokespecial   #1   <Method void Object()>
16     //    2    4:return          
17     }
18     public static void main(String args[])
19     {
20         String s = "abc";
21     //    0    0:ldc1            #2   <String "abc">
22     //    1    2:astore_1        
23         String ss = (new StringBuilder()).append("ok").append(s).append("xyz").append(5).toString();
24     //    2    3:new             #3   <Class StringBuilder>
25     //    3    6:dup             
26     //    4    7:invokespecial   #4   <Method void StringBuilder()>
27     //    5   10:ldc1            #5   <String "ok">
28     //    6   12:invokevirtual   #6   <Method StringBuilder StringBuilder.append(String)>
29     //    7   15:aload_1         
30     //    8   16:invokevirtual   #6   <Method StringBuilder StringBuilder.append(String)>
31     //    9   19:ldc1            #7   <String "xyz">
32     //   10   21:invokevirtual   #6   <Method StringBuilder StringBuilder.append(String)>
33     //   11   24:iconst_5        
34     //   12   25:invokevirtual   #8   <Method StringBuilder StringBuilder.append(int)>
35     //   13   28:invokevirtual   #9   <Method String StringBuilder.toString()>
36     //   14   31:astore_2        
37         System.out.println(ss);
38     //   15   32:getstatic       #10  <Field PrintStream System.out>
39     //   16   35:aload_2         
40     //   17   36:invokevirtual   #11  <Method void PrintStream.println(String)>
41     //   18   39:return          
42     }
43 }

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

再来执行例3的代码:

 1 public class test2 {2     public static void main(String[] args) {3         String s = "";4         Random rand = new Random();5         for (int i = 0; i < 10; i++) {6             s = s + rand.nextInt(1000) + " ";7         }8         System.out.println(s);9     }
10 }

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

 1 // Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.2 // Jad home page: http://www.kpdus.com/jad.html3 // Decompiler options: packimports(3) annotate 4 // Source File Name:   test2.java5 package example;6 import java.io.PrintStream;7 import java.util.Random;8 public class test29 {
10     public test2()
11     {
12     //    0    0:aload_0         
13     //    1    1:invokespecial   #1   <Method void Object()>
14     //    2    4:return          
15     }
16     public static void main(String args[])
17     {
18         String s = "";
19     //    0    0:ldc1            #2   <String "">
20     //    1    2:astore_1        
21         Random rand = new Random();
22     //    2    3:new             #3   <Class Random>
23     //    3    6:dup             
24     //    4    7:invokespecial   #4   <Method void Random()>
25     //    5   10:astore_2        
26         for(int i = 0; i < 10; i++)
27     //*   6   11:iconst_0        
28     //*   7   12:istore_3        
29     //*   8   13:iload_3         
30     //*   9   14:bipush          10
31     //*  10   16:icmpge          55
32             s = (new StringBuilder()).append(s).append(rand.nextInt(1000)).append(" ").toString();
33     //   11   19:new             #5   <Class StringBuilder>
34     //   12   22:dup             
35     //   13   23:invokespecial   #6   <Method void StringBuilder()>
36     //   14   26:aload_1         
37     //   15   27:invokevirtual   #7   <Method StringBuilder StringBuilder.append(String)>
38     //   16   30:aload_2         
39     //   17   31:sipush          1000
40     //   18   34:invokevirtual   #8   <Method int Random.nextInt(int)>
41     //   19   37:invokevirtual   #9   <Method StringBuilder StringBuilder.append(int)>
42     //   20   40:ldc1            #10  <String " ">
43     //   21   42:invokevirtual   #7   <Method StringBuilder StringBuilder.append(String)>
44     //   22   45:invokevirtual   #11  <Method String StringBuilder.toString()>
45     //   23   48:astore_1        
46 
47     //   24   49:iinc            3  1
48     //*  25   52:goto            13
49         System.out.println(s);
50     //   26   55:getstatic       #12  <Field PrintStream System.out>
51     //   27   58:aload_1         
52     //   28   59:invokevirtual   #13  <Method void PrintStream.println(String)>
53     //   29   62:return          
54     }
55 }

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

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.执行以下例子代码:

 1 public class test4 {2     public static void main(String[] args) {3         final int MAX=10000000;4         System.out.println("不用intern:"+notIntern(MAX));5 //      System.out.println("使用intern:"+intern(MAX));6     }7     private static long notIntern(int MAX){8         long start = System.currentTimeMillis();9         for (int i = 0; i < MAX; i++) {
10             int j = i % 100;
11             String str = String.valueOf(j);
12         }
13         return System.currentTimeMillis() - start;
14     }
15 /*
16     private static long intern(int MAX){
17         long start = System.currentTimeMillis();
18         for (int i = 0; i < MAX; i++) {
19             int j = i % 100;
20             String str = String.valueOf(j).intern();
21         }
22         return System.currentTimeMillis() - start;
23     }*/
24 

未使用intern的GC日志:

 1 不用intern:3542 [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 Heap5  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:15152 [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 Heap5  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版本执行以下一个例子:

 1 public class test5 {2     public static void main(String[] args) {3         4         String s1=new String("ab");5         s.intern();6         String s2="ab";7         System.out.println(s1==s2);8 9 
10         String s3=new String("ab")+new String("cd");
11         s3.intern();
12         String s4="abcd";
13         System.out.println(s4==s3);
14     }
15 }

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代替;

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/145136.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

SpringBoot整合Redis使用基于注解的缓存

环境准备 注解 EnableCaching CacheConfig CacheConfig 提供了一种在类级别共享公共缓存相关设置的机制。 | 参数 | 作用 | | | — | — | — | | cacheNames | 使用在类上的默认缓存名称 | | | keyGenerator | 用于类的默认KeyGenerator的bean名称 | | | cacheManager | 自定…

【ARM Trace32(劳特巴赫) 使用介绍 2.1 -- TRACE32 Practice 脚本 cmm 脚本学习】

请阅读【ARM Coresight SoC-400/SoC-600 专栏导读】 上篇文章【ARM Trace32(劳特巴赫) 使用介绍 2 - Veloce 环境中使用trace32 连接 Cortex-M33】 下篇文章【ARM Trace32(劳特巴赫) 使用介绍 2.2 – TRACE32 进阶命令之 DIAG 弹框命令】 文章目录 1. TRACE32 Practice 语法1.…

Python | 机器学习之PCA降维

​&#x1f308;个人主页&#xff1a;Sarapines Programmer&#x1f525; 系列专栏&#xff1a;《人工智能奇遇记》&#x1f516;少年有梦不应止于心动&#xff0c;更要付诸行动。 目录结构 1. 机器学习之PCA降维概念 1.1 机器学习 1.2 PCA降维 2. PCA降维 2.1 实验目的 2…

如何在Jupyter Lab中安装不同的Kernel

❤️觉得内容不错的话&#xff0c;欢迎点赞收藏加关注&#x1f60a;&#x1f60a;&#x1f60a;&#xff0c;后续会继续输入更多优质内容❤️ &#x1f449;有问题欢迎大家加关注私戳或者评论&#xff08;包括但不限于NLP算法相关&#xff0c;linux学习相关&#xff0c;读研读博…

Jupyter Notebook的下载安装与使用教程_Python数据分析与可视化

Jupyter Notebook的下载安装与使用 Jupyter简介下载与安装启动与创建NotebookJupyter基本操作 在计算机编程领域&#xff0c;有一个很强大的工具叫做Jupyter。它不仅是一个集成的开发环境&#xff0c;还是一个交互式文档平台。对于初学者来说&#xff0c;Jupyter提供了友好的界…

linux实现SSH免密登录设置,以及shell脚本实现

原创/朱季谦 最近在搭建linux集群&#xff0c;做了SSH免密登录的设置&#xff0c;正好把过程记录一下&#xff1a; 一.用搭建好的两台虚拟机做演示&#xff0c;A机器&#xff1a;192.168.200.129&#xff0c;B机器&#xff1a;192.168.200.128 二.分别在两台机器上执行以下步…

机器人制作开源方案 | 守护一体化护耆卫士

作者&#xff1a;白玲玲、张硕、孔亚轩单位&#xff1a;兰州理工大学指导老师&#xff1a;毕广利 1. 场景调研 “探索者”平台是结合机械、电子、传感器、计算机软硬件、控制、人工智能和造型技术等众多的先进技术研发推出的专业型机器人设备原型设计工具&#xff0c;包含机构…

利用jquery对HTML中的名字进行替代

想法&#xff1a;将网页中经常要修改的名字放在一个以jquery编写的js文件中&#xff0c;如果需要修改名字&#xff0c;直接修改js文件中的名字即可。 新建name_07.html文件&#xff0c;写入下面的代码&#xff1a; <!DOCTYPE html> <html> <head><meta …

Excel Unix时间戳和日期时间格式的相互转换

时间戳转日期时间 ((A18*3600)/86400)DATE(1970,1,1) # 或 (A18*3600)/8640070*36519# 带格式化 TEXT((C18*3600)/8640070*36519,"yyyy-mm-dd hh:mm:ss")首先加8小时进行时区转换&#xff0c;然后转换成天数&#xff0c;再加上1970年1月1日&#xff0c;最后设置日期…

kafka分布式安装部署

1.集群规划 2.集群部署 官方下载地址&#xff1a;http://kafka.apache.org/downloads.html &#xff08;1&#xff09;上传并解压安装包 [zhangflink9wmwtivvjuibcd2e package]$ tar -zxvf kafka_2.12-3.3.1.tgz -C ../software/&#xff08;2&#xff09;修改解压后的文件…

休闲娱乐 - 挂耳咖啡

公司有一个小的茶歇间&#xff0c;平时去喝个咖啡、放松身心、锻炼下身体。咖啡机是现磨咖啡豆的&#xff0c;喝喝就习惯了。 而我旁边一位同事习惯每天早上来自己泡一杯挂耳咖啡&#xff0c;再配上牛奶&#xff0c;感觉挺高级的。 关于挂耳咖啡就查了一下资料&#xff0c;介绍…

DDR SDRAM 学习笔记

一、基本知识 1.SDRAM SDRAM : 即同步动态随机存储器&#xff08;Synchronous Dynamic Random Access Memory&#xff09;, 同步是指其时钟频率与对应控制器&#xff08;CPU/FPGA&#xff09;的系统时钟频率相同&#xff0c;并且内部命令 的发送与数据传输都是以该时钟为基准…

web环境实现一键式安装启动

部署的痛点 一般在客户环境安装web环境&#xff0c;少说需要花费1-2小时。一般需要安装jdk、nginx、mysql、redis等 等你接触到了inno setup &#xff0c;你有可能会节约更少的时间去部署。也有可能是一个不懂技术的人&#xff0c;都可以进行操作的。废话不多说&#xff0c;接…

Ansible 企业实战详解

一、ansible简介1. ansible是什么2.ansible的特点ansible的架构图 二、ansible 任务执行1、ansible 任务执行模式2、ansible 执行流程3、ansible 命令执行过程 二 .Ansible安装部署1.yum安装2.ansible 程序结构3、ansible配置文件查找顺序4、ansible配置文件5.ansible自动化配置…

yolov5模型代码怎么修改

yaml配置文件 深度乘积因子 宽度乘积因子 所有版本只有这两个参数的不同&#xff0c;s m l x逐渐加宽加深 各种类型层参数对照 backbone里的各层&#xff0c;在这里解析&#xff0c;只需要改.yaml里的各层参数就能控制网络结构 修改网络结构 第一步&#xff1a;把新加的模块…

C++打怪升级(十一)- STL之list

~~~~ 前言1. list是什么2. list接口函数的使用1. 构造相关默认构造n个val构造迭代器范围构造拷贝构造 2 赋值运算符重载函数2 析构函数3 迭代器相关begin 和 endrbegin 和rend 4 容量相关emptysize 5 元素访问相关frontback 6 修改相关push_backpop_backpush_frontpop_frontins…

二进制的形式在内存中绘制一个对象实例

一、引用类型实例的内存布局 从内存布局的角度来看&#xff0c;一个引用类型的实例由如下图所示的三部分组成&#xff1a;ObjHeader TypeHandle Fields。前置的ObjHeader用来缓存哈希值和同步状态&#xff0c;TypeHandle部分存储类型对应方法表&#xff08;Method Table&…

并发编程之生产者消费者模型

什么是生产者消费者模型 生产者消费者模型是多线程中一个比较典型的模型。 打个比方&#xff1a;你是一个客户&#xff0c;你去超市里买火腿肠。 这段话中的 "你"就是消费者&#xff0c; 那么给超市提供火腿肠的供货商就是生产者。超市呢&#xff1f;超市是不是被…

Scrapy----Scrapy简介

文章目录 概述与应用背景架构和组件功能和特点社区生态概述与应用背景 Scrapy,一个高效、灵活、且强大的Web爬取框架,被广泛应用于数据抓取和网页内容的结构化提取。它是用Python编写的,支持多平台运行,适用于数据挖掘、在线零售信息收集、历史数据存档等多种场景。Scrapy…

【ArcGIS处理】行政区划与流域区划间转化

【ArcGIS处理】行政区划与流域区划间转化 引言数据准备1、行政区划数据2、流域区划数据 ArcGIS详细处理步骤Step1&#xff1a;统计行政区划下子流域面积1、创建批量处理模型2、添加批量裁剪处理3、添加计算面积 Step2&#xff1a;根据子流域面积占比均化得到各行政区固定值 参考…