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]));
}
}
}