Java——数组的拷贝

1.for循环拷贝：

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

这是基本数据类型，如果修改b[i]的值，则a[i]的值不会发生变化，所以称之为深拷贝；

	class TestArray{
    private int val=10;
    public void setVal(int val){
        this.val=val;
    }
    public int getVal(){
        return this.val;
    }
}
		 TestArray[] t1=new TestArray[4];
        t1[0]=new TestArray();
        t1[1]=new TestArray();
        t1[2]=new TestArray();
        t1[3]=new TestArray();
        TestArray[] t2=new TestArray[4];
        for(int i=0;i<t1.length;i++) {
            t2[i]=t1[i];
        }

而引用数据类型时，改变t2[i]的值，则t1[i]的值也会发生改变，即为浅拷贝；
总的来说，for循环的拷贝是 浅拷贝

2. Object.clone（）拷贝：

		int[] array={1,2,3,4,5};
        int[] brray=array.clone();

class TestArray{
    private int val=10;
    public void setVal(int val){
        this.val=val;
    }
    public int getVal(){
        return this.val;
    }
}
    public static void main4(String[] args) {
        TestArray[] t1=new TestArray[4];
        t1[0]=new TestArray();
        t1[1]=new TestArray();
        t1[2]=new TestArray();
        t1[3]=new TestArray();
        TestArray[] t2=t1.clone();
        }

array.clone()，会产生一个新的数组，然后将array数组的值复制到新数组中去；
简单数据类型是深拷贝；
引用数据类型是浅拷贝，
总的来说是浅拷贝；

3. Arrays.copyOf()拷贝：

		int[] array={1,2,3,4,5};
        int[] brray=Arrays.copyOf(array,array.length);

class TestArray{
    private int val=10;
    public void setVal(int val){
        this.val=val;
    }
    public int getVal(){
        return this.val;
    }
}
 public static void main(String[] args) {
        TestArray[] t1=new TestArray[4];
        t1[0]=new TestArray();
        t1[1]=new TestArray();
        t1[2]=new TestArray();
        t1[3]=new TestArray();
        TestArray[] t2=Arrays.copyOf(t1,t1.length);
        }

同样的，Arrays.copyOf()会产生一个新数组，然后将Array数组的值复制到新数组中去，与array.clone不同的是，Arrays.copyOf()第二个参数，是定义要拷贝的长度；
简单数据类型是深拷贝；
引用数据类型是浅拷贝，
总的来说是浅拷贝；
### 4. System.arraycopy()拷贝：

        int[] array={1,2,3,4,5};
        int[] brray=new int[array.length];
        System.arraycopy(array,0,brray,0,array.length);

class TestArray{
    private int val=10;
    public void setVal(int val){
        this.val=val;
    }
    public int getVal(){
        return this.val;
    }
}
public static void main6(String[] args) {
        TestArray[] t1=new TestArray[4];
        t1[0]=new TestArray();
        t1[1]=new TestArray();
        t1[2]=new TestArray();
        t1[3]=new TestArray();
        TestArray[] t2=new TestArray[4];
        System.arraycopy(t1,0,t2,0,t1.length);
        }

System.arraycopy() 里面有四个参数：
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量
System.arrayCopy 只复制已有的数组，
简单数据类型是深拷贝；
引用数据类型是浅拷贝，
总的来说是浅拷贝。

练习题

2.2 如何排序数组并插入某个元素？

 public static void insert(int[] array,int key) {
        Arrays.sort(array);
        int index=0;
        for(int i=0;i<array.length;i++){
            if(key<array[i]){
                index=i;
                break;
            }
        }
       int[] brray=Arrays.copyOf(array,array.length+1);
        for(int j=brray.length-1;j>=index;j--){
            brray[j]=brray[j-1];
        }
        brray[index]=key;
        System.out.println(Arrays.toString(brray));
    }

2.5如何搜索数组中的最小值和最大元素？

 public static int[] maxMin(int[] array) {
        int min = array[0];
        int max = array[0];
        int[] brray = {0,0};
        for(int i = 0;i < array.length;i++) {
            if(array[i] > max) {
                max = array[i];
            } else if(array[i] < min) {
                min = array[i];
            }
        }
        brray[0] = min;
        brray[1] = max;
        return brray;
    }

2.6如何合并两个数组（合并到一个新的数组）？

public static void merge(int[] array,int[] brray) {
        int[] crray=new int[array.length+brray.length];
        System.arraycopy(array,0,crray,0,array.length);
        System.arraycopy(brray,0,crray,array.length,brray.length);
        System.out.println(Arrays.toString(crray));
    }

2.10：如何删除数组指定元素？

public static void delect(int[] array,int key) {
       Arrays.sort(array);
       int x= Arrays.binarySearch(array,key);
       int[] brray=Arrays.copyOf(array,array.length-1);
       for(int i=x;i<array.length-1;i++){
           brray[i]=array[i+1];
       }
       System.out.println(Arrays.toString(array));
    }

2.11： 如何从数组中查找常见的元素？

       int[] array={3,4,2,8,7,5};
       Arrays.sort(array);
       int x= Arrays.binarySearch(array,8);
       System.out.println(x);

1.将奇数放在偶数前面 大小顺序不要求

public static void paixu(int[] array){
        int i=0;
        int j=array.length-1;
        while(i<j){

            while(i<j&&array[i]%2!=0){
                i++;
            }
            while(i<j&&array[j]%2==0) {
                j--;
            }
            int tmp=array[i];
            array[i]=array[j];
            array[j]=tmp;
            continue;
        }
        System.out.println(Arrays.toString(array));

2.一个数组是有序的，给定一个key:数字 有两个数字的和加起来等于key找到这两个数字的下标。

 public static  void add(int[] array,int key){
     for(int i=0;i<array.length;i++){
         for(int j=i;j<array.length;j++){
             if(key==array[i]+array[j]) {
                 System.out.println(i);
                 System.out.println(j);
                 break;
             }
         }
         break;
     }
    }

3. 一个整形数组，除了两个数字只出现一次外，其他数字都是两次。

  public static int[] findNumberApperOnce(int[] array) {
        int a=0;
        for(int i=0;i<array.length;i++) {
            a=a^array[i];
        }
        int index=weishu(a);
        int n1=0;
        int n2=0;
        for(int i=0;i<array.length;i++) {
            if (isOne(array[i], index)) {
                n1=n1^array[i];
            }else{
                n2=n2^array[i];
            }
        }
        int[] brray={0,0};
        brray[0]=n1;
        brray[1]=n2;
        return brray;
    }
 public static int weishu(int  number) {
        int count=0;
        while((number&1)==0&&count<32){
            number=number>>>1;
            count++;
        }
        return count;
    }
public static boolean isOne(int number,int index) {
        number=number>>index;
        if((number&1)==0){
            return false;
       }
       return true;
    }