Java数组，数组的拷贝方式及冒泡排序改进

数组是一种特殊类型的变量，可以只存储一个值，也可以存储多个值，当需要使用一组相互有关联的值时，就应当考虑使用数组。当不知道一个列表中要包含多少项数据时，数组尤其有用。这是因为在创建数组时，不需要指定它会包含多少个值。

数组的定义方式：
int []array={1,2,3,4,5,6,7,8,9};//定义方式
int [] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
int []array3=new int[10];
数组的输出方式：
1

int []array={1,2,3,4,5,6,7,8,9};
for(int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }//可以输出数组的某个值
for (int j : array) {
        System.out.println(j);
    }//只能把一个数组全部输出，不能输出单个值

2
输出基本类型的数组

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

3
输出引用类型的数组

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

数组的拷贝方式
1
直接拷贝
（1）

int []array={1,2,3,4,5};//定义方式
        int []array1;
        array1=array;

这种拷贝方式是将数组array的地址直接复制给array，倆者访问的是同一个地址，所以，当array发生改变时，array1随之改变

2.用for循环拷贝数组
（1）拷贝基本类型的数组

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(array2);
        System.out.println("==========");
        array2[0]=1000;

        System.out.println("改变值后");
        show(array);
        System.out.println("==========");
        show(array2);

运行结果

由上面的运行结果可以看出，for循环拷贝数组，对于基本类型的数组，是一种深拷贝，即改变目标数组的某一个值，其原数组对应的值不变。

（2）拷贝引用类型的数组

class TestArray{
    private int val=10;
    public int getval(){
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }
    TestArray[] t1=new TestArray[3];
     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];
     }
     t2[0].setVal(30);//浅拷贝，改变一个，另一个也改变

       show2(t2);
     System.out.println("=======");
     System.out.println("改变值后");
     show2(t2);
     System.out.println("=======");
     show2(t2);
   }

运行结果为

由上图可以看出，当用for循环拷贝引用类型的数组时，是一种浅拷贝，即当目标数组的一个值改变时，原数组对应的那个值也会发生改变。

3 clone拷贝

基本类型数组

int []array={1,2,3,4,5};//定义方式
        int []array2=new int[array.length];
        array2=array.clone();
        show(array2);
        System.out.println("==========");
        array2[0]=1000;

        System.out.println("改变值后");
        show(array);
        System.out.println("==========");
        show(array2);

clone方法对于基本类型的数组也是一种深拷贝

class TestArray2{
    private int val=10;
    public int getval(){
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }


}
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(t2);
         System.out.println("=======");
         t2[0].setVal(30);
         System.out.println("改变值后");
         show2(t2);
         System.out.println("=======");
         show2(t2);

运行结果

clone方法对于引用数组来说是一种浅拷贝。

4，System.arraycopy方法
方法源代码分析：

public static native void arraycopy(Object src,  int  srcPos,  
                                        Object dest, int destPos,  
                                        int length);  

各种变量代表的意义：
* src：原数组。
* srcPos原数组开始位置 开始拷贝的位置
* dest 拷贝到哪个目标数组
* destPos 拷贝到目标数组的哪个位置
* length 要从原数组里拷贝多长
用法示例

int []array={1,2,3,4,5};//定义方式
        int []array2=new int[array.length];
        System.arraycopy(array, 0, array2, 0, array.length);

代码表示把array数组里面的前五个值复制到array2数组。

5 Arrays.copyOf 方法。
方法源代码分析：

public static boolean[] copyOf(boolean[] original, int newLength) {
        boolean[] copy = new boolean[newLength];
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

original - 要复制的数组
newLength - 要复制原数组的长度

使用示例

int []array={1,2,3,4,5};//定义方式
        int []array2=new int[array.length];
        array2=Arrays.copyOf(array,5);

代码表示把array数组里面的前五个值复制到array2数组。

Arrays.copyOf 方法与System.arraycopy方法与前面俩种方式一样，对于基本类型的数组，它是一种深拷贝，对于引用类型的数组，他是一种浅拷贝。

冒泡排序

public static void PX(int []array){
        int tmp=0;

        for(int i=0;i<array.length;i++){
            for(int j=0;j<array.length-i-1;j++){
                if(array[j]>array[j+1])
                {tmp=array[j];
                array[j]=array[j+1];
                array[j+1]=tmp;

                }
                }
        }

    }

    public static void main(String[] args) {
        int []a={1,3,2,5,9,4};
        PX(a);
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
        System.out.println(Arrays.toString(a));
        // TODO Auto-generated method stub

    }

}

冒泡排序改进
若在其中的某一趟排序中,未发生元素的交换则说明元素一开始就已经排序好，则不需要进行排序,直接跳出函数,进行下一趟排序.

    public static void PX(int []array){
        int tmp=0;
        int t=0;//设置一个t，来控制是否进行排序
        for(int i=0;i<array.length;i++){
            for(int j=0;j<array.length-i-1;j++){
                if(array[j]>array[j+1])
                {tmp=array[j];
                array[j]=array[j+1];
                array[j+1]=tmp;
                t=1;//此时说明排序中发生了交换

                }

                }
            if(t== 0)//某次排序中未发生交换，说明已经有序，函数结束！  
                break;
        }




    }

    public static void main(String[] args) {
        int []a={1,3,2,5,9,4};
        PX(a);
        for(int i=0;i<a.length;i++){

        }
        System.out.println(Arrays.toString(a));
        // TODO Auto-generated method stub

    }

}