java 6 中的数组复制

  Java语言包含了一些精彩的“古董”。例如仍然不支持在switch语句中使用String对象。(不过已经更新为可以支持enum类型了) 。这个理由似乎可以追溯到switch语句是源自于c语言。不论如何，在switch语句中不能使用string对象进行判断对我来说都是很不方便的。
  System.arraycopy, 快速拷贝数组内容到另一数组的方法，似乎也有类似的传统。方法名称看上去像一个旧风格的C函数memcpy，这意味着Java的数组复制方法从第一个版本以来就没有改变.
  arraycopy这个方法是一个系统级别的静态方法，具备很强大的功能，通常的写法如下：
  System.arraycopy(sourceArray, sourceStartIndex, targetArray, targetStartIndex, length);
  该arraycopy方法不仅仅是支持复制到目标数组的全部内容，此外，arraycopy允许设置源和目标的起始索引以及长度来进行内容元素的拷贝。这种额外的灵活性是很有用的，尽管它可能不是我在通常情况下所需要的。例如ArrayList类在插入一个元素时就是用arraycopy来转移数组的内容，这个方法执行得非常快: 在底层不是Java实现的，而是JVM调用的本地方法来实现。
  大多情况下，我需要复制整个数组而不是子集。 我也不需要频繁的转变数组中的元素。 我的System.arrayCopy调用大多需要两行代码：
      String[] source = { "alpha", "beta", "gamma" };
      String[] target = new String[source.length];
      System.arraycopy(source, 0, target, 0, source.length);
更进一步，出于重用性的需要，需要多一点儿的Java代码,如下：
private final <T> T[] copy(T[] source) {
   T[] target = new T[source.length]; // This will not compile!
     System.arraycopy(source, 0, target, 0, source.length);
     return target;
   }
好的，这段代码并不能真正的工作，编译会出错：
Cannot create a generic array of T
通过反射可以解决这个编译问题，下面是可以正确编译的代码：
private final <T> T[] copy(T[] source) {
   Class type = source.getClass().getComponentType();
   T[] target = (T[])Array.newInstance(type, source.length);
   System.arraycopy(source, 0, target, 0, source.length);
   return target;
}
Java编译器会显示一个警告“Type safety: the case from Object to T[] is actually checking against the erased type Object[]” 使用反射意味着没有足够的信息告诉编译器这是否是一个错误的cast，但这确实是一个快速的能够绕过那个讨厌的警告的方法。
@SuppressWarnings("unchecked")
private final <T> T[] copy(T[] source) {
   Class type = source.getClass().getComponentType();
   T[] target = (T[])Array.newInstance(type, source.length);
   System.arraycopy(source, 0, target, 0, source.length);
   return target;
}
包装了这个copy方法，我的客户端代码就很简单了，如下：
String[] source = { "alpha", "beta", "gamma" };
String[] target = copy(source);
好了，我已经快速建立了自己的通用拷贝方法。

copyof的介绍
在Java 6中，我不再需要推出自己的实用方法：Sun公司推出了复制一个数组的直接支持：copyof， 基本使用方法如下：
targetArray = Arrays.copyOf(sourceArray, length);
我写了几个JUnit的测试，以证明copyOf法（及其变种）。 这里的第一个测试，显示其基本功能：
@Test
public void genericArrayCopyOf() {
   Number[] source = { new Double(5.0), new Double(10.0) };
   Number[] target = Arrays.copyOf(source, source.length);
   assertEquals(source, target);
}
JUnit4的一个不错的新特点是它能够使用assertEquals比较两个数组。首先比较JUnit的每个数组的长度,如果两个数组的长度相同，jUnit再比较数组的每个元素中是否相等，如果数组不同，JUnit则提供了一个失败的消息，并显示了不一致的值。
Java重载copyOf以支持原始类型，以及扩展使用。下一项测试显示了这一点：
@Test
public void copyOfWithRange() {
   String[] source = { "0", "1", "2", "3", "4" };
   String[] target = Arrays.copyOfRange(source, 2, 4);
   assertEquals(new String[] { "2", "3" }, target);
}
这是一个数组复制原始使用的测试
@Test
public void primitives() {
   int[] source = { 0, 1, 2, 3, 4 };
   int[] target = Arrays.copyOfRange(source, 4, 5);
   assertEqualsPrim(new int[] { 4 }, target);
}
我写的方法assertEqualsPrim因为JUnit 4不比较两个数组中包含的原始对象。它仅比较两个数组对象的版本。 使用assertEquals比较两个数组意味着Java进行内存地址比较。不过没关系，assertEqualsPrim是很容易写的：
static void assertEqualsPrim(int[] expected, int[] actual) {
   if (expected.length != actual.length)
      fail(String.format("expected length = %s, actual length = %s",
            expected.length, actual.length));
   for (int i = 0; i < expected.length; i++) {
      if (expected[i] != actual[i])
         fail(String.format(
               "mismatch at index %d: expected [%s] but was [%s]", i,
               expected[i], actual[i]));
   }
如果我想通过强制转换返回结果的方式来进行数组拷贝,就会出现下面的测试失败：
@Test
public void genericArrayCopyOfWithNewType() {
   Number[] source = { new Double(5.0), new Double(10.0) };
   Double[] target = (Double[])Arrays.copyOf(source, source.length);
   assertEquals(source, target); // fail!
}
好在java 6中可以通过声明新类型的方式进行数组拷贝
@Test
public void genericArrayCopyOfWithNewType() {
   Number[] source = { new Double(5.0), new Double(10.0) };
   Double[] target = Arrays.copyOf(source, source.length, Double[].class);
   assertEquals(source, target);
}

性能以及替代方案

其实我可以使用Clone方法实现数组复制，所以技术上copyOf是没有必要的。不过，我匆匆写的一个性能测试表明，克隆是相当缓慢。他们还表明，copyOf比arraycopy还慢。所以我将使用新的copyOf方法。

广告时间：轻松阅读尽在阅读地带