Java代码细节优化 java程序性能优化实战

转载

代码匠人之心 2023-06-25 21:13:29

文章标签 Java代码细节优化 Java优化初始化 i++ 数据 文章分类 Java 后端开发

文章目录

循环

减少重复计算

基础知识

使用移位来代替除法操作
ArrayList & LinkedList
数组复制使用System.arraycopy()代替通过来循环
缓冲经常使用对象

变量

避免随意使用静态变量
多使用局部变量
避免频繁创建对象
充分利用关键字 final

避免重复初始化变量
在合适的场合使用单例

其他

避免在循环中使用Try/Catch语句
慎用异常
设置StringBuffer初始化容量以明显提升性能
线程安全使用StringBuilder，线程不安全使用StringBuffer
使用静态方法
在finally块中释放资源
指定StringBuffer的初始容量
尽量减少二维数组的使用？？？

字符串操作

对频繁的字符串操作建议使用StringBuffer
避免频繁使用split

多线程

尽量使用 HashMap, ArrayList

----------------------- 以下内容未整理 --------------------------

其他

参考文献

在JAVA程序中，性能问题的大部分原因并不在于JAVA语言，而是程序中代码的编写习惯。良好的编码习惯非常重要，能够显著地提升程序性能；反之一些不好的习惯会极大地影响性能。关于Java代码优化的文章很多，本文是一个经验总结文章，通过网上的一些文章和自己多年的使用经验对Java的使用进行总结。

循环

减少重复计算

在循环中，经常有对长度的计算，如下所示：

for(int i = 0; i < list.size(); i++)

由于在每次循环的时， i < arr.length() 都需要调用 arr.length() 函数，所以此函数实际上是被多次调用了，影响实际的效率，所以可以修改为：

for(int i = 0, len = list.size(); i < len; i++)

通过在初始化时将长度的值直接赋给变量 len 从而减少了重复计算，提高的计算效率。

基础知识

使用移位来代替除法操作

在几乎所有的程序设计语言中（包括Java），除法都是一个很耗时的计算操作，这是因为除法本身的特性所决定的。但是移位操作 >> 或 << 就相对要快得多。这是因为移位操作在底层只是对一个变量的各位进行左右的移动，操作很简单，所以计算性能非常快。因此，在代码层面，由于是2进制，所以除以(或乘以)2的阶乘都可以使用位移操作来完成。

如下所示，

int num = a / 4; 
int num = a / 8;
int num = a * 4; 
int num = a * 8;

可以修改为：

int num = a >> 2; 
int num = a >> 3;
int num = a << 2; 
int num = a << 3;

这样计算效率能够极大地提高。

ArrayList & LinkedList

一句话：随机读写或查询使用ArrayList，数据添加删除的操作使用LinkedList。

数组复制使用System.arraycopy()代替通过来循环

因为System.arraycopy() 要比通过循环来复制数组快的多。

缓冲经常使用对象

所谓的缓冲是指在内存中保持已经生成的数据，并进行再利用，从而减少数据的读取或生成的时间。举例来说，有一张几M大的图片文件，在使用之前需要从硬盘上加载，而这个加载时间一般几十微秒。这张图片需要多次使用，可以保持在内存中，这样就避免了多次读取所需要的时间。同样的，数据库中的数据，或者需要计算的数据，都可以这样缓冲。但是这样也需要付出内存的代价，即缓冲需要占据一定的内存空间，如果数据量比较大的情况下，在使用缓冲的时候要根据实际情况进行优化。

变量

避免随意使用静态变量

当某个对象被定义为static变量所引用，那么GC通常是不会回收这个对象所占有的内存，如

public class A{ 
        private static B b = new B(); 
}

此时静态变量b的生命周期与A类同步，如果A类不会卸载，那么b对象会常驻内存，直到程序终止。

多使用局部变量

调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快；其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。

避免频繁创建对象

尽量避免在经常调用的方法，循环中new对象，由于系统不仅要花费时间来创建对象，而且还要花时间对这些对象进行垃圾回收和处理，在我们可以控制的范围内，最大限度地重用对象，最好能用基本的数据类型或数组来替代对象。

充分利用关键字 final

带有final修饰符的类是不可派生的。在JAVA核心API中，有许多应用final的例子，例如java、lang、String，为String类指定final防止了使用者覆盖length()方法。另外，如果一个类是final的，则该类所有方法都是final的。java编译器会寻找机会内联（inline）所有的final方法（这和具体的编译器实现有关），此举能够使性能平均提高50%。
如：让访问实例内变量的getter/setter方法变成”final：
简单的getter/setter方法应该被置成final，这会告诉编译器，这个方法不会被重载，所以，可以变成”inlined”,例子：

class MAF {
    private int _size; 
    public void setSize(int size){
        _size = size; 
    }
}

我们可以在 setSize 方法前追加 final，推荐写法如下：

class DAF_fixed {
    private int _size; 
    final public void setSize (int size) {     
        _size = size; 
    } 
}

类

避免重复初始化变量

默认情况下，调用类的构造函数时，java会把变量初始化成确定的值，所有的对象被设置成null，整数变量设置成0，float和double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键字创建一个对象时，构造函数链中的所有构造函数都会被自动调用。
这里有个注意，给成员变量设置初始值但需要调用其他方法的时候，最好放在一个方法。比如initXXX()中，因为直接调用某方法赋值可能会因为类尚未初始化而抛空指针异常，如：public int state = this.getState()。

在合适的场合使用单例

使用单例可以让一个比较重的类只生成一个对象，从而减轻加载的负担，缩短加载的时间，提高加载的效率，但并不是所有地方都适用于单例，简单来说，单例主要适用于以下三个方面：
第一，控制资源的使用，通过线程同步来控制资源的并发访问；
第二，控制实例的产生，以达到节约资源的目的；
第三，控制数据共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信。

其他

避免在循环中使用Try/Catch语句

应把Try/Catch放在循环最外层，因为Error是获取系统错误的类，或者说是虚拟机错误的类。不是所有的错误Exception都能获取到的，虚拟机报错Exception就获取不到，必须用Error获取。

慎用异常

当创建一个异常时，需要收集一个栈跟踪(stack track)，这个栈跟踪用于描述异常是在何处创建的。构建这些栈跟踪时需要为运行时栈做一份快照，这一部分开销很大。所以在使用异常时，建议在可能的情况下使用if进行判断，从而减少异常的过度使用。

设置StringBuffer初始化容量以明显提升性能

StringBuffer的默认容量为16，当StringBuffer的容量达到最大容量时，它会将自身容量增加到当前的2倍+2，也就是2*n+2。当StringBuffer到达它的最大容量，就会创建一个新的对象数组，然后复制旧的对象数组，造成额外的时间浪费。所以，当数据量较大时，建议在初始化StringBuffer时设置一个不小于实际数据大小的初始化容量值以减少其增加长度所需要的额外时间开销。

线程安全使用StringBuilder，线程不安全使用StringBuffer

java.lang.StringBuffer 是一个线程安全的可变字符序列，所以当多线程间可能有操作冲突的时候，使用此类。而StringBuilder是线程不安全的但是性能要优于StringBuffer（一般来说有10%-15%），所以在单线程或多线程无操作冲突时使用。

使用静态方法

如果你没有必要去访问对象的外部，那么就使你的方法成为静态方法。它会被更快地调用，因为它不需要一个虚拟函数导向表。这同时也是一个很好的实践，因为它告诉你如何区分方法的性质，调用这个方法不会改变对象的状态。

在finally块中释放资源

在使用try-catch-finally模型中，如果需要释放资源，最好在finally块中去做。这是因为无论程序执行的结果如何，finally块总是会执行的，从而保证资源的正确关闭。

指定StringBuffer的初始容量

StringBuffer 提供了一个带有指定容量的构造函数，如 StringBuffer buffer = new StringBuffer(1000); 指定了初始化大小为1000个字节。由于StringBuilder的初始大小是16字节，所以如果不指定初始化大小的话，在使用过程中需要不断分配更多空间，从而花费更多额外的时间（多次分配比一次分配耗时多）。所以在能够预测数据长度的情况下，提前指定其初始容量

尽量减少二维数组的使用？？？

二维数据占用的内存空间比一维数组多得多，大概10倍以上。

字符串操作

对频繁的字符串操作建议使用StringBuffer

由于字符串是固定不变的，所以在进行连接时，会创建大量的中间变量。因为建议使用StringBuilder来代替，因为它是可变长的，性能要好得多。

避免频繁使用split

由于split支持正则表达式，所以效率不高。在需要频繁调用的场合，建议使用自定义的函数，或者可以考虑使用第三方，如 Apache 的 StringUtils.split(string,char) 函数。

多线程

尽量使用 HashMap, ArrayList

虽然 HashTable和Vector是线程安全的，但是由于同步机制需要额外开销，所以在单线程或多线程但无竞争访问时，推荐使用线程不安全的HashMap和ArrayList。

----------------------- 以下内容未整理 --------------------------

其他

以下举几个实用优化的例子
一、避免在循环条件中使用复杂表达式
在不做编译优化的情况下，在循环中，循环条件会被反复计算，如果不使用复杂表达式，而使循环条件值不变的话，程序将会运行的更快。例子：

import java.util.Vector; 

    class CEL { 
        void method (Vector vector) { 
            for (int i = 0; i < vector.size (); i++) 
            // Violation ; 
            // ... 
        } 
    }

    更正：

    class CEL_fixed { 

        void method (Vector vector) { 
            int size = vector.size ();
                for (int i = 0; i < size; i++) ; 
                // ... 
        } 
    }

二、为’Vectors’ 和 'Hashtables’定义初始大小
JVM为Vector扩充大小的时候需要重新创建一个更大的数组，将原原先数组中的内容复制过来，最后，原先的数组再被回收。可见Vector容量的扩大是一个颇费时间的事。
通常，默认的10个元素大小是不够的。你最好能准确的估计你所需要的最佳大小。例子：

import java.util.Vector; 

    public class DIC { 
        
        public void addObjects (Object[] o) { 
            // if length > 10, Vector needs to expand 
            for (int i = 0; i< o.length;i++) { 
                v.add(o); // capacity before it can add more elements.     
            } 
         } 
        public Vector v = new Vector(); 
        // no initialCapacity. 
    }

更正：
自己设定初始大小。

public Vector v = new Vector(20); 
    public Hashtable hash = new Hashtable(10);

三、在finally块中关闭Stream
程序中使用到的资源应当被释放，以避免资源泄漏。这最好在finally块中去做。不管程序执行的结果如何，finally块总是会执行的，以确保资源的正确关闭。
四、使用’System.arraycopy ()'代替通过来循环复制数组
例子：

public class IRB { 
        void method () { 
            int[] array1 = new int [100]; 
                for (int i = 0; i < array1.length; i++) { 
                    array1 [i] = i; 
                } 
            int[] array2 = new int [100]; 
                for (int i = 0; i < array2.length; i++) {     
                    array2 [i] = array1 [i]; // Violation 
                }
        } 

    }

更正：

public class IRB { 

        void method () { 
            
            int[] array1 = new int [100]; 
                for (int i = 0; i < array1.length; i++) { 
                    array1 [i] = i; 
                } 
            int[] array2 = new int [100]; 
            System.arraycopy(array1, 0, array2, 0, 100); 
        } 
    }

五、让访问实例内变量的getter/setter方法变成”final”

简单的getter/setter方法应该被置成final，这会告诉编译器，这个方法不会被重载，所以，可以变成”inlined”,例子：

class MAF { 
        public void setSize (int size) { 

            _size = size; 
        } 
        private int _size; 
    }

更正：

class DAF_fixed { 
        
        final public void setSize (int size) { 

            _size = size; 
        } 

        private int _size; 
     }

七、在字符串相加的时候，使用 ’ ’ 代替 " "，如果该字符串只有一个字符的话
例子：

public class STR { 

        public void method(String s) { 
            String string = s + "d" // violation. string = "abc" + "d" // violation. 
        } 
    }

更正：
将一个字符的字符串替换成’ ’

public class STR { 
        public void method(String s) { 
            String string = s + 'd' string = "abc" + 'd' 
            } 
    }

以上仅是Java方面编程时的性能优化，性能优化大部分都是在时间、效率、代码结构层次等方面的权衡，各有利弊，不要把上面内容当成教条，或许有些对我们实际工作适用，有些不适用，还望根据实际工作场景进行取舍，活学活用，变通为宜。
·END·

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：python 消费者redis python 生产者消费者模型

下一篇：als spark 算法原理 astar算法

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯