數組復制java
㈠ java二維數組怎麼復制，，array方法行嗎麻煩給個例子。謝啦
java的多維數組的：希望採納
class C{
public static void main(String args[]){
int a[][] = {{1,2,3},{4,5,6}};
int b[][] = new int[a.length][a[0].length];
System.array(a,0,b,0,a.length); //通過array()函數拷貝數組
b[0][0] = 4; //改變數組b[0][0]的值
System.out.println("a[][]");
for(int i=0;i<2;i++){
for(int j=0;j<3;j++){
System.out.print(a[i][j]+" ");
}
System.out.println();
}
System.out.println("b[][]");
for(int i=0;i<2;i++){
for(int j=0;j<3;j++){
System.out.print(b[i][j]+" ");
}
System.out.println();
}
}
列印的結果如下：
a[][]
4 2 3
4 5 6
b[][]
4 2 3
4 5 6
而如果把上述程序中的二維數組改為一維數組，結果卻不同。程序如下：
class C{
public static void main(String args[]){
int a[] = {1,2,3};
int b[] = new int[a.length];
System.array(a,0,b,0,a.length); //通過array()函數拷貝數組
b[0] = 4; //改變數組b[0]的值
System.out.println("a[]:");
for(int i=0;i<3;i++){
System.out.print(a[i] + " ");
}
System.out.println();
System.out.println("b[]:");
for(int i=0;i<3;i++){
System.out.print(b[i] + " ");
}
}
}
列印結果如下：
a[]:
1 2 3
b[]:
4 2 3
在
第一個程序中，用b[0][0] =
4;只改變了數組b[0][0]的值，可是結果卻是數組a[0][0]的值也發生了改變。而在第二個程序中，由於是一個一維數組，改變了b[0]的
值，a[0]的值卻並沒有受到影響，所以問題可能就出在數組的維數上。第一個程序中的a 是一個數組的數組(java
中沒有多維數組的概念，只有數組的數組),同理b 也是，那麼a 含有兩個元素，第一個是指向(1,2,3)
這個數組的引用，第二個是指向(4,5,6）這個數組的引用，而arrayCopy 就是負責把數組的內容 過去的，因此 a 的內容 (2
個引用) 被 到b 中去了，因此你對b[0][0] 做修改，a 也會同樣跟著變化.
在JAVA裡面，可以用復制語句「A=B」給基本類型的數據傳遞值，但是如果A,B是兩個同類型的數組，復制就相當於將一個數組變數的引用傳遞給另一個數組；如果一個數組發生改變，那麼引用同一數組的變數也要發生改變。
JAVA中復制數組元素值的的方法指深拷貝
1 使用for循環，將數組的每個元素復制（需要將每個對象調用clone方法，才能實現真正的復制）
2 使用clone方法，得到數組的值，而不是引用
3 使用System.array方法
注意：
1.上面方法中array效率較高。
2. 以上所說的拷貝數組的方法，只是針對一維數組，對於多維數組，要在每一維用以上方法進行復制才能實現復制數組元素的值而不是引用。
3. clone 和 array對二維數組進行復制時，是淺拷貝， 即
Object[][] aa;
Object[][] bb = aa.clone();
//or bb＝System.array(aa,0,bb, 0, bb.length);
則：
boolean b1 = ( aa[i] == bb[i] ); //false
boolean b2 = (aa[i][j] == bb[i][j]); //true, 可見數組元素只復制了引用。新舊數組指向相同的內存地址，（不論對象數組，還是基本類型數組）。
/**
* 數組的淺拷貝是指數組拷貝時，只拷貝了數組的地址，新舊數組指向同一數據
* 數組的深拷貝，不論數據是基本類型，還是對象類型，都是一樣的。
* 對數組來說，不一樣的地方在於，當為數組元素賦值時，基本類型值傳遞，對象類型是引用傳遞。
*
*/
Object[] a = new Object[]{"String", new Integer(1)};
Object[] b = a;
/**
* 數組深拷貝的方法有如下幾種：
* 1。 調用clone
* 2。 調用System.array
* 以上兩種對基本類型和對象類型數據效果等同。
* 3。 使用FOR循環，將數組的每個元素復制。（注意調用clone方法）
*
*/
/*
* 當數組數據是基本類型時，
*/
// int[] array = new int[]{0,1,2,3,4};
// int[] = array.clone(); //1.拷貝數據
// System.out.println( .equals(array));
// System.out.println( == array );
// for (int i = 0; i < .length; i++) {
// System.out.print( [i]+", " );
// [i]++; //2.改變新數組數據內容
// System.out.print( [i]+", " );
// System.out.println( array[i]+","); //3.不影響原始數組
// }
// System.out.println();
/*
* 當數組數據是對象類型時，
*/
// Object[] src = new Object[]{ new String("Zhao"),
// Integer.valueOf(1),
// Integer.valueOf(2),
// Integer.valueOf(3),
// Integer.valueOf(4)};
//
// Object[] dest = src.clone(); //1.拷貝數據
//
//// Object[] dest = new Object[5];
//// System.array(src, 0, dest, 0, dest.length);
//
// System.out.println( dest.equals(src));
// System.out.println( dest == src );
// for (int i = 0; i < dest.length; i++) {
// System.out.print( dest[i]+", " );
// dest[i] = new String("KE"); //2.改變新數組內容
// System.out.print( dest[i]+", " );
// System.out.println( src[i]+","); //3.不影響原始數組
// }
// System.out.println();
/**
* 對多維數組(多維基本類型數組和多維對象數組完全一致。)
*
*/
//多維基本類型數組
int[][] aa = new int[][]{
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
// //多維對象類型數組
// Object[][] aa = new Object[][]{
// { Integer.valueOf(1),Integer.valueOf(2),Integer.valueOf(3) },
// { Integer.valueOf(4),Integer.valueOf(5),Integer.valueOf(6) },
// { Integer.valueOf(7),Integer.valueOf(8),Integer.valueOf(9) }
// };
/**
* 一維數組下的深拷貝在 多維數組 只是淺拷貝！！
*/
int[][] bb = aa.clone(); //一維數組下的深拷貝，對於二維數組只是淺拷貝！！
// int[][] bb = new int[aa.length][aa[0].length];
// System.array(aa, 0, bb, 0, aa.length);
// Object[][] bb = aa.clone();
//// Object[][] bb = new Object[3][3];
//// System.array(aa, 0, bb, 0, aa.length); //一維數組下的深拷貝，對於二維數組只是淺拷貝！！
/**
* 二維數組的深拷貝的實現方式！！！ 轉為一維數組拷貝。
*/
// for (int i = 0; i < bb.length; i++) { //實現深拷貝的方法！！！！！！！！！！！！
// System.array(aa[i], 0, bb[i], 0, aa[i].length);
// // bb[i] = aa[i].clone();
// }
System.out.println("＃＃ 初始 aa:" ); //1. 初始原數組
for (int i = 0; i < aa.length; i++) {
for (int j = 0; j < aa[i].length; j++) {
System.out.print(aa[i][j]+" ");
}
System.out.println( );
}
System.out.println("＃＃ bb = aa.clone() 後bb:" ); //2. 新數組（值等於原數組的值）
for (int i = 0; i < bb.length; i++) {
for (int j = 0; j < bb[i].length; j++) {
System.out.print(bb[i][j]+" ");
}
System.out.println( );
}
System.out.println("＃＃ bb改變後:" ); //3.改變新數組後
for (int i = 0; i < bb.length; i++) {
for (int j = 0; j < bb[i].length; j++) {
bb[i][j] += 10; //for 多維基本類型數組
// bb[i][j] = new String("Zhao"); //for 多維對象類型數組
System.out.print(bb[i][j]+" ");
}
System.out.println( );
}
System.out.println("＃＃ bb改變後， aa:" ); //4.輸出原數組
for (int i = 0; i < aa.length; i++) {
for (int j = 0; j < aa[i].length; j++) {
System.out.print(aa[i][j]+" ");
}
還有和c++不同，java定義int [][]a=new int[3][];是沒有問題的，c和c++後面就是必須要有維數，int a[][3];。
如果list裡面全是String[]，轉為String[][]，使用
(String[][]) bodyDataList.toArray(new String[bodyDataList.size()][]);這樣就能轉成功，還一直不清楚toArray(x)x裡面的東西，因為java裡面只有array對象
㈡ java怎麼把數組復制
publicclassArraysCopy{
publicstaticvoidmain(String[]args){
int[]arr={1,2,3,4};
int[]arr2=newint[arr.length];
System.array(arr,0,arr2,0,arr2.length);
System.out.println(java.util.Arrays.toString(arr2));
}
}
參數：
src-源數組。
srcPos-源數組中的起始位置。
dest-目標數組。
destPos-目標數據中的起始位置。
length-要復制的數組元素的數量。
㈢ Java中數組復制的幾種方法
最簡單的一種就是直接挨個把原數組的值賦給新數組 不過一般都用System.array(原數組起始復制的標號，新數組接收復制的起始標號，賦值的長度) 這個方法
例如：public class llx { public static void main(String args[]) { int a[] = {1,2,3,4,5}; int b[] = new int[10];//搞一個10位置的新數組 System.array(a[0],b[0],a.length);//從a的第一個位置開始復制；從b的第一個位置開始接收；一共接收a的總長度（a.length)；；；懂了嗎？這樣的話 b的前5個值就被傳遞了，但是後5個是初始值0。 }}
㈣ JAVA 數組拷貝
array方法只是淺層復制，就是單純的把值賦給目標 當值為引用類型時，這毫無意義，因為復制出來的對象不能獨立於原對象，當原來的引用內容改變時，復制的也改變。 當拷貝一維數組時，數組裡面也必須存放非引用值（比如int,char)才有效，不然你修改也一樣會影響原數組 當拷貝二維數組時，它相當於一個一維數組的每一項又存一個一維數組的首地址引用，那麼單純對二維數組使用array就沒有用了，要達到目的只有把它細分到不是引用值（比如你原來是對b拷貝，現在改成對b[0],b[1]...分別拷貝），再使用這個方法。
㈤ java多維數組怎麼復制
網上有這樣的一個例子
程序如下：
class C{
public static void main(String args[]){
int a[][] = {{1,2,3},{4,5,6}};
int b[][] = new int[a.length][a[0].length];
System.array(a,0,b,0,a.length); //通過array()函數拷貝數組
b[0][0] = 4; //改變數組b[0][0]的值
System.out.println("a[][]");
for(int i=0;i<2;i++){
for(int j=0;j<3;j++){
System.out.print(a[i][j]+" ");
}
System.out.println();
}
System.out.println("b[][]");
for(int i=0;i<2;i++){
for(int j=0;j<3;j++){
System.out.print(b[i][j]+" ");
}
System.out.println();
}
}
列印的結果如下：
a[][]
4 2 3
4 5 6
b[][]
4 2 3
4 5 6
而如果把上述程序中的二維數組改為一維數組，結果卻不同。程序如下：
class C{
public static void main(String args[]){
int a[] = {1,2,3};
int b[] = new int[a.length];
System.array(a,0,b,0,a.length); //通過array()函數拷貝數組
b[0] = 4; //改變數組b[0]的值
System.out.println("a[]:");
for(int i=0;i<3;i++){
System.out.print(a[i] + " ");
}
System.out.println();
System.out.println("b[]:");
for(int i=0;i<3;i++){
System.out.print(b[i] + " ");
}
}
}
列印結果如下：
a[]:
1 2 3
b[]:
4 2 3
在第一個程序中，用b[0][0] = 4;只改變了數組b[0][0]的值，可是結果卻是數組a[0][0]的值也發生了改變。而在第二個程序中，由於是一個一維數組，改變了b[0]的 值，a[0]的值卻並沒有受到影響，所以問題可能就出在數組的維數上。第一個程序中的a 是一個數組的數組(java 中沒有多維數組的概念，只有數組的數組),同理b 也是，那麼a 含有兩個元素，第一個是指向(1,2,3) 這個數組的引用，第二個是指向(4,5,6）這個數組的引用，而arrayCopy 就是負責把數組的內容 過去的，因此 a 的內容 (2 個引用) 被 到b 中去了，因此你對b[0][0] 做修改，a 也會同樣跟著變化.
在JAVA裡面，可以用復制語句「A=B」給基本類型的數據傳遞值，但是如果A,B是兩個同類型的數組，復制就相當於將一個數組變數的引用傳遞給另一個數組；如果一個數組發生改變，那麼引用同一數組的變數也要發生改變。
JAVA中復制數組元素值的的方法指深拷貝
1 使用for循環，將數組的每個元素復制（需要將每個對象調用clone方法，才能實現真正的復制）
2 使用clone方法，得到數組的值，而不是引用
3 使用System.array方法
注意：
1.上面方法中array效率較高。
2. 以上所說的拷貝數組的方法，只是針對一維數組，對於多維數組，要在每一維用以上方法進行復制才能實現復制數組元素的值而不是引用。
3. clone 和 array對二維數組進行復制時，是淺拷貝， 即
Object[][] aa;
Object[][] bb = aa.clone();
//or bb＝System.array(aa,0,bb, 0, bb.length);
則：
boolean b1 = ( aa[i] == bb[i] ); //false
boolean b2 = (aa[i][j] == bb[i][j]); //true, 可見數組元素只復制了引用。新舊數組指向相同的內存地址，（不論對象數組，還是基本類型數組）。
/**
* 數組的淺拷貝是指數組拷貝時，只拷貝了數組的地址，新舊數組指向同一數據
* 數組的深拷貝，不論數據是基本類型，還是對象類型，都是一樣的。
* 對數組來說，不一樣的地方在於，當為數組元素賦值時，基本類型值傳遞，對象類型是引用傳遞。
*
*/
Object[] a = new Object[]{"String", new Integer(1)};
Object[] b = a;
/**
* 數組深拷貝的方法有如下幾種：
* 1。 調用clone
* 2。 調用System.array
* 以上兩種對基
㈥ java中二維數組怎麼復制
/** * @Title: ArrayCopy.java * @Package com.sd.coding * @Description: TODO * @author Administrator * @date 2015-6-29 上午9:26:11 * @version V1.0 */package com.sd.coding; /** * @ClassName: ArrayCopy * @Description: TODO * @author Administrator * @date 2015-6-29 上午9:26:11 * 備註： */public class ArrayCopy { /** * @Title: main * @Description: TODO * @author sd * @date 2015-6-29 上午9:26:12 * @param args * @throws */ public static void main(String[] args) { // TODO Auto-generated method stub ArrayCopy arrayCopy = new ArrayCopy(); String[][] strArray=new String[][]{ {"a","b","c"}, {"A","B","C","D"}, {"1","2"} }; String[][] Array = arrayCopy.Array2(strArray); ArrayCopy.printArray(Array); } //列印數組 public static void printArray(String[][] array){ for(int i=0;i<array.length;i++){ for(int j=0;j<array[i].length;j++){ System.out.print(array[i][j]+" "); } System.out.println(); } } //使用循環語句遍歷復制 public String[][] Array1(String[][] array){ String[][] Array=new String[array.length][]; for(int i=0;i<array.length;i++){ Array[i]=new String[array[i].length]; for(int j=0;j<array[i].length;j++){ Array[i][j]=array[i][j]; } } return Array; } //使用java.lang.System.array()方法復制（推薦使用） public String[][] Array2(String[][] array){ String[][] Array=new String[array.length][]; for(int i=0;i<array.length;i++){ Array[i]=new String[array[i].length]; System.array(array[i], 0, array[i], 0, Array[i].length); } return array; }}
㈦ java復制數組數據到其他數組
不用這么麻煩吧。。。把原先的數據，循環拼接到新數組就行了吧
㈧ Java 如何拷貝數組的數據
這就是從指定的源數組復制一個數組到目的數組，復制是從指定位置開始到目標數組指定位置結束，
也就是從你的第一個數組0
index開始復制長度為3復制到目標的0開始前3位
簡單說system.array(a1,0,a2,0,3);
a1是你的原數組就是要提供復制的，0是你的原數組的開始位數，
也就是a1的index，a2是目的數組，就是需要復制到的，0是a2的開始位數嗎，也就是a2的index，3是復制的長度
㈨ JAVA如何將數組復制到另一個表中
E[]data ------ oldArray E[]temp ------ newArray ( but empty) for ( int 1 =0; i<data.size(); i++)temp[i] = data[i] ; // over; or JAVA API Collection Interface ( toArray method) !!! toArray<T> T[] toArray(T[] a) Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array. If the collection fits in the specified array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the specified array and the size of this collection. If this collection fits in the specified array with room to spare (i.e., the array has more elements than this collection), the element in the array immediately following the end of the collection is set to null. This is useful in determining the length of this collection only if the caller knows that this collection does not contain any null elements.) If this collection makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order. Like the toArray method, this method acts as bridge between array-based and collection-based APIs. Further, this method allows precise control over the runtime type of the output array, and may, under certain circumstances, be used to save allocation costs Suppose l is a List known to contain only strings. The following code can be used to mp the list into a newly allocated array of String: String[] x = (String[]) v.toArray(new String[0]); Note that toArray(new Object[0]) is identical in function to toArray(). </dd>Parameters: a - the array into which the elements of this collection are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose. Returns: an array containing the elements of this collection Throws: ArrayStoreException - the runtime type of the specified array is not a supertype of the runtime type of every element in this collection. NullPointerException - if the specified array is null.</dd>