关键词搜索

源码搜索 ×
×

Java 程序优化：字符串操作、基本运算方法等优化策略

发布2015-08-19浏览2897次

详情内容

欢迎支持笔者新作：《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》，同时欢迎关注笔者的微信公众号：朱小厮的博客。

 

字符串操作优化

字符串对象

字符串对象或者其等价对象 (如 char 数组)，在内存中总是占据最大的空间块，因此如何高效地处理字符串，是提高系统整体性能的关键。

String 对象可以认为是 char 数组的延伸和进一步封装，它主要由 3 部分组成：char 数组、偏移量和 String 的长度。char 数组表示 String 的内容，它是 String 对象所表示字符串的超集。String 的真实内容还需要由偏移量和长度在这个 char 数组中进行定位和截取。

String 有 3 个基本特点：

1. 不变性；

2. 针对常量池的优化；

3. 类的 final 定义。

不变性指的是 String 对象一旦生成，则不能再对它进行改变。String 的这个特性可以泛化成不变 (immutable) 模式，即一个对象的状态在对象被创建之后就不再发生变化。不变模式的主要作用在于当一个对象需要被多线程共享，并且访问频繁时，可以省略同步和锁等待的时间，从而大幅提高系统性能。

针对常量池的优化指的是当两个 String 对象拥有相同的值时，它们只引用常量池中的同一个拷贝，当同一个字符串反复出现时，这个技术可以大幅度节省内存空间。

下面代码 str1、str2、str4 引用了相同的地址，但是 str3 却重新开辟了一块内存空间，虽然 str3 单独占用了堆空间，但是它所指向的实体和 str1 完全一样。代码如下清单 1 所示。

清单 1. 示例代码

  1. publicclassStringDemo {
  2.  publicstaticvoid main(String[] args){
  3.  String str1 = "abc";
  4.  String str2 = "abc";
  5.  String str3 = newString("abc");
  6.  String str4 = str1;
  7.  System.out.println("is str1 = str2?"+(str1==str2));
  8.  System.out.println("is str1 = str3?"+(str1==str3));
  9.  System.out.println("is str1 refer to str3?"+(str1.intern()==str3.intern()));
  10.  System.out.println("is str1 = str4"+(str1==str4));
  11.  System.out.println("is str2 = str4"+(str2==str4));
  12.  System.out.println("is str4 refer to str3?"+(str4.intern()==str3.intern()));
  13.  }
  14. }

输出如清单 2 所示。

清单 2. 输出结果

  1. is str1 = str2?true
  2. is str1 = str3?false
  3. is str1 refer to str3?true
  4. is str1 = str4true
  5. is str2 = str4true
  6. is str4 refer to str3?true

SubString 使用技巧

String 的 substring 方法源码在最后一行新建了一个 String 对象，new String(offset+beginIndex,endIndex-beginIndex,value);该行代码的目的是为了能高效且快速地共享 String 内的 char 数组对象。但在这种通过偏移量来截取字符串的方法中，String 的原生内容 value 数组被复制到新的子字符串中。设想，如果原始字符串很大，截取的字符长度却很短，那么截取的子字符串中包含了原生字符串的所有内容，并占据了相应的内存空间，而仅仅通过偏移量和长度来决定自己的实际取值。这种算法提高了速度却浪费了空间。

下面代码演示了使用 substring 方法在一个很大的 string 独享里面截取一段很小的字符串，如果采用 string 的 substring 方法会造成内存溢出，如果采用反复创建新的 string 方法可以确保正常运行。

清单 3.substring 方法演示

  1. importjava.util.ArrayList;
  2. importjava.util.List;
  3.  
  4. publicclassStringDemo {
  5.  publicstaticvoid main(String[] args){
  6.  List<String> handler = newArrayList<String>();
  7.  for(inti=0;i<1000;i++){
  8.  HugeStr h = newHugeStr();
  9.  ImprovedHugeStr h1 = newImprovedHugeStr();
  10.  handler.add(h.getSubString(1,5));
  11.  handler.add(h1.getSubString(1,5));
  12.  }
  13.  }
  14.  
  15.  staticclassHugeStr{
  16.  privateString str = newString(newchar[800000]);
  17.  publicString getSubString(intbegin,intend){
  18.  returnstr.substring(begin, end);
  19.  }
  20.  }
  21.  
  22.  staticclassImprovedHugeStr{
  23.  privateString str = newString(newchar[10000000]);
  24.  publicString getSubString(intbegin,intend){
  25.  returnnewString(str.substring(begin, end));
  26.  }
  27.  }
  28. }

 

输出结果如清单 4 所示。

清单 4. 输出结果

  1. Exception in thread "main"java.lang.OutOfMemoryError: Java heap space
  2. at java.util.Arrays.copyOf(Unknown Source)
  3. at java.lang.StringValue.from(Unknown Source)
  4. at java.lang.String.<init>(Unknown Source)
  5. at StringDemo$ImprovedHugeStr.<init>(StringDemo.java:23)
  6. at StringDemo.main(StringDemo.java:9)

 

ImprovedHugeStr 可以工作是因为它使用没有内存泄漏的 String 构造函数重新生成了 String 对象，使得由 substring() 方法返回的、存在内存泄漏问题的 String 对象失去所有的强引用，从而被垃圾回收器识别为垃圾对象进行回收，保证了系统内存的稳定。

String 的 split 方法支持传入正则表达式帮助处理字符串，但是简单的字符串分割时性能较差。

对比 split 方法和 StringTokenizer 类的处理字符串性能，代码如清单 5 所示。

切分字符串方式讨论

String 的 split 方法支持传入正则表达式帮助处理字符串，操作较为简单，但是缺点是它所依赖的算法在对简单的字符串分割时性能较差。清单 5 所示代码对比了 String 的 split 方法和调用 StringTokenizer 类来处理字符串时性能的差距。

清单 5.String 的 split 方法演示

  1. importjava.util.StringTokenizer;
  2.  
  3. publicclasssplitandstringtokenizer {
  4.  publicstaticvoid main(String[] args){
  5.  String orgStr = null;
  6.  StringBuffer sb = newStringBuffer();
  7.  for(inti=0;i<100000;i++){
  8.  sb.append(i);
  9.  sb.append(",");
  10.  }
  11.  orgStr = sb.toString();
  12.  longstart = System.currentTimeMillis();
  13.  for(inti=0;i<100000;i++){
  14.  orgStr.split(",");
  15.  }
  16.  longend = System.currentTimeMillis();
  17.  System.out.println(end-start);
  18.  
  19.  start = System.currentTimeMillis();
  20.  String orgStr1 = sb.toString();
  21.  StringTokenizer st = newStringTokenizer(orgStr1,",");
  22.  for(inti=0;i<100000;i++){
  23.  st.nextToken();
  24.  }
  25.  st = newStringTokenizer(orgStr1,",");
  26.  end = System.currentTimeMillis();
  27.  System.out.println(end-start);
  28.  
  29.  start = System.currentTimeMillis();
  30.  String orgStr2 = sb.toString();
  31.  String temp = orgStr2;
  32.  while(true){
  33.  String splitStr = null;
  34.  intj=temp.indexOf(",");
  35.  if(j<0)break;
  36.  splitStr=temp.substring(0, j);
  37.  temp = temp.substring(j+1);
  38.  }
  39.  temp=orgStr2;
  40.  end = System.currentTimeMillis();
  41.  System.out.println(end-start);
  42.  }
  43. }

 

输出如清单 6 所示：

清单 6. 运行输出结果

  1. 39015
  2. 16
  3. 15

 

当一个 StringTokenizer 对象生成后，通过它的 nextToken() 方法便可以得到下一个分割的字符串，通过 hasMoreToken 方法可以知道是否有更多的字符串需要处理。对比发现 split 的耗时非常的长，采用 StringTokenizer 对象处理速度很快。我们尝试自己实现字符串分割算法，使用 substring 方法和 indexOf 方法组合而成的字符串分割算法可以帮助很快切分字符串并替换内容。

由于 String 是不可变对象，因此，在需要对字符串进行修改操作时 (如字符串连接、替换)，String 对象会生成新的对象，所以其性能相对较差。但是 JVM 会对代码进行彻底的优化，将多个连接操作的字符串在编译时合成一个单独的长字符串。

以上实例运行结果差异较大的原因是 split 算法对每一个字符进行了对比，这样当字符串较大时，需要把整个字符串读入内存，逐一查找，找到符合条件的字符，这样做较为耗时。而 StringTokenizer 类允许一个应用程序进入一个令牌（tokens），StringTokenizer 类的对象在内部已经标识化的字符串中维持了当前位置。一些操作使得在现有位置上的字符串提前得到处理。 一个令牌的值是由获得其曾经创建 StringTokenizer 类对象的字串所返回的。

清单 7.split 类源代码

  1. importjava.util.ArrayList;
  2.  
  3. publicclassSplit {
  4. publicString[] split(CharSequence input, intlimit) { 
  5. intindex = 0;
  6. booleanmatchLimited = limit > 0;
  7. ArrayList<String> matchList = newArrayList<String>();
  8. Matcher m = matcher(input); 
  9. // Add segments before each match found 
  10. while(m.find()) { 
  11. if(!matchLimited || matchList.size() < limit - 1) { 
  12. String match = input.subSequence(index, m.start()).toString(); 
  13. matchList.add(match);
  14. index = m.end(); 
  15. }elseif(matchList.size() == limit - 1) { 
  16. // last one 
  17. String match = input.subSequence(index,input.length()).toString(); 
  18. matchList.add(match);
  19. index = m.end(); 
  20. }
  21. }
  22. // If no match was found, return this 
  23. if(index == 0){
  24. returnnewString[] {input.toString()}; 
  25. }
  26. // Add remaining segment 
  27. if(!matchLimited || matchList.size() < limit){ 
  28. matchList.add(input.subSequence(index, input.length()).toString()); 
  29. }
  30. // Construct result 
  31. intresultSize = matchList.size(); 
  32. if(limit == 0){
  33. while(resultSize > 0&& matchList.get(resultSize-1).equals(""))
  34. resultSize--;
  35.  String[] result = newString[resultSize];
  36.  returnmatchList.subList(0, resultSize).toArray(result); 
  37. }
  38. }
  39.  
  40. }

 

split 借助于数据对象及字符查找算法完成了数据分割，适用于数据量较少场景。

合并字符串

由于 String 是不可变对象，因此，在需要对字符串进行修改操作时 (如字符串连接、替换)，String 对象会生成新的对象，所以其性能相对较差。但是 JVM 会对代码进行彻底的优化，将多个连接操作的字符串在编译时合成一个单独的长字符串。针对超大的 String 对象，我们采用 String 对象连接、使用 concat 方法连接、使用 StringBuilder 类等多种方式，代码如清单 8 所示。

清单 8. 处理超大 String 对象的示例代码

  1. publicclassStringConcat {
  2.  publicstaticvoid main(String[] args){
  3.  String str = null;
  4.  String result = "";
  5.  
  6.  longstart = System.currentTimeMillis();
  7.  for(inti=0;i<10000;i++){
  8.  str = str + i;
  9.  }
  10.  longend = System.currentTimeMillis();
  11.  System.out.println(end-start);
  12.  
  13.  start = System.currentTimeMillis();
  14.  for(inti=0;i<10000;i++){
  15.  result = result.concat(String.valueOf(i));
  16.  }
  17.  end = System.currentTimeMillis();
  18.  System.out.println(end-start);
  19.  
  20.  start = System.currentTimeMillis();
  21.  StringBuilder sb = newStringBuilder();
  22.  for(inti=0;i<10000;i++){
  23.  sb.append(i);
  24.  }
  25.  end = System.currentTimeMillis();
  26.  System.out.println(end-start);
  27.  }
  28. }

 

输出如清单 9 所示。

清单 9. 运行输出结果

  1. 375
  2. 187
  3. 0

 

虽然第一种方法编译器判断 String 的加法运行成 StringBuilder 实现，但是编译器没有做出足够聪明的判断，每次循环都生成了新的 StringBuilder 实例从而大大降低了系统性能。

StringBuffer 和 StringBuilder 都实现了 AbstractStringBuilder 抽象类，拥有几乎相同的对外借口，两者的最大不同在于 StringBuffer 对几乎所有的方法都做了同步，而 StringBuilder 并没有任何同步。由于方法同步需要消耗一定的系统资源，因此，StringBuilder 的效率也好于 StringBuffer。 但是，在多线程系统中，StringBuilder 无法保证线程安全，不能使用。代码如清单 10 所示。

清单 10.StringBuilderVSStringBuffer

  1. publicclassStringBufferandBuilder {
  2. publicStringBuffer contents = newStringBuffer();
  3. publicStringBuilder sbu = newStringBuilder();
  4.  
  5. publicvoidlog(String message){ 
  6. for(inti=0;i<10;i++){
  7. /*
  8. contents.append(i);
  9. contents.append(message);
  10. contents.append("\n");
  11. */
  12. contents.append(i);
  13. contents.append("\n");
  14. sbu.append(i);
  15. sbu.append("\n");
  16. }
  17. }
  18. publicvoidgetcontents(){ 
  19. //System.out.println(contents);
  20. System.out.println("start print StringBuffer");
  21. System.out.println(contents);
  22. System.out.println("end print StringBuffer");
  23. }
  24. publicvoidgetcontents1(){ 
  25. //System.out.println(contents);
  26. System.out.println("start print StringBuilder");
  27. System.out.println(sbu);
  28. System.out.println("end print StringBuilder");
  29. }
  30.  
  31.  publicstaticvoid main(String[] args) throwsInterruptedException { 
  32. StringBufferandBuilder ss = newStringBufferandBuilder();
  33. runthread t1 = newrunthread(ss,"love");
  34. runthread t2 = newrunthread(ss,"apple");
  35. runthread t3 = newrunthread(ss,"egg");
  36. t1.start();
  37. t2.start();
  38. t3.start();
  39. t1.join();
  40. t2.join();
  41. t3.join();
  42. }
  43.  
  44. }
  45.  
  46. classrunthreadextendsThread{
  47. String message; 
  48. StringBufferandBuilder buffer; 
  49. publicrunthread(StringBufferandBuilder buffer,String message){ 
  50. this.buffer = buffer;
  51. this.message = message; 
  52. }
  53. publicvoidrun(){ 
  54. while(true){
  55. buffer.log(message);
  56. //buffer.getcontents();
  57. buffer.getcontents1();
  58. try{
  59. sleep(5000000);
  60. }catch(InterruptedException e) {
  61. // TODO Auto-generated catch block
  62. e.printStackTrace();
  63. }
  64. }
  65. }
  66.  
  67. }

 

输出结果如清单 11 所示。

清单 11. 运行结果

  1. start print StringBuffer
  2. 0123456789
  3. end print StringBuffer
  4. start print StringBuffer
  5. start print StringBuilder
  6. 01234567890123456789
  7. end print StringBuffer
  8. start print StringBuilder
  9. 01234567890123456789
  10. 01234567890123456789
  11. end print StringBuilder
  12. end print StringBuilder
  13. start print StringBuffer
  14. 012345678901234567890123456789
  15. end print StringBuffer
  16. start print StringBuilder
  17. 012345678901234567890123456789
  18. end print StringBuilder

 

StringBuilder 数据并没有按照预想的方式进行操作。StringBuilder 和 StringBuffer 的扩充策略是将原有的容量大小翻倍，以新的容量申请内存空间，建立新的 char 数组，然后将原数组中的内容复制到这个新的数组中。因此，对于大对象的扩容会涉及大量的内存复制操作。如果能够预先评估大小，会提高性能。

 

数据定义、运算逻辑优化

使用局部变量

调用方法时传递的参数以及在调用中创建的临时变量都保存在栈 (Stack) 里面，读写速度较快。其他变量，如静态变量、实例变量等，都在堆 (heap) 中创建，读写速度较慢。清单 12 所示代码演示了使用局部变量和静态变量的操作时间对比。

清单 12. 局部变量 VS 静态变量

  1. publicclassvariableCompare {
  2. publicstaticint b = 0;
  3.  publicstaticvoid main(String[] args){
  4.  inta = 0;
  5.  longstarttime = System.currentTimeMillis();
  6.  for(inti=0;i<1000000;i++){
  7.  a++;//在函数体内定义局部变量
  8.  }
  9.  System.out.println(System.currentTimeMillis() - starttime);
  10.  
  11.  starttime = System.currentTimeMillis();
  12.  for(inti=0;i<1000000;i++){
  13.  b++;//在函数体内定义局部变量
  14.  }
  15.  System.out.println(System.currentTimeMillis() - starttime);
  16.  }
  17. }

 

运行后输出如清单 13 所示。

清单 13. 运行结果

  1. 0
  2. 15

 

以上两段代码的运行时间分别为 0ms 和 15ms。由此可见，局部变量的访问速度远远高于类的成员变量。

位运算代替乘除法

位运算是所有的运算中最为高效的。因此，可以尝试使用位运算代替部分算数运算，来提高系统的运行速度。最典型的就是对于整数的乘除运算优化。清单 14 所示代码是一段使用算数运算的实现。

清单 14. 算数运算

  1. publicclassyunsuan {
  2.  publicstaticvoid main(String args[]){
  3.  longstart = System.currentTimeMillis();
  4.  longa=1000;
  5.  for(inti=0;i<10000000;i++){
  6.  a*=2;
  7.  a/=2;
  8.  }
  9.  System.out.println(a);
  10.  System.out.println(System.currentTimeMillis() - start);
  11.  start = System.currentTimeMillis();
  12.  for(inti=0;i<10000000;i++){
  13.  a<<=1;
  14.  a>>=1;
  15.  }
  16.  System.out.println(a);
  17.  System.out.println(System.currentTimeMillis() - start);
  18.  }
  19. }

 

运行输出如清单 15 所示。

清单 15. 运行结果

  1. 1000
  2. 546
  3. 1000
  4. 63

 

两段代码执行了完全相同的功能，在每次循环中，整数 1000 乘以 2，然后除以 2。第一个循环耗时 546ms，第二个循环耗时 63ms。

替换 switch

关键字 switch 语句用于多条件判断，switch 语句的功能类似于 if-else 语句，两者的性能差不多。但是 switch 语句有性能提升空间。清单 16 所示代码演示了 Switch 与 if-else 之间的对比。

清单 16.Switch 示例

  1. publicclassswitchCompareIf {
  2.  
  3. publicstaticint switchTest(intvalue){
  4. inti = value%10+1;
  5. switch(i){
  6. case1:return10;
  7. case2:return11;
  8. case3:return12;
  9. case4:return13;
  10. case5:return14;
  11. case6:return15;
  12. case7:return16;
  13. case8:return17;
  14. case9:return18;
  15. default:return-1;
  16. }
  17. }
  18.  
  19. publicstaticint arrayTest(int[] value,intkey){
  20. inti = key%10+1;
  21. if(i>9|| i<1){
  22. return-1;
  23. }else{
  24. returnvalue[i];
  25. }
  26. }
  27.  
  28.  publicstaticvoid main(String[] args){
  29.  intchk = 0;
  30.  longstart=System.currentTimeMillis();
  31.  for(inti=0;i<10000000;i++){
  32.  chk = switchTest(i);
  33.  }
  34.  System.out.println(System.currentTimeMillis()-start);
  35.  chk = 0;
  36.  start=System.currentTimeMillis();
  37.  int[] value=newint[]{0,10,11,12,13,14,15,16,17,18};
  38.  for(inti=0;i<10000000;i++){
  39.  chk = arrayTest(value,i);
  40.  }
  41.  System.out.println(System.currentTimeMillis()-start);
  42.  }
  43. }

 

运行输出如清单 17 所示。

清单 17. 运行结果

  1. 172
  2. 93

 

使用一个连续的数组代替 switch 语句，由于对数据的随机访问非常快，至少好于 switch 的分支判断，从上面例子可以看到比较的效率差距近乎 1 倍，switch 方法耗时 172ms，if-else 方法耗时 93ms。

一维数组代替二维数组

JDK 很多类库是采用数组方式实现的数据存储，比如 ArrayList、Vector 等，数组的优点是随机访问性能非常好。一维数组和二维数组的访问速度不一样，一维数组的访问速度要优于二维数组。在性能敏感的系统中要使用二维数组，尽量将二维数组转化为一维数组再进行处理，以提高系统的响应速度。

清单 18. 数组方式对比

  1. publicclassarrayTest {
  2.  publicstaticvoid main(String[] args){
  3.  longstart = System.currentTimeMillis();
  4.  int[] arraySingle = newint[1000000];
  5.  intchk = 0;
  6.  for(inti=0;i<100;i++){
  7.  for(intj=0;j<arraySingle.length;j++){
  8.  arraySingle[j] = j;
  9.  }
  10.  }
  11.  for(inti=0;i<100;i++){
  12.  for(intj=0;j<arraySingle.length;j++){
  13.  chk = arraySingle[j];
  14.  }
  15.  }
  16.  System.out.println(System.currentTimeMillis() - start);
  17.  
  18.  start = System.currentTimeMillis();
  19.  int[][] arrayDouble = newint[1000][1000];
  20.  chk = 0;
  21.  for(inti=0;i<100;i++){
  22.  for(intj=0;j<arrayDouble.length;j++){
  23.  for(intk=0;k<arrayDouble[0].length;k++){
  24.  arrayDouble[i][j]=j;
  25.  }
  26.  }
  27.  }
  28.  for(inti=0;i<100;i++){
  29.  for(intj=0;j<arrayDouble.length;j++){
  30.  for(intk=0;k<arrayDouble[0].length;k++){
  31.  chk = arrayDouble[i][j];
  32.  }
  33.  }
  34.  }
  35.  System.out.println(System.currentTimeMillis() - start);
  36.  
  37.  start = System.currentTimeMillis();
  38.  arraySingle = newint[1000000];
  39.  intarraySingleSize = arraySingle.length;
  40.  chk = 0;
  41.  for(inti=0;i<100;i++){
  42.  for(intj=0;j<arraySingleSize;j++){
  43.  arraySingle[j] = j;
  44.  }
  45.  }
  46.  for(inti=0;i<100;i++){
  47.  for(intj=0;j<arraySingleSize;j++){
  48.  chk = arraySingle[j];
  49.  }
  50.  }
  51.  System.out.println(System.currentTimeMillis() - start);
  52.  
  53.  start = System.currentTimeMillis();
  54.  arrayDouble = newint[1000][1000];
  55.  intarrayDoubleSize = arrayDouble.length;
  56.  intfirstSize = arrayDouble[0].length;
  57.  chk = 0;
  58.  for(inti=0;i<100;i++){
  59.  for(intj=0;j<arrayDoubleSize;j++){
  60.  for(intk=0;k<firstSize;k++){
  61.  arrayDouble[i][j]=j;
  62.  }
  63.  }
  64.  }
  65.  for(inti=0;i<100;i++){
  66.  for(intj=0;j<arrayDoubleSize;j++){
  67.  for(intk=0;k<firstSize;k++){
  68.  chk = arrayDouble[i][j];
  69.  }
  70.  }
  71.  }
  72.  System.out.println(System.currentTimeMillis() - start);
  73.  }
  74. }

 

运行输出如清单 19 所示。

清单 19. 运行结果

  1. 2
  2. 3
  3. 4
  4. 343
  5. 624
  6. 287
  7. 390

 

  

第一段代码操作的是一维数组的赋值、取值过程，第二段代码操作的是二维数组的赋值、取值过程。可以看到一维数组方式比二维数组方式快接近一半时间。而对于数组内如果可以减少赋值运算，则可以进一步减少运算耗时，加快程序运行速度。

提取表达式

大部分情况下，代码的重复劳动由于计算机的高速运行，并不会对性能构成太大的威胁，但若希望将系统性能发挥到极致，还是有很多地方可以优化的。

清单 20. 提取表达式

  1. publicclassduplicatedCode {
  2.  publicstaticvoid beforeTuning(){
  3.  longstart = System.currentTimeMillis();
  4.  doublea1 = Math.random();
  5.  doublea2 = Math.random();
  6.  doublea3 = Math.random();
  7.  doublea4 = Math.random();
  8.  doubleb1,b2;
  9.  for(inti=0;i<10000000;i++){
  10.  b1 = a1*a2*a4/3*4*a3*a4;
  11.  b2 = a1*a2*a3/3*4*a3*a4;
  12.  }
  13.  System.out.println(System.currentTimeMillis() - start);
  14.  }
  15.  
  16.  publicstaticvoid afterTuning(){
  17.  longstart = System.currentTimeMillis();
  18.  doublea1 = Math.random();
  19.  doublea2 = Math.random();
  20.  doublea3 = Math.random();
  21.  doublea4 = Math.random();
  22.  doublecombine,b1,b2;
  23.  for(inti=0;i<10000000;i++){
  24.  combine = a1*a2/3*4*a3*a4;
  25.  b1 = combine*a4;
  26.  b2 = combine*a3;
  27.  }
  28.  System.out.println(System.currentTimeMillis() - start);
  29.  }
  30.  
  31.  publicstaticvoid main(String[] args){
  32.  duplicatedCode.beforeTuning();
  33.  duplicatedCode.afterTuning();
  34.  }
  35. }

 

 

运行输出如清单 21 所示。

清单 21. 运行结果

  1. 202
  2. 110

 

 

两段代码的差别是提取了重复的公式，使得这个公式的每次循环计算只执行一次。分别耗时 202ms 和 110ms，可见，提取复杂的重复操作是相当具有意义的。这个例子告诉我们，在循环体内，如果能够提取到循环体外的计算公式，最好提取出来，尽可能让程序少做重复的计算。

优化循环

当性能问题成为系统的主要矛盾时，可以尝试优化循环，例如减少循环次数，这样也许可以加快程序运行速度。

清单 22. 减少循环次数

  1. publicclassreduceLoop {
  2. publicstaticvoid beforeTuning(){
  3.  longstart = System.currentTimeMillis();
  4.  int[] array = newint[9999999];
  5.  for(inti=0;i<9999999;i++){
  6.  array[i] = i;
  7.  }
  8.  System.out.println(System.currentTimeMillis() - start);
  9. }
  10.  
  11. publicstaticvoid afterTuning(){
  12.  longstart = System.currentTimeMillis();
  13.  int[] array = newint[9999999];
  14.  for(inti=0;i<9999999;i+=3){
  15.  array[i] = i;
  16.  array[i+1] = i+1;
  17.  array[i+2] = i+2;
  18.  }
  19.  System.out.println(System.currentTimeMillis() - start);
  20. }
  21.  
  22. publicstaticvoid main(String[] args){
  23. reduceLoop.beforeTuning();
  24. reduceLoop.afterTuning();
  25. }
  26. }

 

运行输出如清单 23 所示。

清单 23. 运行结果

  1. 265
  2. 31

 

这个例子可以看出，通过减少循环次数，耗时缩短为原来的 1/8。

布尔运算代替位运算

虽然位运算的速度远远高于算术运算，但是在条件判断时，使用位运算替代布尔运算确实是非常错误的选择。在条件判断时，Java 会对布尔运算做相当充分的优化。假设有表达式 a、b、c 进行布尔运算“a&&b&&c”，根据逻辑与的特点，只要在整个布尔表达式中有一项返回 false，整个表达式就返回 false，因此，当表达式 a 为 false 时，该表达式将立即返回 false，而不会再去计算表达式 b 和 c。若此时，表达式 a、b、c 需要消耗大量的系统资源，这种处理方式可以节省这些计算资源。同理，当计算表达式“a||b||c”时，只要 a、b 或 c，3 个表达式其中任意一个计算结果为 true 时，整体表达式立即返回 true，而不去计算剩余表达式。简单地说，在布尔表达式的计算中，只要表达式的值可以确定，就会立即返回，而跳过剩余子表达式的计算。若使用位运算 (按位与、按位或) 代替逻辑与和逻辑或，虽然位运算本身没有性能问题，但是位运算总是要将所有的子表达式全部计算完成后，再给出最终结果。因此，从这个角度看，使用位运算替代布尔运算会使系统进行很多无效计算。

清单 24. 运算方式对比

  1. publicclassOperationCompare {
  2.  publicstaticvoid booleanOperate(){
  3.  longstart = System.currentTimeMillis();
  4.  booleana = false;
  5.  booleanb = true;
  6.  intc = 0;
  7.  //下面循环开始进行位运算，表达式里面的所有计算因子都会被用来计算
  8.  for(inti=0;i<1000000;i++){
  9.  if(a&b&"Test_123".contains("123")){
  10.  c = 1;
  11.  }
  12.  }
  13.  System.out.println(System.currentTimeMillis() - start);
  14.  }
  15.  
  16.  publicstaticvoid bitOperate(){
  17.  longstart = System.currentTimeMillis();
  18.  booleana = false;
  19.  booleanb = true;
  20.  intc = 0;
  21.  //下面循环开始进行布尔运算，只计算表达式 a 即可满足条件
  22.  for(inti=0;i<1000000;i++){
  23.  if(a&&b&&"Test_123".contains("123")){
  24.  c = 1;
  25.  }
  26.  }
  27.  System.out.println(System.currentTimeMillis() - start);
  28.  }
  29.  
  30.  publicstaticvoid main(String[] args){
  31.  OperationCompare.booleanOperate();
  32.  OperationCompare.bitOperate();
  33.  }
  34. }


 

运行输出如清单 25 所示。

清单 25. 运行结果

  1. 63
  2. 0

 

实例显示布尔计算大大优于位运算，但是，这个结果不能说明位运算比逻辑运算慢，因为在所有的逻辑与运算中，都省略了表达式“”Test_123″.contains(“123″)”的计算，而所有的位运算都没能省略这部分系统开销。

使用 arrayCopy()

数据复制是一项使用频率很高的功能，JDK 中提供了一个高效的 API 来实现它。System.arraycopy() 函数是 native 函数，通常 native 函数的性能要优于普通的函数，所以，仅处于性能考虑，在软件开发中，应尽可能调用 native 函数。ArrayList 和 Vector 大量使用了 System.arraycopy 来操作数据，特别是同一数组内元素的移动及不同数组之间元素的复制。arraycopy 的本质是让处理器利用一条指令处理一个数组中的多条记录，有点像汇编语言里面的串操作指令 (LODSB、LODSW、LODSB、STOSB、STOSW、STOSB)，只需指定头指针，然后开始循环即可，即执行一次指令，指针就后移一个位置，操作多少数据就循环多少次。如果在应用程序中需要进行数组复制，应该使用这个函数，而不是自己实现。具体应用如清单 26 所示。

清单 26. 复制数据例子

  1. publicclassarrayCopyTest {
  2. publicstaticvoid arrayCopy(){
  3. intsize = 10000000;
  4.  int[] array = newint[size];
  5.  int[] arraydestination = newint[size];
  6.  for(inti=0;i<array.length;i++){
  7.  array[i] = i;
  8.  }
  9.  longstart = System.currentTimeMillis();
  10.  for(intj=0;j>1000;j++){
  11.  System.arraycopy(array,0, arraydestination, 0, size);//使用 System 级别的本地 arraycopy 方式
  12.  }
  13.  System.out.println(System.currentTimeMillis() - start);
  14. }
  15.  
  16. publicstaticvoid arrayCopySelf(){
  17. intsize = 10000000;
  18.  int[] array = newint[size];
  19.  int[] arraydestination = newint[size];
  20.  for(inti=0;i<array.length;i++){
  21.  array[i] = i;
  22.  }
  23.  longstart = System.currentTimeMillis();
  24.  for(inti=0;i<1000;i++){
  25.  for(intj=0;j<size;j++){
  26.  arraydestination[j] = array[j];//自己实现的方式，采用数组的数据互换方式
  27.  }
  28.  }
  29.  System.out.println(System.currentTimeMillis() - start);
  30. }
  31.  
  32.  publicstaticvoid main(String[] args){
  33.  arrayCopyTest.arrayCopy();
  34.  arrayCopyTest.arrayCopySelf();
  35.  }
  36. }

 

输出如清单 27 所示。

清单 27. 运行结果

  1. 0
  2. 23166

上面的例子显示采用 arraycopy 方法执行复制会非常的快。原因就在于 arraycopy 属于本地方法，源代码如清单 28 所示。

清单 28.arraycopy 方法

  1. publicstaticnative void arraycopy(Object src, intsrcPos,
  2. Object dest, intdestPos,
  3. intlength);

 

src – 源数组；srcPos – 源数组中的起始位置； dest – 目标数组；destPos – 目标数据中的起始位置；length – 要复制的数组元素的数量。清单 28 所示方法使用了 native 关键字，调用的为 C++编写的底层函数，可见其为 JDK 中的底层函数。

 

欢迎支持笔者新作：《深入理解Kafka:核心设计与实践原理》和《RabbitMQ实战指南》，同时欢迎关注笔者的微信公众号：朱小厮的博客。

相关技术文章

最新源码

下载排行榜
点击QQ咨询
开通会员
返回顶部
×
微信扫码支付 元
微信扫码支付
确定支付下载
请使用微信描二维码支付
×

提示信息

×

选择支付方式

  • 微信支付
  • 支付宝付款
确定支付下载