newInstance比new慢, 但某些情况下可忽略性能差异 new在十万次到二十亿次都是5毫秒左右不再增加, new基本没有等比增加耗时, 可能与虚拟机优化有关, 又或者是new实在太快了,十亿次以下都测不出准确耗时 单纯newInstance的性能的话, 用创建空String的实例来测可能比较真实

测试用例202206021331 AMD4800H64G

测试代码

package newInstance;

import java.lang.reflect.InvocationTargetException;

public class New和NewInstance速度对比2206021229 {
	
	static int sum;
	static void pln(Object o) {System.out.println(o);}
	
	public static class C2206021230{
		public  C2206021230(int a, int b) {
			sum += a + b;
		}
	}
	
	static int amount = 10_0000;
	
	static void test1() {
		long beginning = System.currentTimeMillis();
		
		for(int c=0; c<amount; c++) {
			new C2206021230(1, 2);
		}
		
		long t1 = System.currentTimeMillis();
		long cost1 = t1-beginning;
		pln("new C2206021230(1, 2) , "+amount+"次, 花费 "+cost1+" 毫秒");
		
		for(int c=0; c<amount; c++) {
			try {
				C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2);
			} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
					| InvocationTargetException | NoSuchMethodException | SecurityException e) {
				e.printStackTrace();
			}
		}
		long t2 = System.currentTimeMillis();
		long cost2 = t2-t1;
		pln("C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , "+amount+"次, 花费 "+cost2+" 毫秒");
	}
	
	public static void main(String...arguments) {
		test1();
		pln("sum="+sum);
	}

}

一万次结果

new C2206021230(1, 2) , 10000次, 花费 1 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 10000次, 花费 14 毫秒
sum=60000

五万次结果

new C2206021230(1, 2) , 50000次, 花费 2 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 50000次, 花费 28 毫秒
sum=300000

十万次结果

new C2206021230(1, 2) , 100000次, 花费 4 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 100000次, 花费 28 毫秒
sum=600000

二十万次结果

new C2206021230(1, 2) , 200000次, 花费 4 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 200000次, 花费 39 毫秒
sum=1200000

三十万次结果

new C2206021230(1, 2) , 300000次, 花费 5 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 300000次, 花费 47 毫秒
sum=1800000

五十万次结果

new C2206021230(1, 2) , 500000次, 花费 5 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 500000次, 花费 50 毫秒
sum=3000000

一百万次结果

new C2206021230(1, 2) , 1000000次, 花费 4 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 1000000次, 花费 83 毫秒
sum=6000000

二百万次结果

new C2206021230(1, 2) , 2000000次, 花费 4 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 2000000次, 花费 98 毫秒
sum=12000000

五百万次结果

new C2206021230(1, 2) , 5000000次, 花费 4 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 5000000次, 花费 143 毫秒
sum=30000000

一千万次结果

new C2206021230(1, 2) , 10000000次, 花费 4 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 10000000次, 花费 218 毫秒
sum=60000000

三千万次结果

new C2206021230(1, 2) , 30000000次, 花费 6 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 30000000次, 花费 616 毫秒
sum=180000000

五千万次结果

new C2206021230(1, 2) , 50000000次, 花费 4 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 50000000次, 花费 780 毫秒
sum=300000000

一亿次结果

new C2206021230(1, 2) , 100000000次, 花费 5 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 100000000次, 花费 1382 毫秒
sum=600000000

两亿次结果

new C2206021230(1, 2) , 200000000次, 花费 5 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 200000000次, 花费 2543 毫秒
sum=1200000000

三亿次结果

new C2206021230(1, 2) , 300000000次, 花费 5 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 300000000次, 花费 3723 毫秒
sum=1800000000

四亿次结果

new C2206021230(1, 2) , 400000000次, 花费 5 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 400000000次, 花费 4868 毫秒
sum=-1894967296

五亿次结果

new C2206021230(1, 2) , 500000000次, 花费 5 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 500000000次, 花费 6063 毫秒
sum=-1294967296

十亿次结果

new C2206021230(1, 2) , 1000000000次, 花费 6 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 1000000000次, 花费 11685 毫秒
sum=1705032704

二十亿次结果

new C2206021230(1, 2) , 2000000000次, 花费 5 毫秒
C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2) , 2000000000次, 花费 23242 毫秒
sum=-884901888

测试用例2206021931

测试代码

package newInstance;

import java.lang.reflect.InvocationTargetException;

public class New和NewInstance速度对比2206021916 {
	
	static long sum;
	static void pln(Object o) {System.out.println(o);}
	
	public static class C2206021230{
		public  C2206021230(int a, int b) {
			sum += a + b;
		}
	}
	
	static int w = 10000;
	static int amountArray[] = new int[] {
			w,w,w,w,w,w,
			w,20000,30000,40000,50000,60000,70000,80000,90000,
			w,20000,30000,40000,50000,60000,70000,80000,90000,
			10*w, 20*w, 30*w, 40*w, 50*w, 60*2, 70*w, 80*w, 90*w,
			100*w, 200*w, 300*w, 400*w, 500*w, 600*w, 700*w, 800*w, 900*w,
			1000*w, 2000*w, 3000*w, 4000*w, 5000*w, 6000*w, 7000*w, 8000*w, 9000*w,
			1*w*w, 2*w*w, 3*w*w,
			};
	
	static void test1(int amount) {
		long beginning = System.currentTimeMillis();
		
		for(int c=0; c<amount; c++) {
			new C2206021230(1, 2);
		}
		
		long t1 = System.currentTimeMillis();
		long cost1 = t1-beginning;
		
		for(int c=0; c<amount; c++) {
			try {
				C2206021230.class.getDeclaredConstructor(int.class, int.class).newInstance(1, 2);
			} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
					| InvocationTargetException | NoSuchMethodException | SecurityException e) {
				e.printStackTrace();
			}
		}
		long t2 = System.currentTimeMillis();
		long cost2 = t2-t1;
		pln("执行 "+amount/10000+"万次, new用时 "+cost1 +" 毫秒     ,    newInstance用时 " + cost2+ "毫秒");
	}
	
	public static void main(String...arguments) {
		for(int amount : amountArray) {
			test1(amount);
		}
	}

}

测试结果

执行 1万次, new用时 1 毫秒 , newInstance用时 13毫秒 执行 1万次, new用时 0 毫秒 , newInstance用时 6毫秒 执行 1万次, new用时 0 毫秒 , newInstance用时 5毫秒 执行 1万次, new用时 0 毫秒 , newInstance用时 3毫秒 执行 1万次, new用时 0 毫秒 , newInstance用时 3毫秒 执行 1万次, new用时 0 毫秒 , newInstance用时 2毫秒 执行 1万次, new用时 0 毫秒 , newInstance用时 3毫秒 执行 2万次, new用时 1 毫秒 , newInstance用时 4毫秒 执行 3万次, new用时 1 毫秒 , newInstance用时 7毫秒 执行 4万次, new用时 0 毫秒 , newInstance用时 14毫秒 执行 5万次, new用时 1 毫秒 , newInstance用时 1毫秒 执行 6万次, new用时 0 毫秒 , newInstance用时 1毫秒 执行 7万次, new用时 0 毫秒 , newInstance用时 2毫秒 执行 8万次, new用时 0 毫秒 , newInstance用时 1毫秒 执行 9万次, new用时 0 毫秒 , newInstance用时 1毫秒 执行 1万次, new用时 0 毫秒 , newInstance用时 0毫秒 执行 2万次, new用时 0 毫秒 , newInstance用时 0毫秒 执行 3万次, new用时 1 毫秒 , newInstance用时 1毫秒 执行 4万次, new用时 0 毫秒 , newInstance用时 0毫秒 执行 5万次, new用时 0 毫秒 , newInstance用时 4毫秒 执行 6万次, new用时 0 毫秒 , newInstance用时 2毫秒 执行 7万次, new用时 0 毫秒 , newInstance用时 2毫秒 执行 8万次, new用时 1 毫秒 , newInstance用时 1毫秒 执行 9万次, new用时 1 毫秒 , newInstance用时 2毫秒 执行 10万次, new用时 0 毫秒 , newInstance用时 3毫秒 执行 20万次, new用时 1 毫秒 , newInstance用时 4毫秒 执行 30万次, new用时 0 毫秒 , newInstance用时 3毫秒 执行 40万次, new用时 0 毫秒 , newInstance用时 6毫秒 执行 50万次, new用时 0 毫秒 , newInstance用时 9毫秒 执行 0万次, new用时 0 毫秒 , newInstance用时 0毫秒 执行 70万次, new用时 0 毫秒 , newInstance用时 13毫秒 执行 80万次, new用时 0 毫秒 , newInstance用时 14毫秒 执行 90万次, new用时 3 毫秒 , newInstance用时 13毫秒 执行 100万次, new用时 5 毫秒 , newInstance用时 11毫秒 执行 200万次, new用时 1 毫秒 , newInstance用时 34毫秒 执行 300万次, new用时 0 毫秒 , newInstance用时 53毫秒 执行 400万次, new用时 1 毫秒 , newInstance用时 72毫秒 执行 500万次, new用时 1 毫秒 , newInstance用时 94毫秒 执行 600万次, new用时 2 毫秒 , newInstance用时 84毫秒 执行 700万次, new用时 2 毫秒 , newInstance用时 78毫秒 执行 800万次, new用时 2 毫秒 , newInstance用时 88毫秒 执行 900万次, new用时 2 毫秒 , newInstance用时 100毫秒 执行 1000万次, new用时 1 毫秒 , newInstance用时 110毫秒 执行 2000万次, new用时 4 毫秒 , newInstance用时 233毫秒 执行 3000万次, new用时 5 毫秒 , newInstance用时 334毫秒 执行 4000万次, new用时 7 毫秒 , newInstance用时 453毫秒 执行 5000万次, new用时 10 毫秒 , newInstance用时 562毫秒 执行 6000万次, new用时 11 毫秒 , newInstance用时 675毫秒 执行 7000万次, new用时 13 毫秒 , newInstance用时 777毫秒 执行 8000万次, new用时 15 毫秒 , newInstance用时 895毫秒 执行 9000万次, new用时 16 毫秒 , newInstance用时 1000毫秒 执行 10000万次, new用时 18 毫秒 , newInstance用时 1111毫秒 执行 20000万次, new用时 36 毫秒 , newInstance用时 2227毫秒 执行 30000万次, new用时 53 毫秒 , newInstance用时 3337毫秒

测试用例2206021933

测试代码

package newInstance;

import java.lang.reflect.InvocationTargetException;

public class New和NewInstance速度对比2206021933 {
	
	static long sum;
	static void pln(Object o) {System.out.println(o);}
	
	static int w = 10000;
	static int amountArray[] = new int[] {
			w,w,w,w,w,w,
			w,20000,30000,40000,50000,60000,70000,80000,90000,
			w,20000,30000,40000,50000,60000,70000,80000,90000,
			10*w, 20*w, 30*w, 40*w, 50*w, 60*2, 70*w, 80*w, 90*w,
			100*w, 200*w, 300*w, 400*w, 500*w, 600*w, 700*w, 800*w, 900*w,
			1000*w, 2000*w, 3000*w, 4000*w, 5000*w, 6000*w, 7000*w, 8000*w, 9000*w,
			1*w*w, 2*w*w, 3*w*w,
			};
	
	
	
	static void test1(int amount) {
		
		long beginning = System.currentTimeMillis();
		
		for(int c=0; c<amount; c++) {
			new String(String.valueOf(Math.random()));
		}
		
		long t1 = System.currentTimeMillis();
		long cost1 = t1-beginning;
		
		for(int c=0; c<amount; c++) {
			try {
				String.class.getDeclaredConstructor(String.class).newInstance(String.valueOf(Math.random()));
			} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
					| InvocationTargetException | NoSuchMethodException | SecurityException e) {
				e.printStackTrace();
			}
		}
		long t2 = System.currentTimeMillis();
		long cost2 = t2-t1;
		pln("<tr><td>"+amount+"</td><td>"+amount/w+"万次</td><td>"+cost1+"</td><td>"+cost2+"</td></tr>");
	}
	
	public static void main(String...arguments) {
		pln("""
				<table><thead><tr>
					<th>执行次数</th><th>执行万次数</th><th>new 的用时(毫秒)</th><th>newInstance 的用时(毫秒)</th>
				</tr></thead><tbody>
				""");
		for(int amount : amountArray) {
			test1(amount);
		}
		pln("</tbody></table>");
	}

}

测试结果

执行次数	执行万次数	new 的用时(毫秒)	newInstance 的用时(毫秒)
10000	1万次	10	29
10000	1万次	4	12
10000	1万次	2	10
10000	1万次	2	8
10000	1万次	2	4
10000	1万次	2	4
10000	1万次	2	4
20000	2万次	3	9
30000	3万次	6	12
40000	4万次	6	14
50000	5万次	8	15
60000	6万次	6	9
70000	7万次	7	37
80000	8万次	29	16
90000	9万次	12	18
10000	1万次	1	2
20000	2万次	4	4
30000	3万次	4	7
40000	4万次	6	7
50000	5万次	7	9
60000	6万次	8	11
70000	7万次	9	12
80000	8万次	9	13
90000	9万次	11	14
100000	10万次	12	20
200000	20万次	25	40
300000	30万次	38	60
400000	40万次	51	80
500000	50万次	63	100
120	0万次	0	1
700000	70万次	88	131
800000	80万次	95	124
900000	90万次	106	137
1000000	100万次	118	154
2000000	200万次	235	304
3000000	300万次	352	460
4000000	400万次	471	611
5000000	500万次	590	765
6000000	600万次	704	918
7000000	700万次	821	1072
8000000	800万次	936	1223
9000000	900万次	988	1292
10000000	1000万次	983	1439
20000000	2000万次	1968	2874
30000000	3000万次	2953	4311
40000000	4000万次	3943	5749
50000000	5000万次	4927	7189
60000000	6000万次	5913	8733
70000000	7000万次	6905	10073
80000000	8000万次	7886	11505
90000000	9000万次	8872	12948
100000000	10000万次	9920	14394
200000000	20000万次	19758	28889
300000000	30000万次	29616	43465

测试用例2206021956

测试代码

package newInstance;

import java.lang.reflect.InvocationTargetException;

public class New和NewInstance速度对比2206021956 {
	
	static long sum;
	static void pln(Object o) {System.out.println(o);}
	
	static int w = 10000;
	static int amountArray[] = new int[] {
			w,w,w,w,w,w,
			w,20000,30000,40000,50000,60000,70000,80000,90000,
			w,20000,30000,40000,50000,60000,70000,80000,90000,
			10*w, 20*w, 30*w, 40*w, 50*w, 60*w, 70*w, 80*w, 90*w,
			100*w, 200*w, 300*w, 400*w, 500*w, 600*w, 700*w, 800*w, 900*w,
			1000*w, 2000*w, 3000*w, 4000*w, 5000*w, 6000*w, 7000*w, 8000*w, 9000*w,
			1*w*w, 2*w*w, 3*w*w,
			10*w*w,
			};
	
	
	
	static void test1(int amount) {
		
		long beginning = System.currentTimeMillis();
		
		for(int c=0; c<amount; c++) {
			new String();
		}
		
		long t1 = System.currentTimeMillis();
		long cost1 = t1-beginning;
		
		for(int c=0; c<amount; c++) {
			try {
				String.class.getDeclaredConstructor().newInstance();
			} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
					| InvocationTargetException | NoSuchMethodException | SecurityException e) {
				e.printStackTrace();
			}
		}
		long t2 = System.currentTimeMillis();
		long cost2 = t2-t1;
		pln("<tr><td>"+amount+"</td><td>"+amount/w+"万次</td><td>"+cost1+"</td><td>"+cost2+"</td></tr>");
	}
	
	public static void main(String...arguments) {
		pln("""
				<table><thead><tr>
					<th>执行次数</th><th>执行万次数</th><th>new 的用时(毫秒)</th><th>newInstance 的用时(毫秒)</th>
				</tr></thead><tbody>
				""");
		for(int amount : amountArray) {
			test1(amount);
		}
		pln("</tbody></table>");
	}

}

测试结果

执行次数	执行万次数	new 的用时(毫秒)	newInstance 的用时(毫秒)
10000	1万次	0	14
10000	1万次	0	10
10000	1万次	1	6
10000	1万次	0	5
10000	1万次	0	3
10000	1万次	0	3
10000	1万次	0	3
20000	2万次	0	6
30000	3万次	0	10
40000	4万次	0	10
50000	5万次	1	11
60000	6万次	0	16
70000	7万次	0	3
80000	8万次	1	3
90000	9万次	1	4
10000	1万次	0	2
20000	2万次	0	1
30000	3万次	0	0
40000	4万次	0	2
50000	5万次	0	2
60000	6万次	0	2
70000	7万次	0	4
80000	8万次	0	6
90000	9万次	0	6
100000	10万次	0	6
200000	20万次	0	12
300000	30万次	0	12
400000	40万次	0	13
500000	50万次	0	35
600000	60万次	0	39
700000	70万次	0	44
800000	80万次	0	52
900000	90万次	0	61
1000000	100万次	0	39
2000000	200万次	0	66
3000000	300万次	0	100
4000000	400万次	0	132
5000000	500万次	0	167
6000000	600万次	0	197
7000000	700万次	0	232
8000000	800万次	1	264
9000000	900万次	0	295
10000000	1000万次	0	332
20000000	2000万次	0	660
30000000	3000万次	0	994
40000000	4000万次	0	1327
50000000	5000万次	0	1656
60000000	6000万次	1	1985
70000000	7000万次	1	2319
80000000	8000万次	1	2665
90000000	9000万次	2	2981
100000000	10000万次	1	3316
200000000	20000万次	4	6646
300000000	30000万次	4	9997
1000000000	100000万次	15	33188