java数组复制,java数组复制哪种最快

本文目录一览：

• 1、java中arraycopy怎么使用
• 2、java复制数组数据到其他数组
• 3、java二维数组怎么复制，，arraycopy方法行吗？麻烦给个例子。谢啦
• 4、Java 如何拷贝数组的数据
• 5、Java怎样把一个字符串数组的元素附给另一个字符串数组
• 6、java怎么把数组复制

java中arraycopy怎么使用

System.arraycopy拷贝数组，

arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。从 src 引用的源数组到

dest 引用的目标数组，数组组件的一个子序列被复制下来。被复制的组件的编号等于 length

参数。源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的

destPos 到 destPos+length-1 位置。

int[] res=new int[]{1,2,3,4,5};

int[] des=new int[]{6,7,8,9,10};

System.arraycopy(res,0,res,0,3);

TextView TV= (TextView) findViewById(R.id.text);

StringBuffer SB=new StringBuffer();

for (int i=0;ires.length;i++){

SB.append(res[i]);

}

TV.setText(SB.toString());123456789

打印结果12345；

如果参数 src 和 dest 引用相同的数组对象，则复制的执行过程就好像首先将

srcPos 到 srcPos+length-1 位置的组件复制到一个带有

length 组件的临时数组，然后再将此临时数组的内容复制到目标数组的 destPos 到

destPos+length-1 位置一样。

int[] res=new int[]{1,2,3,4,5};

int[] des=new int[]{6,7,8,9,10};

System.arraycopy(res,1,res,0,3);

TextView TV= (TextView) findViewById(R.id.text);

StringBuffer SB=new StringBuffer();

for (int i=0;ires.length;i++){

SB.append(res[i]);

}

TV.setText(SB.toString());123456789

假如这样的话就是23445.。。。

public class MainActivity extends AppCompatActivity {

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

int[] res=new int[]{1,2,3,4,5};

int[] des=new int[]{6,7,8,9,10};

System.arraycopy(res,1,des,0,3);

TextView TV= (TextView) findViewById(R.id.text);

StringBuffer SB=new StringBuffer();

for (int i=0;ides.length;i++){

SB.append(des[i]);

}

TV.setText(SB.toString());

//System.out.print(des.toString());

}

}

打印结果是234910.

好明显的道理就是我们是为了得到目标数组，原数组只起被复制的功能，我们打印一万遍源数组还是不变的。但是我们要考虑的是，我们复制的长度再加上目标数组的起始位置不能大于目标数组的长度，

System.arraycopy(res,1,des,4,3);1

我们不能从目标数组第四位加起，还截取3，那么就.ArrayIndexOutOfBoundsException:数组下标越界了。

所以要慎重。

java复制数组数据到其他数组

不用这么麻烦吧。。。把原先的数据，循环拼接到新数组就行了吧

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对象

Java 如何拷贝数组的数据

这就是从指定的源数组复制一个数组到目的数组，复制是从指定位置开始到目标数组指定位置结束，

也就是从你的第一个数组0

index开始复制长度为3复制到目标的0开始前3位

简单说system.arraycopy(a1,0,a2,0,3);

a1是你的原数组就是要提供复制的，0是你的原数组的开始位数，

也就是a1的index，a2是目的数组，就是需要复制到的，0是a2的开始位数吗，也就是a2的index，3是复制的长度

Java怎样把一个字符串数组的元素附给另一个字符串数组

数组的复制方法现在至少有四个思路：

1 使用循环结构 这种方法最灵活。唯一不足的地方可能就是代码较多

2 使用Object类的clone（）方法， 这种方法最简单，得到原数组的一个副本。灵活形也最差。效率最差，尤其是在数组元素很大或者复制对象数组时。

3 使用Systems的arraycopy这种方法被告之速度最快，并且灵活性也较好，可以指定原数组名称、以及元素的开始位置、复制的元素的个数，目标数组名称、目标数组的位置。

4 Arrarys类的copyOf（）方法与copyOfRange（）方法可实现对数组的复制

另外我建议你去百度下“java数组的复制拷贝”，数组是可以复制的哦！

java怎么把数组复制

public class ArraysCopy{

public static void main(String[] args){

int[] arr = {1,2,3,4};

int[] arr2 = new int[arr.length];

System.arraycopy(arr,0,arr2,0,arr2.length);

System.out.println(java.util.Arrays.toString(arr2));

}

}

参数：

src – 源数组。

srcPos – 源数组中的起始位置。

dest – 目标数组。

destPos – 目标数据中的起始位置。

length – 要复制的数组元素的数量。