分享几个工作中实用的代码优化技巧！

前言

之前分享一篇代码优化的文章：条件语句的多层嵌套问题优化，助你写出不让同事吐槽的代码!

今天再次分享一些我日常工作中常用的代码优化技巧，希望对大家有帮助!

正文

类成员与方法的可见性最小化

举例：如果是一个private的方法，想删除就删除

如果一个public的service方法，或者一个public的成员变量，删除一下，不得思考很多。

使用位移操作替代乘除法

计算机是使用二进制表示的，位移操作会极大地提高性能。

<< 左移相当于乘以 2;>> 右移相当于除以 2;

>>> 无符号右移相当于除以 2，但它会忽略符号位，空位都以 0 补齐。

 
 
 
 
    
  
  
  
  
  1. a = val << 3;
    2. 
  
  
  
  
  2. b = val >> 1;
    3.

尽量减少对变量的重复计算

我们知道对方法的调用是有消耗的，包括创建栈帧、调用方法时保护现场，恢复现场等。

 
 
 
 
    
  
  
  
  
  1. //反例
    2. 
  
  
  
  
  2. for (int i = 0; i < list.size(); i++) {
    3. 
  
  
  
  
  3.   System.out.println("result");
    4. 
  
  
  
  
  4. }
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. //正例
    7. 
  
  
  
  
  7. for (int i = 0, length = list.size(); i < length; i++) {
    8. 
  
  
  
  
  8.   System.out.println("result");
    9. 
  
  
  
  
  9. }
    10.

在list.size()很大的时候，就减少了很多的消耗。

不要捕捉RuntimeException

RuntimeException 不应该通过 catch 语句去捕捉，而应该使用编码手段进行规避。

如下面的代码，list 可能会出现数组越界异常。

是否越界是可以通过代码提前判断的，而不是等到发生异常时去捕捉。

提前判断这种方式，代码会更优雅，效率也更高。

 
 
 
 
    
  
  
  
  
  1. public String test1(List list, int index) {
    2. 
  
  
  
  
  2.     try {
    3. 
  
  
  
  
  3.         return list.get(index);
    4. 
  
  
  
  
  4.     } catch (IndexOutOfBoundsException ex) {
    5. 
  
  
  
  
  5.         return null;
    6. 
  
  
  
  
  6.     }
    7. 
  
  
  
  
  7. }
    8. 
  
  
  
  
  8. 
  
  
  
  
  9. //正例
    10. 
  
  
  
  
  10. public String test2(List list, int index) {
    11. 
  
  
  
  
  11.     if (index >= list.size() || index < 0) {
    12. 
  
  
  
  
  12.         return null;
    13. 
  
  
  
  
  13.     }
    14. 
  
  
  
  
  14.     return list.get(index);
    15. 
  
  
  
  
  15. }
    16.

使用局部变量可避免在堆上分配

由于堆资源是多线程共享的，是垃圾回收器工作的主要区域，过多的对象会造成 GC 压力，可以通过局部变量的方式，将变量在栈上分配。这种方式变量会随着方法执行的完毕而销毁，能够减轻 GC 的压力。

减少变量的作用范围

注意变量的作用范围，尽量减少对象的创建。

如下面的代码，变量 s 每次进入方法都会创建，可以将它移动到 if 语句内部。

 
 
 
 
    
  
  
  
  
  1. public void test(String str) {
    2. 
  
  
  
  
  2.     final int s = 100;
    3. 
  
  
  
  
  3.     if (!StringUtils.isEmpty(str)) {
    4. 
  
  
  
  
  4.         int result = s * s;
    5. 
  
  
  
  
  5.     }
    6. 
  
  
  
  
  6. }
    7.

尽量采用懒加载的策略，在需要的时候才创建

 
 
 
 
    
  
  
  
  
  1. String str = "月伴飞鱼";
    2. 
  
  
  
  
  2. if (name == "公众号") {
    3. 
  
  
  
  
  3.   list.add(str);
    4. 
  
  
  
  
  4. }
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. if (name == "公众号") {
    7. 
  
  
  
  
  7.   String str = "月伴飞鱼";
    8. 
  
  
  
  
  8.   list.add(str);
    9. 
  
  
  
  
  9. }
    10.

访问静态变量直接使用类名

使用对象访问静态变量，这种方式多了一步寻址操作，需要先找到变量对应的类，再找到类对应的变量。

 
 
 
 
    
  
  
  
  
  1. // 反例
    2. 
  
  
  
  
  2. nt i = objectA.staticMethod();
    3. 
  
  
  
  
  3. // 正例
    4. 
  
  
  
  
  4. nt i = ClassA.staticMethod();
    5.

字符串拼接使用StringBuilder

字符串拼接，使用 StringBuilder 或者 StringBuffer，不要使用 + 号。

 
 
 
 
    
  
  
  
  
  1. //反例
    2. 
  
  
  
  
  2. public class StringTest {
    3. 
  
  
  
  
  3.     @Test
    4. 
  
  
  
  
  4.     public void testStringPlus() {
    5. 
  
  
  
  
  5.         String str = "111";
    6. 
  
  
  
  
  6.         str += "222";
    7. 
  
  
  
  
  7.         str += "333";
    8. 
  
  
  
  
  8.         System.out.println(str);
    9. 
  
  
  
  
  9.     }
    10. 
  
  
  
  
  10.      
    11. 
  
  
  
  
  11. }
    12. 
  
  
  
  
  12. 
  
  
  
  
  13. //正例
    14. 
  
  
  
  
  14. public class TestMain {
    15. 
  
  
  
  
  15.     public static void main(String[] args) {
    16. 
  
  
  
  
  16.         StringBuilder sb = new StringBuilder("111");
    17. 
  
  
  
  
  17.         sb.append("222");
    18. 
  
  
  
  
  18.         sb.append(333);
    19. 
  
  
  
  
  19.         System.out.println(sb.toString());
    20. 
  
  
  
  
  20.     }
    21. 
  
  
  
  
  21. }
    22.

重写对象的HashCode，不要简单地返回固定值

有同学在开发重写 HashCode 和 Equals 方法时，会把 HashCode 的值返回固定的 0，而这样做是不恰当的

当这些对象存入 HashMap 时，性能就会非常低，因为 HashMap 是通过 HashCode 定位到 Hash 槽，有冲突的时候，才会使用链表或者红黑树组织节点，固定地返回 0，相当于把 Hash 寻址功能无效了。

HashMap等集合初始化的时候，指定初始值大小

这样的对象有很多，比如 ArrayList，StringBuilder 等，通过指定初始值大小可减少扩容造成的性能损耗。

初始值大小计算可以参考《阿里巴巴开发手册》：

循环内不要不断创建对象引用

 
 
 
 
    
  
  
  
  
  1. //反例
    2. 
  
  
  
  
  2. for (int i = 1; i <= size; i++) {
    3. 
  
  
  
  
  3.     Object obj = new Object();    
    4. 
  
  
  
  
  4. }
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. //正例
    7. 
  
  
  
  
  7. Object obj = null;
    8. 
  
  
  
  
  8. for (int i = 0; i <= size; i++) {
    9. 
  
  
  
  
  9.     obj = new Object();
    10. 
  
  
  
  
  10. }
    11.

第一种会导致内存中有size个Object对象引用存在，size很大的话，就耗费内存了

遍历Map 的时候，使用 EntrySet 方法

使用 EntrySet 方法，可以直接返回 set 对象，直接拿来用即可;而使用 KeySet 方法，获得的是key 的集合，需要再进行一次 get 操作，多了一个操作步骤，所以更推荐使用 EntrySet 方式遍历 Map。

 
 
 
 
    
  
  
  
  
  1. Set> entryseSet = nmap.entrySet();
    2. 
  
  
  
  
  2. for (Map.Entry entry : entryseSet) {
    3. 
  
  
  
  
  3.     System.out.println(entry.getKey()+","+entry.getValue());
    4. 
  
  
  
  
  4. }
    5.

不要在多线程下使用同一个 Random

Random 类的 seed 会在并发访问的情况下发生竞争，造成性能降低，建议在多线程环境下使用 ThreadLocalRandom 类。

 
 
 
 
    
  
  
  
  
  1. public static void main(String[] args) {
    2. 
  
  
  
  
  2.        ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
    3. 
  
  
  
  
  3.        Thread thread1 = new Thread(()->{
    4. 
  
  
  
  
  4.            for (int i=0;i<10;i++){
    5. 
  
  
  
  
  5.                System.out.println("Thread1:"+threadLocalRandom.nextInt(10));
    6. 
  
  
  
  
  6.            }
    7. 
  
  
  
  
  7.        });
    8. 
  
  
  
  
  8.        Thread thread2 = new Thread(()->{
    9. 
  
  
  
  
  9.            for (int i=0;i<10;i++){
    10. 
  
  
  
  
  10.                System.out.println("Thread2:"+threadLocalRandom.nextInt(10));
    11. 
  
  
  
  
  11.            }
    12. 
  
  
  
  
  12.        });
    13. 
  
  
  
  
  13.        thread1.start();
    14. 
  
  
  
  
  14.        thread2.start();
    15. 
  
  
  
  
  15.    }
    16.

自增推荐使用LongAddr

自增运算可以通过 synchronized 和 volatile 的组合来控制线程安全，或者也可以使用原子类(比如 AtomicLong)。

后者的速度比前者要高一些，AtomicLong 使用 CAS 进行比较替换，在线程多的情况下会造成过多无效自旋，可以使用 LongAdder 替换 AtomicLong 进行进一步的性能提升。

 
 
 
 
    
  
  
  
  
  1. public class Test {
    2. 
  
  
  
  
  2.     public int longAdderTest(Blackhole blackhole) throws InterruptedException {
    3. 
  
  
  
  
  3.         LongAdder longAdder = new LongAdder();
    4. 
  
  
  
  
  4.         for (int i = 0; i < 1024; i++) {
    5. 
  
  
  
  
  5.             longAdder.add(1);
    6. 
  
  
  
  
  6.         }
    7. 
  
  
  
  
  7.         return longAdder.intValue();
    8. 
  
  
  
  
  8.     }
    9. 
  
  
  
  
  9. }
    10.

程序中要少用反射

反射的功能很强大，但它是通过解析字节码实现的，性能就不是很理想。

现实中有很多对反射的优化方法，比如把反射执行的过程(比如 Method)缓存起来，使用复用来加快反射速度。

Java 7.0 之后，加入了新的包java.lang.invoke，同时加入了新的 JVM 字节码指令 invokedynamic，用来支持从 JVM 层面，直接通过字符串对目标方法进行调用。

分享文章：分享几个工作中实用的代码优化技巧！
分享地址：http://www.shufengxianlan.com/qtweb/news4/247954.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

企业建站知识

各行业网站

成都网站建设　　 　犀浦门窗定制　　 　八点广告　　 　网站建设公司　　 　手机网站建设　　 　网站制作价格　　 　成都网站建设公司　　 　培训网站方案　　 　网站建设开发　　 　LED网站设计方案　　 　资中网站建设　　 　网络营销公司　　 　护栏钻孔机　　 　国泰民安消防　　 　水泥基自流平　　 　一元广告　　 　西信服务器托管　　 　B2C电商系统　　 　四川成都展柜定制厂家　　 　无边发光字制作