java代码效率比较_java开发之java代码优化前后性能对比测试

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import java.util.StringTokenizer;

public class Test {

public static void main(String argv[]) {

/*

* 避免在循环条件中使用复杂表达式

* @author yifangyou

* @since 2011-08-16 09:35:00

*

*/

// test0();

/*

* 如果只是查找单个字符的话，用charAt()代替startsWith()

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

// test1();

/*

* 能够使用移位的乘除，最好用移位

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

// test2();

/*

* 只有一个字符的字符串拼接，用''代替""

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

// test3();

/**

* try catch最好不要放在循环里

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

// test4();

/**

* switch的实现 map比较稳定,if最慢，switch在数量少于10个时最快，随着数量增加下降厉害

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

// test5();

/*

* 对于常量字符串，用'String' 代替 'StringBuffer' ,节省空间,节省时间

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

// test6();

/*

* 用'StringTokenizer' 代替 'indexOf()' 和'substring()'

* 字符串的分析在很多应用中都是常见的。使用indexOf

* ()和substring()来分析字符串容易导致StringIndexOutOfBound***ception。

* 而使用StringTokenizer类来分析字符串则会容易一些，效率也会低一些。

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

// test7();

/*

* 不要在循环体中实例化变量 在循环体中实例化临时变量将会增加内存消耗

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

// test8();

/*

* 确定 StringBuffer的容量

* StringBuffer的构造器会创建一个默认大小(通常是16)的字符数组。在使用中，如果超出这个大小

* ，就会重新分配内存，创建一个更大的数组，并将原先的数组复制过来，再丢弃旧的数组。在大多数情况下，你可以在创建

* StringBuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

// test9();

/*

* 尽可能的使用栈变量

*

* 如果一个变量需要经常访问，那么你就需要考虑这个变量的作用域了。static?

* local?还是实例变量？访问静态变量和实例变量将会比访问局部变量多耗费2-3个时钟周期。

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

// test10();

/**

* 复制数组最好用System.arraycopy 逐个复制,最慢；批量复制,最快

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

// copyArray();

/*

* 复制ArrayList数组最好用addAll addAll，最快;clone,次之,逐个最慢

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

// copyArrayList();

/*

* 复制Map最好用逐个复制最快，putAll最简单

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

copyMap();

}

int localN = 0;

static int staticN = 0;

/*

* 避免在循环条件中使用复杂表达式

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

public static void test0() {

ArrayList a = new ArrayList();

for (int i = 0; i < 10000000; i++) {

a.add(i);

}

long startTime;

// 循环条件中使用复杂表达式

startTime = new Date().getTime();

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

int j = a.get(i);

}

System.out.println(new Date().getTime() - startTime);

// 循环条件中不使用复杂表达式

startTime = new Date().getTime();

for (int i = 0, maxlen = a.size(); i < maxlen; i++) {

int j = a.get(i);

}

System.out.println(new Date().getTime() - startTime);

}

/*

* 如果只是查找单个字符的话，用charAt()代替startsWith()

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

public static void test1() {

String s = "sdfsdfsdfsdfdssssssssssssssssssssssssssssdfffffffffffffffa";

long startTime;

// startsWith

startTime = new Date().getTime();

for (int i = 0; i < 10000000; i++) {

if (s.startsWith("a")) {

}

}

System.out.println(new Date().getTime() - startTime);

// charAt

startTime = new Date().getTime();

for (int i = 0; i < 10000000; i++) {

if (s.charAt(0) == 'a') {

}

}

System.out.println(new Date().getTime() - startTime);

// charAt

startTime = new Date().getTime();

for (int i = 0; i < 10000000; i++) {

if ("ab".equals("abcdssdds".substring(0, 2))) {

}

}

System.out.println(new Date().getTime() - startTime);

}

/*

* 能够使用移位的乘除，最好用移位

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

public static void test2() {

long startTime;

int a;

//

startTime = new Date().getTime();

for (int i = 0; i < 10000000; i++) {

a = 333333333 / 8;

}

System.out.println(new Date().getTime() - startTime);

// charAt

startTime = new Date().getTime();

for (int i = 0; i < 10000000; i++) {

a = 333333333 >> 3;

}

System.out.println(new Date().getTime() - startTime);

}

/*

* 只有一个字符的字符串拼接，用''代替""

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

public static void test3() {

long startTime;

startTime = new Date().getTime();

String s = "123";

for (int i = 0; i < 10000000; i++) {

String a = s + "d";

}

System.out.println(new Date().getTime() - startTime);

// charAt

startTime = new Date().getTime();

for (int i = 0; i < 10000000; i++) {

String a = s + 'd';

}

System.out.println(new Date().getTime() - startTime);

}

/**

* try catch最好不要放在循环里

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

public static void test4() {

long startTime;

startTime = new Date().getTime();

for (int i = 0; i < 10000000; i++) {

try {

int a = Integer.parseInt("1");

} catch (Exception e) {

}

}

System.out.println(new Date().getTime() - startTime);

startTime = new Date().getTime();

try {

for (int i = 0; i < 10000000; i++) {

int a = Integer.parseInt("1");

}

} catch (Exception e) {

}

System.out.println(new Date().getTime() - startTime);

}

/**

* switch的实现 map比较稳定,if最慢，switch在数量少于10个时最快，随着数量增加下降厉害,在switch最好把出现次数最多的判断放在最前面

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

public static void test5() {

HashMap types = new HashMap() {

{

int i = 0;

this.put("a", i++);

this.put("b", i++);

this.put("c", i++);

this.put("d", i++);

this.put("e", i++);

}

};

String a = "e";

int b = 0;

long startTime;

startTime = new Date().getTime();

for (int i = 0; i < 10000000; i++) {

if ("a".equals(a)) {

b = 0;

} else if ("b".equals(a)) {

b = 1;

} else if ("c".equals(a)) {

b = 2;

} else if ("d".equals(a)) {

b = 3;

} else if ("e".equals(a)) {

b = 4;

}

}

System.out.println(new Date().getTime() - startTime);

startTime = new Date().getTime();

for (int i = 0; i < 10000000; i++) {

b = types.get(a);

}

System.out.println(new Date().getTime() - startTime);

int c = 14;//改为0的话则最快

startTime = new Date().getTime();

for (int i = 0; i < 10000000; i++) {

switch (c) {

case 0:

break;

case 1:

break;

case 2:

break;

case 3:

break;

case 4:

break;

case 5:

break;

case 6:

break;

case 7:

break;

case 8:

break;

case 9:

break;

case 10:

break;

case 11:

break;

case 12:

break;

case 13:

break;

case 14:

break;

default:

break;

}

}

System.out.println(new Date().getTime() - startTime);

}

/*

* 对于常量字符串，用'String' 代替 'StringBuffer' ,节省空间,节省一半时间

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

public static void test6() {

StringBuffer s = new StringBuffer("Hello");

int maxlen=1000000;

long startTime;

startTime = new Date().getTime();

for (int i = 0; i < maxlen; i++) {

String t =new String("Hello ") + "World!";

}

System.out.println(new Date().getTime() - startTime);

startTime = new Date().getTime();

for (int i = 0; i < maxlen; i++) {

StringBuffer t =new StringBuffer("Hello ").append("World!");

}

System.out.println(new Date().getTime() - startTime);

}

/*

* 用'StringTokenizer' 代替 'indexOf()' 和'substring()'

* 字符串的分析在很多应用中都是常见的。使用indexOf

* ()和substring()来分析字符串容易导致StringIndexOutOfBound***ception。

* 而使用StringTokenizer类来分析字符串则会容易一些，效率也会低一些。

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

public static void test7() {

String domain = "www.a.com.";

long startTime;

startTime = new Date().getTime();

for (int i = 0; i < 100000; i++) {

int index = 0;

while ((index = domain.indexOf(".", index + 1)) != -1) {

domain.substring(index + 1, domain.length());

// System.out.println(domain.substring(index+1,

// domain.length()));

}

}

System.out.println(new Date().getTime() - startTime);

startTime = new Date().getTime();

for (int i = 0; i < 100000; i++) {

StringTokenizer st = new StringTokenizer(domain, ".");

while (st.hasMoreTokens()) {

st.nextToken();

// System.out.println(st.nextToken());

}

}

System.out.println(new Date().getTime() - startTime);

}

/*

* 不要在循环体中实例化变量 在循环体中实例化临时变量将会增加内存消耗

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

public static void test8() {

ArrayList a = new ArrayList();

int maxlen = 10000000;

for (int i = 0; i < maxlen; i++) {

a.add(i);

}

long startTime;

startTime = new Date().getTime();

for (int i = 0; i < maxlen; i++) {

Object o = new Object();

o = a.get(i);

}

System.out.println(new Date().getTime() - startTime);

Object o = new Object();

startTime = new Date().getTime();

for (int i = 0; i < maxlen; i++) {

o = a.get(i);

}

System.out.println(new Date().getTime() - startTime);

}

/*

* 确定 StringBuffer的容量

* StringBuffer的构造器会创建一个默认大小(通常是16)的字符数组。在使用中，如果超出这个大小，就会重新分配内存

* ，创建一个更大的数组，并将原先的数组复制过来，再丢弃旧的数组。在大多数情况下，你可以在创建

* StringBuffer的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

public static void test9() {

int maxlen = 1000000;

long startTime;

startTime = new Date().getTime();

for (int i = 0; i < maxlen; i++) {

StringBuffer buffer = new StringBuffer(); // violation

buffer.append("hellosdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");

}

System.out.println(new Date().getTime() - startTime);

startTime = new Date().getTime();

for (int i = 0; i < maxlen; i++) {

StringBuffer buffer = new StringBuffer(128); // violation

buffer.append("hellosdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");

}

System.out.println(new Date().getTime() - startTime);

}

/*

* 尽可能的使用栈变量 如果一个变量需要经常访问，那么你就需要考虑这个变量的作用域了。static?

* local?还是实例变量？访问静态变量和实例变量将会比访问局部变量多耗费2-3个时钟周期。

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

public static void test10() {

int maxlen = 100000000;

long startTime;

int n = 0;

Test test = new Test();

// 局部变量

startTime = new Date().getTime();

for (int i = 0; i < maxlen; i++) {

n = i;

}

System.out.println(new Date().getTime() - startTime);

// 类变量

startTime = new Date().getTime();

for (int i = 0; i < maxlen; i++) {

test.localN = i;

}

System.out.println(new Date().getTime() - startTime);

// 静态变量

startTime = new Date().getTime();

for (int i = 0; i < maxlen; i++) {

Test.staticN = i;

}

System.out.println(new Date().getTime() - startTime);

}

//

// /*1.尽量使用final修饰符。

//带有final修饰符的类是不可派生的。在JAVA核心API中，有许多应用final的例子，例如java.lang.String。为String类指定final防止了使用者覆盖length()方法。另外，如果一个类是final的，则该类所有方法都是final的。java编译器会寻找机会内联(inline)所有的final方法(这和具体的编译器实现有关)。此举能够使性能平均提高50%。

// */

// public static void test11() {

// int maxlen = 10000000;

// long startTime;

// int n = 0;

//

// // 普通类

// startTime = new Date().getTime();

// A a = new A();

// for (int i = 0; i < maxlen; i++) {

// a.inc();

// }

// System.out.println(new Date().getTime() - startTime);

//

// // final类

// startTime = new Date().getTime();

// FinalA finalA = new FinalA();

// for (int i = 0; i < maxlen; i++) {

// finalA.inc();

// }

// System.out.println(new Date().getTime() - startTime);

// }

/**

* 复制数组最好用System.arraycopy 逐个复制,最慢；批量复制,最快

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

static void copyArray() {

int[] array1 = new int[10000000];

int[] array2 = new int[10000000];

for (int i = 0, maxlen = array1.length; i < maxlen; i++) {

array1[i] = i;

}

long startTime;

// 逐个复制,最慢

startTime = new Date().getTime();

for (int i = 0, maxlen = array2.length; i < maxlen; i++) {

array2[i] = array1[i]; // Violation

}

System.out.println(new Date().getTime() - startTime);

// 批量复制,最快

startTime = new Date().getTime();

System.arraycopy(array1, 0, array2, 0, 10000);

System.out.println(new Date().getTime() - startTime);

}

/*

* 复制ArrayList数组最好用addAll addAll，最快;clone,次之,逐个最慢

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

static void copyArrayList() {

int maxlen = 1000000;

ArrayList array1 = new ArrayList();

ArrayList array2 = new ArrayList();

ArrayList array3 = new ArrayList();

ArrayList array4;

for (int i = 0; i < maxlen; i++) {

array1.add(i);

}

long startTime;

// 逐个复制,最慢

startTime = new Date().getTime();

for (int i = 0; i < maxlen; i++) {

array2.add(array1.get(i)); // Violation

}

System.out.println(new Date().getTime() - startTime);

// 批量复制，最快

startTime = new Date().getTime();

array3.addAll(array1);

System.out.println(new Date().getTime() - startTime);

// 克隆，次快

startTime = new Date().getTime();

array4 = (ArrayList) array1.clone();

System.out.println(new Date().getTime() - startTime);

array4.set(0, 4);

System.out.println("array1[0]=" + array1.get(0));

System.out.println("array4[0]=" + array4.get(0));

}

/*

* 复制Map最好用逐个复制最快，putAll最简单

* @author yifangyou

* @since 2011-08-16 09:35:00

*/

static void copyMap() {

int maxlen = 1000000;

Map map1 = new HashMap();

Map map2 = new HashMap();

Map map3 = new HashMap();

Map map4 = new HashMap();

for (int i = 0; i < maxlen; i++) {

map1.put(i, i);

}

long startTime;

// 逐个复制，最快

startTime = new Date().getTime();

Set key = map1.keySet();

for (Iterator it = key.iterator(); it.hasNext();) {

Integer k = (Integer) it.next();

map2.put(k, map1.get(k));

}

System.out.println(new Date().getTime() - startTime);

// 批量复制，最慢

startTime = new Date().getTime();

map3.putAll(map1);

System.out.println(new Date().getTime() - startTime);

System.out.println("map2[9999]=" + map2.get(9999));

System.out.println("map3[9999]=" + map3.get(9999));

// 逐个复制，次快

startTime = new Date().getTime();

Set> set = map1.entrySet();

for (Iterator> it = set.iterator(); it

.hasNext();) {

Map.Entry entry = (Map.Entry) it

.next();

map4.put(entry.getKey(), entry.getValue());

}

System.out.println(new Date().getTime() - startTime);

}

}