java二維數組復制

㈠ java中如何將一維數組的內容復制到二維數組

比如二維數組
a[8][5]
,你可以看成
8個
a[5]
組成。
從a[0]-a[4]一圈結束後，在高位+1，就成了
a[1][5]，以此類推，8輪就是a[8][5]
就是輪次的序號用一個一維數組表示了，每個元素都是一個a[5]
（另一個一維數組）

㈡ 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中深度一個二維數組是什麼意思怎麼用代碼實現

從設計模式的角度來講的話，普通的淺就是object裡面帶的clone方法，一個對象a的時候，只是生成了一個新的同類型的對象b，他們兩個是同類型，但是不是指向一塊內存空間，是兩個不同的對象，形成了所謂的，但是如果這個的對象a裡面還引用到了其它的一個object對象c，那麼這個時候，克隆和被克隆的兩個對象a，b雖然不一樣，但是他們裡面引用到的那個object是一個對象，都是c，這就沒有達到深度的效果，深度是不光把最外面的對象給成兩個不同的對象a，b，甚至把對象裡面引用到的對象c也給了一個出來，這樣，在得到的b裡面不再是c，而是和c同類型的d，這就叫深度，明白？ 如果你想實現深度的話，就自己重寫clone方法，或者自定義方法

㈣ 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高手：java定義二維數組問題

int a[][] = new int[3][2]; 表示定義一個三行二列的二維數組，但是a[0] = {1,6}; 是對一維數組進行賦值，而a是二維數組無法使用一維數組的賦值方法，所以程序會報錯。

該代碼的正確方法應該是：

int a[][] = new int[3][2];

a[0][0]=1;

a[0][1]=6;

(5)java二維數組復制擴展閱讀

java定義二維數組的方法：

1、動態初始化

數據類型 數組名 [ ][ ] = new 數據類型[m][n]

數據類型 [ ][ ] 數組名 = new 數據類型[m][n]

數據類型 [ ] 數組名 [ ] = new 數據類型[m][n]

舉例：int [ ][ ] arr=new int [5][3]; 也可以理解為「5行3例」

2、 靜態初始化

數據類型 [ ][ ] 數組名 = {{元素1,元素2....},{元素1,元素2....},{元素1,元素2....}.....};

舉例：int [ ][ ] arr={{22,15,32,20,18},{12,21,25,19,33},{14,58,34,24,66},}

㈥ java題目:聲明一個3*4的二維數組（整型）a[ ][ ]，從鍵盤輸入數據賦值 並拷貝給b[ ]

publicclassTest{
publicstaticvoidmain(String[]args){
inta[][]=newint[3][4];
Scannersc=newScanner(System.in);
System.out.println("請輸入數字，每輸完一個數字回車");
intsum=0;
for(inti=0;i<3;i++){
for(intj=0;j<4;j++){
a[i][j]=sc.nextInt();
if(i==0){
sum+=a[i][j];
}
}
}
System.out.println("第一列總和="+sum);
}
}

㈦ java二維數組的復制

package Test;

public class TestArray {
public static void main(String[] args) {
String[][] arrString = {{"1", "2", "3"}, {"4", "5"}, {"6"}, {"7", "8", "9", "10"}};
System.out.println("original array:");
String[][] To = new String[arrString.length][];
for (int i = 0; i < arrString.length; i++) {
String[] arrRow = new String[arrString[i].length];
for (int j = 0; j < arrString[i].length; j++) {
System.out.print(arrString[i][j] + " ");
arrRow[j] = arrString[i][j];
}
To[i] = arrRow;
System.out.println();
}
System.out.println(" result array:");
for (int i = 0; i < To.length; i++) {
for (int j = 0; j < To[i].length; j++) {
System.out.print(To[i][j] + " ");
}
System.out.println();
}
}
}

運行結果：
original array:
1 2 3
4 5
6
7 8 9 10
target array:
1 2 3
4 5
6
7 8 9 10

㈧ 請問java中深度一個二維數組是什麼意思怎麼用代碼實現

一個二維數組可以看成一個一維數組，每個元素存儲一個一維數組首地址的引用，這個沒問題吧！
也就是說對於a[][]，直接用b[][]=a,或者b[][]=a.clone() 都只是復制了一個引用(包括上面的array等方法)，無法保證數據獨立性，就是說a數組值改變會影響到b，反之亦然，這就是淺層復制。
如果二維數組存放類型為基本類型，則只需要b的每一行進行復制(Object.clone()可以保證對基本類型做深層復制api上有寫):
b[][]=a.clone();//先利用淺層復制分配新的引用存放地址
for(int i=0;i<a.length;i++){
b[i]=a[i].clone();//a[i]指向數組的內容為基本類型，可以深層復制生成新引用對象
}
如果二維數組表示的是引用類型，則要對每一個元素調用clone()，並且保證所表示的引用類型遵循clone()復寫原則。
b[][]=a.clone();//先利用淺層復制分配新的引用存放地址
for(int i=0;i<a.length;i++){
for(int j=0;j<a[0].length;j++){
b[i][j]=a[i][j].clone()//為每個元素進行深層復制
}
}

以上是規范寫法，實現方法有很多，但一定要記住，單純的對引用的COPY是沒有意義的，編程中要避免。

㈨ JAVA二維數組如何使用array

array
public static void array(Object src,
int srcPos,
Object dest,
int destPos,
int length)
src - 源數組。
srcPos - 源數組中的起始位置。
dest - 目標數組。
destPos - 目標數據中的起始位置。
length - 要復制的數組元素的數量。

只能復制一維數組

㈩ java中何用for循環將一個二維數組的值付給另外一個二維數組

import java.util.Arrays;

public class CopyTest{
public static void main(String[] args) {
int [][]values={{5,15},{25,35,45},{55,65}};
int [][]cloned=new int [values.length][];
for(int i=values.length;--i>=0;){
cloned[i]=new int[values[i].length];
System.array(values, 0, cloned, 0, values[i].length);
}
for(int i=cloned.length;--i>=0;){
System.out.println(Arrays.toString(cloned[i]));
}
}
}