Java Tutorial/Collections/Array Copy Clone

Array clone

   <source lang="java">

public class MainClass {

 public static void main (String args[]) {
   int array1[] = {1, 2, 3, 4, 5};
   int[] clone = (int[]) array1.clone();    
   for(int i: clone){
     System.out.println(i);  
   }
   
 }

}</source>

1
2
3
4
5

Copies the given array and adds the given element at the end of the new array. (long value type)

   <source lang="java">

/* Copyright 2004 The Apache Software Foundation

*
*   Licensed under the Apache License, Version 2.0 (the "License");
*   you may not use this file except in compliance with the License.
*   You may obtain a copy of the License at
*
*       http://www.apache.org/licenses/LICENSE-2.0
*
*   Unless required by applicable law or agreed to in writing, software
*   distributed under the License is distributed on an "AS IS" BASIS,
*   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*   See the License for the specific language governing permissions and
*  limitations under the License.
*/

import java.lang.reflect.Array;

/**

*

Operations on arrays, primitive arrays (like int[]) and * primitive wrapper arrays (like Integer[]).

* 

*

This class tries to handle null input gracefully. * An exception will not be thrown for a null * array input. However, an Object array that contains a null * element may throw an exception. Each method documents its behaviour.

*
* @author Stephen Colebourne
* @author Moritz Petersen
* @author 
* @author Maarten Coene
* @since 2.0
* @version $Id: ArrayUtils.java 632503 2008-03-01 00:21:52Z ggregory $
*/

public class Main {

 /**

*

Copies the given array and adds the given element at the end of the new array.

  *

*

The new array contains the same elements of the input * array plus the given element in the last position. The component type of * the new array is the same as that of the input array.

  *

*

If the input array is null, a new one element array is returned * whose component type is the same as the element.

  * 

*

   * ArrayUtils.add(null, 0)   = [0]
   * ArrayUtils.add([1], 0)    = [1, 0]
   * ArrayUtils.add([1, 0], 1) = [1, 0, 1]
   * 

  * 
  * @param array  the array to copy and add the element to, may be null
  * @param element  the object to add at the last index of the new array
  * @return A new array containing the existing elements plus the new element
  * @since 2.1
  */
 public static long[] add(long[] array, long element) {
     long[] newArray = (long[])copyArrayGrow1(array, Long.TYPE);
     newArray[newArray.length - 1] = element;
     return newArray;
 }
 
 /**
  * Returns a copy of the given array of size 1 greater than the argument. 
  * The last value of the array is left to the default value.
  * 
  * @param array The array to copy, must not be null.
  * @param newArrayComponentType If array is null, create a 
  * size 1 array of this type.
  * @return A new copy of the array of size 1 greater than the input.
  */    
 private static Object copyArrayGrow1(Object array, Class newArrayComponentType) {
     if (array != null) {
         int arrayLength = Array.getLength(array);
         Object newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
         System.arraycopy(array, 0, newArray, 0, arrayLength);
         return newArray;
     }
     return Array.newInstance(newArrayComponentType, 1);
 }

}</source>

Copying and Cloning Arrays

   <source lang="java">

public class MainClass {

 public static void main (String args[]) {
   int array1[] = {1, 2, 3, 4, 5};
   int array2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
   System.out.println("Original size: " + array1.length);
   System.out.println("New size: " + doubleArray(array1).length);
   System.out.println("Original size: " + array2.length);
   System.out.println("New size: " + doubleArray(array2).length);
 }
 static int[] doubleArray(int original[]) {
   int length = original.length;
   int newArray[] = new int[length*2];
   System.arraycopy(original, 0, newArray, 0, length);
   return newArray;
 }

}</source>

Original size: 5
New size: 10
Original size: 9
New size: 18

Copy some items of an array into another array

   <source lang="java">

public class Main {

 public static void main(String[] args) {
   String[] letters = { "A", "I", "U", "E", "O" };
   String[] results = new String[3];
   System.arraycopy(letters, 2, results, 0, 3);
   for (int i = 0; i < results.length; i++) {
     System.out.println("result = " + results[i]);
   }
 }

}</source>

Doubling the size of an array

   <source lang="java">

public class MainClass {

 public static void main (String args[]) {
   int array1[] = {1, 2, 3, 4, 5};
   int array2[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
   System.out.println("Original size: " + array1.length);
   System.out.println("New size: " + doubleArray(array1).length);
   System.out.println("Original size: " + array2.length);
   System.out.println("New size: " + doubleArray(array2).length);
 }
 static int[] doubleArray(int original[]) {
   int length = original.length;
   int newArray[] = new int[length*2];
   System.arraycopy(original, 0, newArray, 0, length);
   return newArray;
 }

}</source>

Original size: 5
New size: 10
Original size: 9
New size: 18

use Arrays.copyOf to copy array

   <source lang="java">

import java.util.Arrays; class MainClass {

   public static void main(String args[])
   {
       int arrayOriginal[] = {42, 55, 21};
       int arrayNew[] =
           Arrays.copyOf(arrayOriginal, 3);             
       printIntArray(arrayNew);
   }
   static void printIntArray(int arrayNew[])
   {
       for (int i : arrayNew)
       {
           System.out.print(i);
           System.out.print(" ");
       }
       System.out.println();
   }

}</source>

Using Arrays.copyOf to copy an array

   <source lang="java">

import java.util.Arrays; public class ArrayCopy {

 public static void main(String args[]) {
   System.out.printf("Before (original)\t%s%n", Arrays.toString(args));
   String copy[] = Arrays.copyOf(args, 4);
   System.out.printf("Before (copy)\t\t%s%n", Arrays.toString(copy));
   copy[0] = "A";
   copy[1] = "B";
   copy[2] = "C";
   copy[3] = "D";
   System.out.printf("After (original)\t%s%n", Arrays.toString(args));
   System.out.printf("After (copy)\t\t%s%n", Arrays.toString(copy));
 }

}</source>