java數組拷貝

『壹』 java數組拷貝問題u!~!~!

public static void main(String[] args) {
int[] a = {1,2,3,4,5,6,7 ,8,9,10 };
int[] b=new int[10];
//將數組a中的所以元素拷貝到數組b中,列印b中元素
for(int i=0;i<a.length;i++){
b[i]=a[i];
System.out.println(b[i]);
}
//向a數組中的第八個位置，添加新的數據200.
int[] temp=new int[11];
for(int i=0,j=0;i<temp.length;i++,j++){
if(j==7){
temp[i]=200;
i++;
}
temp[i]=a[j];

}
a=temp;
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}
//把添加完新數據的數組中的第五個位置的數據刪除，並把就數組中的元素順序列印
for(int i=0;i<a.length-1;i++){
if(i>=4){
a[i]=a[i+1];
}
System.out.println(a[i]);
}
}

『貳』 java怎麼把數組復制

publicclassArraysCopy{
	publicstaticvoidmain(String[]args){
		int[]arr={1,2,3,4};
		int[]arr2=newint[arr.length];
		System.array(arr,0,arr2,0,arr2.length);
		System.out.println(java.util.Arrays.toString(arr2));
	}
}
參數：
src-源數組。
srcPos-源數組中的起始位置。
dest-目標數組。
destPos-目標數據中的起始位置。
length-要復制的數組元素的數量。

『叄』 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
* 以上兩種對基

『肆』 java復制數組數據到其他數組

不用這么麻煩吧。。。把原先的數據，循環拼接到新數組就行了吧

『伍』 java中數組復制的方法有幾種

最簡單的一種就是直接挨個把原數組的值賦給新數組 不過一般都用System.array(原數組起始復制的標號，新數組接收復制的起始標號，賦值的長度) 這個方法

例如：public class llx {
public static void main(String args[]) {
int a[] = {1,2,3,4,5};
int b[] = new int[10];//搞一個10位置的新數組
System.array(a[0],b[0],a.length);//從a的第一個位置開始復制；從b的第一個位置開始接收；一共接收a的總長度（a.length)；；；懂了嗎？這樣的話 b的前5個值就被傳遞了，但是後5個是初始值0。
}
}

補充：Java是一種可以撰寫跨平台應用軟體的面向對象的程序設計語言。Java 技術具有卓越的通用性、高效性、平台移植性和安全性，廣泛應用於PC、數據中心、游戲控制台、科學超級計算機、行動電話和互聯網，同時擁有全球最大的開發者專業社群。

『陸』 java 把一個數組的值拷貝到另一個數組 不準用拷貝方法

可以直接通過循環獲取一個數組的值，之後分別賦值給另外一個數組。

int [] old={1,2,3};

int newStr[]=new int[old.length];

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

newStr[i]=old[i];

}

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

System.out.println(newStr[i]);

}

執行結果：

『柒』 Java 如何拷貝數組的數據

這就是從指定的源數組復制一個數組到目的數組，復制是從指定位置開始到目標數組指定位置結束，
也就是從你的第一個數組0
index開始復制長度為3復制到目標的0開始前3位
簡單說system.array(a1,0,a2,0,3);
a1是你的原數組就是要提供復制的，0是你的原數組的開始位數，
也就是a1的index，a2是目的數組，就是需要復制到的，0是a2的開始位數嗎，也就是a2的index，3是復制的長度

『捌』 Java中數組復制的幾種方法

最簡單的一種就是直接挨個把原數組的值賦給新數組 不過一般都用System.array(原數組起始復制的標號，新數組接收復制的起始標號，賦值的長度) 這個方法
例如：public class llx { public static void main(String args[]) { int a[] = {1,2,3,4,5}; int b[] = new int[10];//搞一個10位置的新數組 System.array(a[0],b[0],a.length);//從a的第一個位置開始復制；從b的第一個位置開始接收；一共接收a的總長度（a.length)；；；懂了嗎？這樣的話 b的前5個值就被傳遞了，但是後5個是初始值0。 }}

『玖』 java中array怎麼使用

System.array拷貝數組，
array(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.array(res,0,res,0,3);
TextView TV= (TextView) findViewById(R.id.text);
StringBuffer SB=new StringBuffer();
for (int i=0;i<res.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.array(res,1,res,0,3);
TextView TV= (TextView) findViewById(R.id.text);
StringBuffer SB=new StringBuffer();
for (int i=0;i<res.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.array(res,1,des,0,3);
TextView TV= (TextView) findViewById(R.id.text);
StringBuffer SB=new StringBuffer();
for (int i=0;i<des.length;i++){
SB.append(des[i]);
}
TV.setText(SB.toString());
//System.out.print(des.toString());
}
}

列印結果是234910.
好明顯的道理就是我們是為了得到目標數組，原數組只起被復制的功能，我們列印一萬遍源數組還是不變的。但是我們要考慮的是，我們復制的長度再加上目標數組的起始位置不能大於目標數組的長度，
System.array(res,1,des,4,3);1

我們不能從目標數組第四位加起，還截取3，那麼就.:數組下標越界了。
所以要慎重。