java代码优化笔记

小鱼儿 2022-04-15 05:10 242阅读 0赞

本文列举java开发中代码优化的一些方法。

### 尽量重用对象，不要循坏创建对象，比如：for循环字符串拼接 ###

在[这篇文章][Link 1]里面介绍了为什么不能循环拼接字符串对象。

### 容器类初始化的时候指定长度 ###

例如map和list，如果我们知道我们的数据量有多大，我们最好一开始的时候就指定长度，因为这些list和map在扩容的时候，会做一些例如数据复制的动作或者重新hash的复杂动作，影响效率。  
先说arraylist，它内部存储的结构其实是数组，扩容的时候需要复制一遍原来的数据，影响效率；而hashmap在resize的时候，也是很复杂，会影响效率。另外hashmap有一点不同的，传入值不一定会作为初始化容量值，例如传入3，最终tableSizeFor得到的初始化容量值是4，总是2的n次方，是为了hash的时候key分布得更加均匀。

### ArrayList随机遍历快，LnkedLiset添加删除快 ###

### 集合遍历尽量减少重复计算 ###

例如：for(int i = 0,len=collection.size;i<len;i++)\{\}，也就是collection.size()尽量先计算出来，以后就不用再计算了。

### 使用Entry遍历Map ###

for(Map.entry<String,String> entry:map.entrySet())\{  
String key = entry.getKey();  
String value = entry.getValue();  
\}  
使用entry一次性把key和value取出来了，如果只取keySet，那么如果要value就要再get一遍，所以最好一起取出来。

### 大数组复制使用System.arraycopy ###

因为System.arraycopy使用的是原生的方法，所以效率比较高，速度比较快

### 尽量使用基本类型而不是包装类型 ###

为什么这么说呢？先看一段代码：

public static void main(String[] args) {
            int i = 100;
            System.out.println(i);
    
            Integer i2 = 100;
            System.out.println(i2);
        }

它编译生产的字节码是：

0: bipush        100
             2: istore_1
             3: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
             6: iload_1
             7: invokevirtual #5                  // Method java/io/PrintStream.println:(I)V
            10: bipush        100
            12: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
            15: astore_2
            16: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
            19: aload_2
            20: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/Object;)V

我们可以看到，调用包装类型的时候，多了一步：

invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

也就是这个基本类型会通过valueOf被包装成Integer类型，所以使用包装类型的时候，都会有一个类似valueOf的操作，把基本类型变成包装类型，这里就会有一点性能上的影响了。  
关于valueOf，我们再看下面一段代码：

public static void main(String[] args) {
            Integer i1=100;
            Integer i2 = 100;
            System.out.println(i1==i2);
    
            Integer i3=1000;
            Integer i4=1000;
            System.out.println(i3==i4);
        }

输出true和false  
看了Integer的valueOf源码：

public static Integer valueOf(int i) {
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }

low默认是-128，hign默认是127，所以如果之前有缓存，小于127的都可以从缓存里面读取，所以是相等的。大于127就自己创建了，所以 就不相等。

### 不要手动调用System.gc() ###

System.gc()通知垃圾收集器进行fullGC，但是什么时候fullgc是不确定的。而且生产环境可能会加+DisableExplicitGC来禁用System.gc()，所以开发过程中最好不要有依赖System.gc()的代码。

### 及时消除过期对象的引用，防止内存泄露 ###

这里有一个模拟stack的类，表面上很难看出问题。

public class Stack {
    	private Object[] elements;
    	private int size = 0;
    	private static final int DEFAULT_INITIAL_CAPACITY = 16;
    
    	public Stack() {
    		elements = new Object[DEFAULT_INITIAL_CAPACITY];
    	}
    
    	public void push(Object e) {
    		ensureCapacity();
    		elements[size++] = e;
    	}
    	public Object pop() {
    		if (size == 0)
    			throw new EmptyStackException();
    		return elements[--size];
    	}
    
    	/**
    	 * Ensure space for at least one more element, roughly doubling the capacity
    	 * each time the array needs to grow.
    	 */
    	private void ensureCapacity() {
    		if (elements.length == size)
    			elements = Arrays.copyOf(elements, 2 * size + 1);
    	}
    }

问题出在这里：

public Object pop() {
    		if (size == 0)
    			throw new EmptyStackException();
    		return elements[--size];
    	}

我们返回了elements的最后一个元素，那么现在有elements\[size-1\]指向的对象有两个引用，一个是elements\[size-1\]，一个是外面引用它的引用，如果外面引用释放了这个对象，elements\[size-1\]这个指针一直还在，对象也不会释放，这里一直被引用着，所以存在内存泄漏的风险，正确的做法是修改为：

public Object pop() {
    		if (size == 0)
    			throw new EmptyStackException();
    		Object object = elements[size-1];
    		elements[size-1] = null;
    		size--;
    		return object;
    	}

或者：

public Object pop() {
    		if (size == 0)
    			throw new EmptyStackException();
    		Object object = elements[--size];
    		elements[size] = null;
    		return object;
    	}

来自《effective java》中文版 第二版page21

### 尽量使用局部变量，减小变量的作用域 ###

因为作用域越小，出了作用域，对象就可以被回收了，可以尽快地做垃圾回收。

### 尽量使用非同步容器 ###

例如，优先考虑使用ArrayList而不是Vector，因为Vector的几乎每个方法都是synchronized，影响效率。

### 尽量减小同步作用范围，synchronized方法vs同步代码块 ###

在非static方法上加锁，其实就相当于在this上加锁，例如下面两个方法就是效率就是一样的：

public synchronized void f1() {//在this對象上加锁
    		System.out.println("f1");
    	}
    	public  void f2() {
    		synchronized(this) {
    			System.out.println("f2");
    		}
    	}

但是如果下面，明显f2的效率比f1的要高：

public synchronized void f1() {//在this對象上加锁
    	       System.out.println("f");
    		System.out.println("f1");
    		System.out.println("f");
    	}
    	public  void f2() {
    	     System.out.println("f");
    		synchronized(this) {
    			System.out.println("f2");
    		}
    		System.out.println("f");
    	}

所以，从这个角度上来说，同步代码块比同步方法更能减小同步的范围，一般来说更加倾向使用同步代码块。  
如果是在static方法上加锁，那么就相当于在类上加锁，下面这两个方法是相同的：

public static synchronized void f3() {
    		System.out.println("f3");
    	}
    	public static void f4() {
    		synchronized(SynchronizedTest.class) {
    			System.out.println("f4");
    		}
    	}

### 用ThreadLocal缓存线程不安全对象，例如SimpleDateFormat ###

例如：

public class SimpleDateFormatUtil {
    	private static ThreadLocal<SimpleDateFormat> dateFormatHolder = new ThreadLocal<SimpleDateFormat>() {  
            protected SimpleDateFormat initialValue() {  
            	return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            }  
    	};
    	public static void main(String[] args) {
    		dateFormatHolder.get().format(new Date());
    	}
    }

这不仅保证了线程安全，也可以提高效率

### 尽量使用延时加载 ###

例如：

public class Singleton {
    	private Singleton() {}
    	private static class SingletonHolder{
    		private static Singleton instance = new Singleton();
    	}
    	public static Singleton getInstance() {
    		return SingletonHolder.instance;
    	}
    }

为什么说是延时加载呢？SingletonHolder是一个类，在不对这个类引用的时候，是不对这个类加载的；当引用SingletonHolder这个类的时候，会把里面的成员Singleton加载出来。SingletonHolder在初始化的时候，由jvm类加载机制保证，所以不会出现线程安全的问题。所以它是线程安全的，并且只有引用这个类的时候才加载，所以是延时加载的。

### 尽量减少使用反射，加缓存 ###

如果真的每次都要反射，试着把反射加缓存里面，下次就不用反射了。框架里面经常会使用这种机制。

### 尽量使用连接池，线程池，对象池，缓存 ###

我们知道，跟数据库建立连接是比较耗内存的，所以建立完连接，就放回去，下次可以使用

### 及时释放资源，I/O流、Socket、数据库连接 ###

jdk1.7开始使用了自动关闭资源的try语句

try (
    
                       // 声明、初始化两个可关闭的资源
    
                       BufferedReader br = new BufferedReader(new FileReader(
    
                                         "AutoCloseTest.java"));
    
                                         PrintStream ps = new PrintStream(new FileOutputStream(
    
                                                            "readme.txt"))) {
    
                                // 使用两个资源
    
                                System.out.println(br.readLine());
    
                                ps.println("test");
    
                       }

### 慎用异常，不要用异常来表示正常业务逻辑 ###

因为异常也是比较重的对象，发生异常的时候，会把整个堆栈记录下来，再往外抛，比较耗时间，会影响正常业务逻辑的时间

### String操作尽量少用正则表达式 ###

因为正则表达式虽然好用，却也做了复杂的操作，所以影响效率。  
例如String的replaceAll使用的就是正则，replace也是但是比较轻量（只是普通字符串替换），所以能用replace的尽量不要用replaceAll。

### 日志输出注意使用不同的级别 ###

有的日志在生产环境打的，有的日志在测试环境打的，生产环境打太多日志会影响效率，生产环境只打关键的日志。

### 日志中参数拼接使用占位符 ###

log.info("orderId:"+orderId);不推荐
        log.info("orderId:{}",orderId);推荐

因为我们都知道，字符串的拼接实际上每次都要new String Builder，效率很低，这里[讲过][Link 1]  
另外即使我们设置了日志级别，info不输出，但是还是会把(“orderId:”+orderId这种字符串拼接拼出来，一样会影响效率。

[Link 1]: https://blog.csdn.net/fst438060684/article/details/84233480