Admin: 1 версия

2010-06-01T05:05:29Z

1 версия

в 17:44, 31 мая 2010

2010-05-31T17:44:27Z

Новая страница

== 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>



<pre class=codeResult>1
2
3
4
5</pre>

== 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 <code>int[]</code>) and
* primitive wrapper arrays (like <code>Integer[]</code>).
*
* This class tries to handle <code>null</code> input gracefully.
* An exception will not be thrown for a <code>null</code>
* array input. However, an Object array that contains a <code>null</code>
* 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 <code>null</code>, a new one element array is returned
* whose component type is the same as the element.
*
* <pre>
* ArrayUtils.add(null, 0) = [0]
* ArrayUtils.add([1], 0) = [1, 0]
* ArrayUtils.add([1, 0], 1) = [1, 0, 1]
* </pre>
*
* @param array the array to copy and add the element to, may be <code>null</code>
* @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 <code>null</code>.
* @param newArrayComponentType If <code>array</code> is <code>null</code>, 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>



<pre class=codeResult>Original size: 5
New size: 10
Original size: 9
New size: 18</pre>

== 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>



<pre class=codeResult>Original size: 5
New size: 10
Original size: 9
New size: 18</pre>

== 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>

← Предыдущая	Версия 05:05, 1 июня 2010
(нет различий)

Java Tutorial/Collections/Array Copy Clone - История изменений

Admin: 1 версия

в 17:44, 31 мая 2010