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

类成员与方法的可见性最小化
举例：如果是一个private的方法，想删除就删除
如果一个public的service方法，或者一个public的成员变量，删除一下，不得思考很多。
使用位移操作替代乘除法
计算机是使用二进制表示的，位移操作会极大地提高性能。
<< 左移相当于乘以 2；>> 右移相当于除以 2；
>>> 无符号右移相当于除以 2，但它会忽略符号位，空位都以 0 补齐

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

复制代码

尽量减少对变量的重复计算
我们知道对方法的调用是有消耗的，包括创建栈帧、调用方法时保护现场，恢复现场等。

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

复制代码

在list.size()很大的时候，就减少了很多的消耗。
不要捕捉RuntimeException
RuntimeException 不应该通过 catch 语句去捕捉，而应该使用编码手段进行规避。
如下面的代码，list 可能会出现数组越界异常。
是否越界是可以通过代码提前判断的，而不是等到发生异常时去捕捉。
提前判断这种方式，代码会更优雅，效率也更高。

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

复制代码

使用局部变量可避免在堆上分配
由于堆资源是多线程共享的，是垃圾回收器工作的主要区域，过多的对象会造成 GC 压力，可以通过局部变量的方式，将变量在栈上分配。这种方式变量会随着方法执行的完毕而销毁，能够减轻 GC 的压力。
减少变量的作用范围
注意变量的作用范围，尽量减少对象的创建。
如下面的代码，变量 s 每次进入方法都会创建，可以将它移动到 if 语句内部。

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

复制代码

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

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

复制代码

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

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

复制代码

字符串拼接使用StringBuilder


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

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

复制代码

重写对象的HashCode，不要简单地返回固定值
有同学在开发重写 HashCode 和 Equals 方法时，会把 HashCode 的值返回固定的 0，而这样做是不恰当的
当这些对象存入 HashMap 时，性能就会非常低，因为 HashMap 是通过 HashCode 定位到 Hash 槽，有冲突的时候，才会使用链表或者红黑树组织节点，固定地返回 0，相当于把 Hash 寻址功能无效了。
HashMap等集合初始化的时候，指定初始值大小
这样的对象有很多，比如 ArrayList，StringBuilder 等，通过指定初始值大小可减少扩容造成的性能损耗。


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

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

复制代码

第一种会导致内存中有size个Object对象引用存在，size很大的话，就耗费内存了
遍历Map 的时候，使用 EntrySet 方法
使用 EntrySet 方法，可以直接返回 set 对象，直接拿来用即可；而使用 KeySet 方法，获得的是key 的集合，需要再进行一次 get 操作，多了一个操作步骤，所以更推荐使用 EntrySet 方式遍历 Map。

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

复制代码

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


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

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

复制代码

自增推荐使用LongAddr
自增运算可以通过 synchronized 和 volatile 的组合来控制线程安全，或者也可以使用原子类（比如 AtomicLong）。
后者的速度比前者要高一些，AtomicLong 使用 CAS 进行比较替换，在线程多的情况下会造成过多无效自旋，可以使用 LongAdder 替换 AtomicLong 进行进一步的性能提升。

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

复制代码

程序中要少用反射
反射的功能很强大，但它是通过解析字节码实现的，性能就不是很理想。
现实中有很多对反射的优化方法，比如把反射执行的过程（比如 Method）缓存起来，使用复用来加快反射速度。
Java 7.0 之后，加入了新的包 java.lang.invoke，同时加入了新的 JVM 字节码指令 invokedynamic，用来支持从 JVM 层面，直接通过字符串对目标方法进行调用。

有些事交给编译器吧

不太确定有一些是不是没必要。。。 例如位移代替乘法 这种优化非常微小。。。 感觉这些编译器就会帮你做的优化不如在IO/网络上的优化来得直接

我觉得专门在 loop 里存 size() 过于 over-optimization 了，有时候可读性更重要，而且他们的 performance 其实差不多

https://stackoverflow.com/questi ... minating-expression

herecomes 发表于 2021-6-28 11:41
有些事交给编译器吧

我想给你点赞，但是系统不让，只好手写点赞了

还有少用stream api这种 runtime都太慢 是决不允许的
实话实说 我们的runtime连for loop都要尽量避免 关键要看你的平台性能要求了

感谢楼主
俺只想说这么写会被CR的烙印搞死

很蓝的啦 发表于 2021-06-28 00:20:20
至少java里的list.size()是直接return 一个private 的int size变量。
我看到lc很多人都喜欢int n=list.size()， 感觉十分无语。

不是，只是 n 比 list.size() 短