数组的拷贝方式

一，关于交换两个数字

1.简单交换

public static void swap(int a,int b) {
        int tmp=a;
        a = b;
        b = tmp;
    }

运行结果如下：

可知，此方法并不可行，因为形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。
2.引用交换

    public static void swap2(TestSwap a,TestSwap b) {
        int tmp = a.date;
        a.data = b.data;
        b.data = tmp;
    }

运行结果如下：

可知，此方法可行，因为形参为引用值，引用的 是存放数据的地址，而在交换方法里，真正交换的是值。

二，数组

数组是用一个标识符（变量名）和一组下标来代表一组具有相同数据类型的数据元素的集合。这些数据元素在计算机存储器中占用一片连续的存储空间，其中的每个数组元素在数组中的位置是固定的，可以通过下标的编号加以区分，并通过标识符和下标访问每一个数据元素。
数组提供了在计算机存储器中快速且简便的数据存取方式，数组的应用可以大大提高对数据操作的灵活性。
在Java中，数组被定义为一个对象，属于引用类型。
数组的三种定义方法：

 1.数组类型[] 数组名=new 数组类型[数组长度];   
 2.数组类型[] 数组名={数组0,数组1,数组2,数组3,....};   
 3.数组类型[] 数组名=new 数组类型[]{数组0,数组1,数组2,...};  

例如：

int[] array = new int[10];//数组每个元素被初始化为0
int[] array2 = {1,2,3,4,5,6,7,8,9};
int[] array3 = new int[]{1,2,3,4,5};

数组的遍历

    public static void show(int[] array){
        for(int i=0;i<array.length;i++)
        {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

foreach循环的语句
格式：

for(数据类型 变量名:对象)
{
//循环体为引用了变量的Java语句
}

例如：数组的遍历

for(int j:array)
        {
        System.out.println(j);  
        }

注：
1.其中变量名可以是任意的但是数据类型必须与遍历对象的数据类型相同。
2.对象为一个容器，例如数组或是集合等
3.无法再循环中改变对象中的值，即任何在循环体中改变对象中的值都是无效的，对象中的值不会被改变。这也是foreach循环较for循环的重要区别，foreach实现对象的遍历代码更加简洁，for循环可以改变对象中的值。

        int []c={1,2,3,4,5};  
        for(int i:c)  
        {  
            if(i==3||i==5)  
                i=i*5;  
        }  
        for(int j:c)  
        {  
            System.out.println(j);  
        } 

foreach循环无法改变对象中的值。
数组的4种拷贝方式
1.for循环拷贝
（1）对于基本类型来说，如果改变了array2的值，array的值并不改变，此拷贝为深拷贝。

    int [] array = {1,2,3,4,5};
    int [] array2 = new int[array.length];
    for (int i = 0; i < array2.length; i++) {
    array2[i] = array[i];
    }

（2）对于引用类型来说，如果改变t2的值，t1的值也会发生改变，他只拷贝了地址，此拷贝为浅拷贝。

class TestArray{
    private int val = 10;
    public int getVal(){           //得到val值
        return val;
    }
    public void setVal(int val){   //设置val值
        this.val = val;
    }

}

public class Test{
    public static void show(int[] array) {
        for(int i=0;i<array.length;i++)
        {
            System.out.println(array[i]+" ");
        }
        System.out.println();
    }

    public static void show2(TestArray[] array) {
        for(int i=0;i<array.length;i++)
        {
            System.out.println(array[i].getVal());
        }
        System.out.println();
    }

    public static void main(String[] args) {
        TestArray[] t1 = new TestArray[3];      //对于引用类型数组用for循环拷贝为浅拷贝
        t1[0] = new TestArray();
        t1[1] = new TestArray();
        t1[2] = new TestArray();

        TestArray[] t2 = new TestArray[3];
        for(int i=0;i<t1.length;i++)
        {   
            t2[i] = t1[i];
        }
        show2(t1);
        System.out.println("------");
        show2(t2);
        System.out.println("---改变后---");
        t2[0].setVal(1000);
        show2(t1);
        System.out.println("--------");
        show2(t2);
    }

    public static void main1(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] array2 = new int[array.length];

        for(int i = 0;i<array.length;i++)
        {
            array2[i] = array[i];
        }

        show(array);
        System.out.println("---------");
        show(array2);
        array2[0]=100;
        System.out.println("----改变后-----");
        show(array);
        System.out.println("---------");
        show(array2);
    }

}

2.clone拷贝
（1）对于基本类型来说，如果改变了array2的值，array的值并不改变，此拷贝为深拷贝。

    public static void show(int[] array){
        for(int i = 0;i < array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] array2 = new int[array.length];
        System.out.println(array);
        System.out.println(array2);
        array2 = array.clone();
        show(array);
        System.out.println("========");
        show(array2);
        array2[0] = 1000;
        System.out.println("===改变后的值===");
        show(array);
        System.out.println("========");
        show(array2);
    }

（2）对于引用类型来说，如果改变t2的值，t1的值也会发生改变，他只拷贝了地址，此拷贝为浅拷贝。

public static void show2(TestArray2[] array) {
        for(int i=0;i<array.length;i++)
        {
            System.out.println(array[i].getVal());
        }
        System.out.println();
    }
    public static void main(String[] args) {
        TestArray2[] t1 = new TestArray2[3];   
        t1[0] = new TestArray2();
        t1[1] = new TestArray2();
        t1[2] = new TestArray2();

        TestArray2[] t2 = new TestArray2[3];
        t2 = t1.clone();
        show2(t1);
        System.out.println("========");
        show2(t2);

        t2[0].setVal(100);
        System.out.println("====改变后=====");
        show2(t1);
        System.out.println("=========");
        show2(t2);
    }

3.System.arraycopy
System.arraycopy 相对较快的拷贝方式 native 方法
System.arraycopy 的使用：
arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
src : 源数组
srcPos: 源数组的开始位置 0 开始拷贝的位置
dest： 拷贝到目标数组
destPos ：拷贝到目标数组的位置 0 1 2
length ： 源数组 考多大 2 3 4

（1）对于基本类型来说，此拷贝为深拷贝。

    public static void show(int[] array){
        for(int i = 0;i < array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] array2 = new int[array.length];
        System.arraycopy(array, 0, array2, 0, array.length);
        show(array);
        System.out.println("========");
        show(array2);
        array2[0] = 1000;
        System.out.println("===改变后的值===");
        show(array);
        System.out.println("========");
        show(array2);

    }    

（2）对于引用类型来说，此拷贝为浅拷贝。

class TestArray3{
    private int val = 10;

    public int getVal(){//得到val值等于多少
        return val;
    }
    public void setVal(int val){//设置当前的val值
        this.val = val;
    }
}
public class Test{
    public static void show2(TestArray3[] array){
        for(int i = 0;i < array.length;i++){

            System.out.println(array[i].getVal());
        }
    }

    public static void main(String[] args) {
        TestArray3[] t1 = new TestArray3[3];//引用类型
        t1[0] = new TestArray3();
        t1[1] = new TestArray3();
        t1[2] = new TestArray3();
        TestArray3[] t2 = new TestArray3[3];
        System.arraycopy(t1,0,t2,0,t1.length);
        show2(t1);
        System.out.println("========");
        show2(t2);
        t2[0].setVal(10000);
        System.out.println("====改变值=====");
        show2(t1);
        System.out.println("======");
        show2(t2);
    }
}

4.Arrays.copyOf()
Arrays.copyOf();//Arrays 工具类 数组 包含很多方法
T[] original, int newLength
原始 数组 新的数组长度
（1）对于基本类型来说，此拷贝为深拷贝。

import java.util.Arrays;
public class Test {
    public static void show(int[] array){
        for(int i = 0;i < array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int[] array2 = new int[array.length];
        array2 = Arrays.copyOf(array, array.length);
        show(array);
        System.out.println("========");
        show(array2);
        array2[0] = 1000;
        System.out.println("===改变后的值===");
        show(array);
        System.out.println("========");
        show(array2);
    }
}

（2）对于引用类型来说，此拷贝为浅拷贝。

import java.util.Arrays;
class TestArray4{
    private int val = 10;

    public int getVal(){//得到val值等于多少？
        return val;
    }
    public void setVal(int val){//设置当前的val值？？？
        this.val = val;
    }
}
public class Test {
public static void show2(TestArray4[] array){
        for(int i = 0;i < array.length;i++){

            System.out.println(array[i].getVal());
        }
    }
    public static void main(String[] args) {
        TestArray4[] t1 = new TestArray4[3];//引用类型
        t1[0] = new TestArray4();
        t1[1] = new TestArray4();
        t1[2] = new TestArray4();

        TestArray4[] t2 = new TestArray4[3];

        t2 = Arrays.copyOf(t1, t1.length);

        show2(t1);
        System.out.println("========");
        show2(t2);

        t2[0].setVal(10000);
        System.out.println("====改变值=====");
        show2(t1);
        System.out.println("======");
        show2(t2);
    }
}

冒泡排序法

import java.util.Arrays;
public class Test{

    public static void bubbleSort(int[] array){
        System.out.println(System.currentTimeMillis());
        int tmp = 0;
        for(int i = 0;i < array.length-1;i++){//趟数 

            for(int j = 0;j < array.length-1-i;j++){

                if(array[j] > array[j+1]){
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }

            }
        }
        System.out.println(System.currentTimeMillis());
    }
public static void main(String[] args) {
        int[] array = {12,43,2,1,54,76};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}