javaclone數組

『壹』 java怎樣把一個字元串數組的元素附給另一個字元串數組

數組的復制方法現在至少有四個思路：
1 使用循環結構 這種方法最靈活。唯一不足的地方可能就是代碼較多
2 使用Object類的clone（）方法， 這種方法最簡單，得到原數組的一個副本。靈活形也最差。效率最差，尤其是在數組元素很大或者復制對象數組時。
3 使用Systems的array這種方法被告之速度最快，並且靈活性也較好，可以指定原數組名稱、以及元素的開始位置、復制的元素的個數，目標數組名稱、目標數組的位置。
4 Arrarys類的Of（）方法與OfRange（）方法可實現對數組的復制

另外我建議你去網路下「java數組的復制拷貝」，數組是可以復制的哦！

『貳』 JAVA中復制數組的方法是什麼求詳解並舉例子！光舉例子不給

在JAVA中可以使用array()方法來復制數組。其格式如下：

System.arraycoppy(sArray,intsrcPos,dArray,intdestPos,intlength)

該方法將指定的源數組sArray中的length個元素復制到目標數組dArray中，復制從原數組sArray的指定位置srcPos開始，把原數組中的元素復制到目標數組中，目標數組的位置從destPos位置處開始向後。

復制數組舉例：

publicclassLi{

publicstaticvoidmain(Stringargs[]){

intk,a1[]={5,4,3,2,1};

inta2[],a3[];

a2=a1;

a3=newint[7];

for(k=0;k<a1.length;k++)

System.out.print("a1["+k+"]="+a1[k]+" ");

System.out.println();

for(k=0;k<a2.length;k++){

a2[k]+=2;

System.out.print("a2["+k+"]="+a2[k]+" ");

}

System.out.println();

System.array(a2,2,a3,1,3);//從a2數組第2個元素開始復制3個元素

for(k=0;k<a3.length;k++)

System.out.print("a3["+k+"]="+a3[k]+" ");

System.out.println();

}

}

運行結果：

夠詳細了吧

『叄』 java如何來交換兩個數組元素的值

首先兩個數組的長度要一樣交換才有意義，循環遍歷數組
int temp; //數組是什麼類型temp就定義什麼類型
for(int i=0; i<ary1.length; i++){
temp = ary1[i];

ary1[i] = ary2[i];
ary2[i] = temp;
}

『肆』 java如何在函數中調用主函數的數組

import java.util.Scanner;

interface getGrade{
public void finGrade();
}

class First implements getGrade{

int a[];

public First(){}

public First(int grade[]){

a=grade.clone();

}

public void finGrade(){
int sum;
for (int i=0;i<=4;i++)
{
sum=sum+a[i];
}
int num;
num=sum/5;
System.out.println("平均成績為:"+num);
}
};

class Second implements getGrade{

int a[];

public Second(){}

public Second(int grade[]){

a=grade.clone();

}

public void finGrade(){
int j,k,t;
for (j=1;j<5;j++)
for (k=0;k<5-j;k++)
if (a[k]>a[k+1])
{
t=a[k];
a[k]=a[k+1];
a[k+1]=t;
}

a[0]=0;
a[4]=0;
int sun;
for (int i=0;i<=4;i++)
{
sun=sun+a[i];
}

int nun;
nun=sun/3;
System.out.println("平均成績為:"+nun);
System.out.println("(去掉一個最高分和一個最低分)");
}
};

public class exer4 {
public static void main (String args[]){
System.out.println("請依次輸入評委所給的分數");
System.out.println("(默認為五個評委)");
int a[] = new int [5];
Scanner reader = new Scanner(System.in);
int x = reader.nextInt();
int i;
for (i=0;i<=4;i++)
a[i]=x;

First fir=new First(a);
Second sec=new Second(a);
fir.finGrade();
sec.finGrade();
}
}

樓上設置全局變數是個方法，這樣進行參數傳遞也是一種方法。

『伍』 java怎麼定義一個數組中包含其他數組的數組

int[]a,b,c;//聲明一維數組
a=newint[5];//創建a
b=newint[]{1,2,3};//帶值列表創建b
c=a.clone();//從a克隆副本為c

int[][]ma;//聲明包含一維數組的數組
ma=newint[3][];//ma包含3個一維數組
ma[0]=a;//0號存a
ma[1]=b;//1號存b
ma[2]=c;//2號存c

System.out.println(Arrays.toString(ma[1]));//ma[1]是一維數組

輸出結果[1, 2, 3]

『陸』 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對象