本文目录一览:
- 1、Java中的数组拷贝
- 2、JAVA中复制数组的方法是什么?求详解并举例子!光举例子不给
- 3、Java里面关于数组拷贝的几种方式
- 4、Java 如何拷贝数组的数据
- 5、java二维数组怎么复制,,arraycopy方法行吗?麻烦给个例子。谢啦
Java中的数组拷贝
这就是从指定的源数组复制一个数组到目的数组,复制是从指定位置开始到目标数组指定位置结束,
也就是从你的第一个数组0 index开始复制长度为3复制到目标的0开始前3位
简单说System.arraycopy(a1,0,a2,0,3); a1是你的原数组就是要提供复制的,0是你的原数组的开始位数,
也就是a1的index,a2是目的数组,就是需要复制到的,0是a2的开始位数吗,也就是a2的index,3是复制的长度
JAVA中复制数组的方法是什么?求详解并举例子!光举例子不给
在JAVA中可以使用arraycopy()方法来复制数组。其格式如下:
System.arraycoppy(sArray,int srcPos,dArray,int destPos,int length)
该方法将指定的源数组sArray中的length个元素复制到目标数组dArray中,复制从原数组sArray的指定位置srcPos开始,把原数组中的元素复制到目标数组中,目标数组的位置从destPos位置处开始向后。
复制数组举例:
public class Li{
public static void main(String args[]){
int k,a1[]={5,4,3,2,1};
int a2[],a3[];
a2=a1;
a3=new int[7];
for(k=0;ka1.length;k++)
System.out.print("a1["+k+"]="+a1[k]+"\t");
System.out.println();
for(k=0;ka2.length;k++){
a2[k]+=2;
System.out.print("a2["+k+"]="+a2[k]+"\t");
}
System.out.println();
System.arraycopy(a2,2,a3,1,3);//从a2数组第2个元素开始复制3个元素
for(k=0;ka3.length;k++)
System.out.print("a3["+k+"]="+a3[k]+"\t");
System.out.println();
}
}
运行结果:
够详细了吧
Java里面关于数组拷贝的几种方式
最简单的一种就是直接挨个把原数组的值赋给新数组 不过一般都用System.arraycopy(原数组起始复制的标号,新数组接收复制的起始标号,赋值的长度) 这个方法
例如:public class llx { public static void main(String args[]) { int a[] = {1,2,3,4,5}; int b[] = new int[10];//搞一个10位置的新数组 System.arraycopy(a[0],b[0],a.length);//从a的第一个位置开始复制;从b的第一个位置开始接收;一共接收a的总长度(a.length);;;懂了吗?这样的话 b的前5个值就被传递了,但是后5个是初始值0。 }}
Java 如何拷贝数组的数据
使用 Arrays.copyOf() 方法可以拷贝数组,代码如下:
import java.util.Arrays;
public class App {
public static void main(String[] args) {
int[] arr1 = new int[] { 1, 2, 3, 4, 5 };
int[] arr2 = Arrays.copyOf(arr1, arr1.length);
System.out.println(Arrays.toString(arr1));
System.out.println(Arrays.toString(arr2));
}
}
运行结果:
java二维数组怎么复制,,arraycopy方法行吗?麻烦给个例子。谢啦
java的多维数组的copy:希望采纳
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.arraycopy(a,0,b,0,a.length); //通过arraycopy()函数拷贝数组
b[0][0] = 4; //改变数组b[0][0]的值
System.out.println("a[][]");
for(int i=0;i2;i++){
for(int j=0;j3;j++){
System.out.print(a[i][j]+" ");
}
System.out.println();
}
System.out.println("b[][]");
for(int i=0;i2;i++){
for(int j=0;j3;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.arraycopy(a,0,b,0,a.length); //通过arraycopy()函数拷贝数组
b[0] = 4; //改变数组b[0]的值
System.out.println("a[]:");
for(int i=0;i3;i++){
System.out.print(a[i] + " ");
}
System.out.println();
System.out.println("b[]:");
for(int i=0;i3;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 就是负责把数组的内容copy 过去的,因此 a 的内容 (2
个引用) 被copy 到b 中去了,因此你对b[0][0] 做修改,a 也会同样跟着变化.
在JAVA里面,可以用复制语句“A=B”给基本类型的数据传递值,但是如果A,B是两个同类型的数组,复制就相当于将一个数组变量的引用传递给另一个数组;如果一个数组发生改变,那么引用同一数组的变量也要发生改变。
JAVA中复制数组元素值的的方法指深拷贝
1 使用for循环,将数组的每个元素复制(需要将每个对象调用clone方法,才能实现真正的复制)
2 使用clone方法,得到数组的值,而不是引用
3 使用System.arraycopy方法
注意:
1.上面方法中arraycopy效率较高。
2. 以上所说的拷贝数组的方法,只是针对一维数组,对于多维数组,要在每一维用以上方法进行复制才能实现复制数组元素的值而不是引用。
3. clone 和 arraycopy对二维数组进行复制时,是浅拷贝, 即
Object[][] aa;
Object[][] bb = aa.clone();
//or bb=System.arraycopy(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.arraycopy
* 以上两种对基本类型和对象类型数据效果等同。
* 3。 使用FOR循环,将数组的每个元素复制。(注意调用clone方法)
*
*/
/*
* 当数组数据是基本类型时,
*/
// int[] array = new int[]{0,1,2,3,4};
// int[] copy = array.clone(); //1.拷贝数据
// System.out.println( copy.equals(array));
// System.out.println( copy == array );
// for (int i = 0; i copy.length; i++) {
// System.out.print( copy[i]+", " );
// copy[i]++; //2.改变新数组数据内容
// System.out.print( copy[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.arraycopy(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.arraycopy(aa, 0, bb, 0, aa.length);
// Object[][] bb = aa.clone();
//// Object[][] bb = new Object[3][3];
//// System.arraycopy(aa, 0, bb, 0, aa.length); //一维数组下的深拷贝,对于二维数组只是浅拷贝!!
/**
* 二维数组的深拷贝的实现方式!!! 转为一维数组拷贝。
*/
// for (int i = 0; i bb.length; i++) { //实现深拷贝的方法!!!!!!!!!!!!
// System.arraycopy(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对象