关于java数组拷贝的性能

java 提供的System.arrayCopy()方法比自己写的数组copy要快.

查看其源代码:

1. public static native void arraycopy(Object src,  int  srcPos,
2.                                         Object dest, int destPos,
3.                                         int length);

可以看到被定义为native方法...速度比自己写的普通方法要快.

 

在jdk1.6中加入了新的数组拷贝方法.Arrays.copyOfRange().

其源代码:

1.  public static byte[] copyOfRange(byte[] original, int from, int to) {
2.         int newLength = to - from;
3.         if (newLength < 0)
4.             throw new IllegalArgumentException(from + " > " + to);
5.         byte[] copy = new byte[newLength];
6.         System.arraycopy(original, from, copy, 0,
7.                          Math.min(original.length - from, newLength));
8.         return copy;
9.     }

 

其实就是System.arraycopy..晕死.

 

别为做的测试:

1. /*******************************************************************************
2.  *
3.  * 比较赋值与System.arraycopy谁快
4.  *
5.  * 复制的内容越多，System.arraycopy优势更明显
6.  *
7.  * Author: NeedJava
8.  *
9.  * Modified: 2007.09.16
10.  *
11.  ******************************************************************************/
12. public final class WhoFaster
13. {
14.   public static void main( String[] args )
15.   {
16.     /*/
17.     int begin=100; 
19.     int length=12; 
21.     String temp="12345678901234567890"
22.                +"12345678901234567890"
23.                +"12345678901234567890"
24.                +"12345678901234567890"
25.                +"12345678901234567890"
26.                +"黑客帝国忍者神龟变形金刚"
27.                +"12345678901234567890"
28.                +"12345678901234567890"
29.                +"12345678901234567890"
30.                +"12345678901234567890"
31.                +"12345678901234567890"; 
33.     int times=10000000;  //千万
34.     /*/
35.     int begin=100; 
37.     int length=120; 
39.     String temp="12345678901234567890"
40.                +"12345678901234567890"
41.                +"12345678901234567890"
42.                +"12345678901234567890"
43.                +"12345678901234567890"
44.                +"黑客帝国忍者神龟变形金刚"
45.                +"黑客帝国忍者神龟变形金刚"
46.                +"黑客帝国忍者神龟变形金刚"
47.                +"黑客帝国忍者神龟变形金刚"
48.                +"黑客帝国忍者神龟变形金刚"
49.                +"黑客帝国忍者神龟变形金刚"
50.                +"黑客帝国忍者神龟变形金刚"
51.                +"黑客帝国忍者神龟变形金刚"
52.                +"黑客帝国忍者神龟变形金刚"
53.                +"黑客帝国忍者神龟变形金刚"
54.                +"12345678901234567890"
55.                +"12345678901234567890"
56.                +"12345678901234567890"
57.                +"12345678901234567890"
58.                +"12345678901234567890"; 
60.     int times=1000000;  //百万
61.     //*/ 
63.     char[] oldArray=temp.toCharArray(); 
65.     char[] newArray=null; 
67.     long start=0L; 
70.     
71.     //
72.     // 单纯赋值
73.     //
74.     
75.     newArray=new char[length]; 
77.     start=System.currentTimeMillis(); 
79.     for( int i=0; i<times; i++ )
80.        {
81.          for( int j=0; j<length; j++ )
82.             {
83.               newArray[j]=oldArray[begin+j];
84.             }
85.        } 
87.     System.out.println( new String( newArray )+"　"+( System.currentTimeMillis()-start ) ); 
90.     
91.     //
92.     // System.arraycopy
93.     //
94.     
95.     newArray=new char[length]; 
97.     start=System.currentTimeMillis(); 
99.     for( int i=0; i<times; i++ )
100.        {
101.          System.arraycopy( oldArray, begin, newArray, 0, length );
102.        } 
104.     System.out.println( new String( newArray )+"　"+( System.currentTimeMillis()-start ) );
105.   }
106. } 

 

其结论:

在第一种情况，循环千万，一个900，一个1000，两者相差100毫秒

第二种情况就拉大了，循环千万，一个6700，一个2200，相差4500毫秒

为防止JVM将字符数组作为常量保存在内存中，我分别屏蔽运行，效果一样。

也就是说，对于很短的字符串复制，单纯赋值略快，可以忽略

对于很长的字符串复制，用单纯赋值就是脏代码