学习数组复制的过程中，代码如下：
package test;
import java.util.*;
public class SelfStudy_Array {
public static void main(String[] args) {
int []a={1,222,56,4,33}; //define the array with 5 elements static  
int []b = a; //copy the array a to b
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));

Arrays.sort(a);
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));
}
}
实际运行结果
[1, 222, 56, 4, 33]
[1, 222, 56, 4, 33]

[1, 4, 33, 56, 222]
[1, 4, 33, 56, 222]

请问为何下划线处的数组b不是保留先前的内容，而是随着数组a的排序调整而变化。
如果需要保持数组b的内容不变，这段代码应该怎样调整？

作为新手，我的理解是：a b都指向同一个数组，实质上的a并没有copy到b中，只是b指向了a。想要copy的话，去java.lang.System 里面有个arraycopy()静态方法
欢迎高手来指点错误
  

楼主你好，你上边的那个是把a的地址给了b也就是b是a的一个引用，你到后边修改了a里边值的顺序那b自然也跟着改了啊！
下边有图示可以帮助你更好的理解



如果你想保持b中元素不变的话你可以使用动态初始化的方式把a中的元素copy到b中
int [] b=new int[a.legth];
for（int i=0；i<a。ength；i++）{
   b=a
}
这样你的b中的元素就会保持不变了

1. package test;
   
2. 
   
3. import java.util.*;
   
4. 
   
5. public class SelfStudy_Array {
   
6.         public static void main(String[] args) {
   
7. 
   
8.                 int []a={1,222,56,4,33};
   
9.                 int []b = a;
   
10.                
    
11.                 System.out.println(Arrays.toString(a));
    
12.                 System.out.println(Arrays.toString(b));
    
13. 
    
14.                 b = Arrays.copyOfRange(a, 0, a.length);
    
15.                
    
16.                 Arrays.sort(a);
    
17.                 System.out.println(Arrays.toString(a));
    
18.                 System.out.println(Arrays.toString(b));
    
19.         }
    
20. }

复制代码

首先明确，在堆内存中只有一个int数组。开始a指向数组的初始地址，然后把b引用也指向同样一个地址。对数组a进行排序，自然b的顺序也随之发生了变化。
要想b不随着a顺序的变化而变化，就只能让b不和a指向同一个数组了，可以用Object.clone方法，将a数组复制一份给b数组。修改后的代码如下：
import java.lang.reflect.Array;
import java.util.*;
public class SelfStudy_Array {
public static void main(String[] args) {
int []a={1,222,56,4,33}; //define the array with 5 elements static  
int []b = a.clone();

System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));
Arrays.sort(a);
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));
}
}

运行结果：
[1, 222, 56, 4, 33]
[1, 222, 56, 4, 33]
[1, 4, 33, 56, 222]
[1, 222, 56, 4, 33]

这个问题很简单...
package test;
import java.util.*;
public class SelfStudy_Array {
public static void main(String[] args) {
int []a={1,222,56,4,33}; //define the array with 5 elements static  
int []b = a; //copy the array a to b
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));

Arrays.sort(a);
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));
}
}
int []a={1,222,56,4,33};
int []b = a;//这个b只是个引用，把对象int[]的a引用赋值给了b引用了..
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));//这两句其实都是输出的int[]的引用的值..这下明白了吧，
所以保持数组b的内容不变就不成立了..

//因为数组是一个对象
//
//这样的话a和b访问的是内存中的同一段数据,
//所以修改一个,另一个也跟着改变了
//想要不改变的话应该这样复制
//int[] a = new int[10];
//int[] b = new int[10];
//for(int k=0;k<a.length;k++){
//a[k]=b[k];
//}
//每次new都会在内存中开辟一个新的空间,
//这样两个数组所访问的就不是同一地址了
//两个数组就可以独立操作了