常用代码优化方法

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

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

List<String> collection = new ArrayList<String>(5);

Map<String,Sting> map = new HashMap<String,String>(32);

ArrayList随机速度快，LinkedList添加删除快

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

for(int i=0,len=collection.size;i<len;i++){}

使用Entry遍历Map

for(Map.Entry<String,String> entry:map.entrySet()){

  String key = entry.getKey();

  String value = entry.getValue();

}

大数组复制用System.arraycopy

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

Integer i = 100 ;

System.out.println(i) ;

不要手动调用System.gc()

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

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();

                   Object object = elements[size-1];

                   elements[size-1] = null;

                   size--;

                   return object;

         }

   // elements[size-1] = null;如果没有这句，会造成内存泄漏

         /**

          * 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);

         }

}

尽量使用局部变量，尽量减小变量的作用域（为了尽快的做垃圾回收）

尽量使用非同步的容器ArrayList，而不是Vetor（很多方法上加入了synchronize），需要加锁时手动加

尽量减小同步作用范围，使用synchronize代码块而不是synchronize方法

##f1和f2是等价的

##f3和f4是等价的 // static方法上加锁相当于在class对象上加锁

public class SynchronizedTest {

         public static void main(String[] args) {

         }

         public synchronized void f1() {//在this对象上加鎖

                   System.out.println("f1");

         }

         public  void f2() {

                   synchronized(this) {

                            System.out.println("f2");

                   }

         }

         public static synchronized void f3() {

                   System.out.println("f3");

         }

         public static void f4() {

                   synchronized(SynchronizedTest.class) {

                            System.out.println("f4");

                   }

         }

}

ThreadLocal缓存线程不安全的对象，比如SimplDateFormat（对象new的成本比较高）

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;

         }

}

尽量少用反射，加缓存

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

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

尽量使用try … finally

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

异常也是比较耗资源的对象

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

正则表达式的性能低

能用replace不要用replaceAll，replaceAll是正则表达式的函数

split

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

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

Log.info(“orderid:”+orderid); //不推荐，因为会new StringBuilder

Log.info(“ordered{}”,orderid); //推荐