java基础篇之5-------一维数组的拷贝

作业：
1、{1,2,3,4,5,6}
将奇数放在偶数前面 大小顺序不要求

    public static int[] sortArray(int[] a) {
        int odd = 0;// 奇数下标
        int even = 0;// 偶数下标
        int evenNum = 0;// 偶数个数
        for (int i = 0; i < a.length; i++) {
            if (a[i] % 2 == 0) {
                even = i; // 保存第一个偶数的下标
                evenNum++;// 个数加1
            } else {
            }
            int temp = a[i];
            a[i] = a[even - evenNum + 1];
            a[even - evenNum + 1] = temp;
            even = i;
        }
        System.out.println(Arrays.toString(a));
        return a;
    }

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

 public static void searchIndex(int a[], int sum) {
        int i = 0, j = 1;
        for (i = 0; i < a.length; i++) {
            for (j = i + 1; j < a.length; j++) {
                if (a[i] + a[j] == sum) {
                    System.out.println(i + "***********" + j);
                }
            }
        }
    }

3： 题目：一个整形数组，除了两个数字只出现一次外， 其他数字都是两次。{1,3,1,2,3,4} 找到这两个数字

步骤：1： 将数组中的所有数字进行异或， ： 因为其他数字都是出现两次，根据异或规律，得到的
 *                                           结果只能是两个只出现一次的数字的异或结果temp；
 *         2：对temp的二进制表示数进行判断，从右往左第几位是1；记作n；
 *         3：以n为判断依据，将所有数字按照二进制数字的第n位是不是1来分组，
 *         4： 将得到的两个分组分别异或，得到的两个数字就是结果；
import java.util.Arrays;

public class testDome4 {

    // 3: 判断传入的数字右移index位，然后和1相与，检测指定位是不是1；
    public static boolean idOne(int number, int index) {
        number >>= index;
        if ((number ^ 1) == 1) {
            return true;   // 如果是0 返回true；
        } else {
            return false;  // 如果是1，返回false；
        }
    }
    
    public static int indexOfOne(int number) {
        //2：判断所有数字异或的结果number二进制从右往左第几位是1；  
        int count = 0; // 设置一个计数器
        for (int i = 0; i <= 32; i++) {   //用循环依次与1异或  
            if ((number ^ 1) != 0 && count < 32) {    
                number >>= 1;//  如果结果是1，则把该数字向右移一位，
                count++; //  计数器+1；
            } else {
                break;  // 只需要找到第一个1就行，所以此处用的break
            }
        }
        return count;
    }

    public static int[] findNumApperOnce(int[] array) {
        // 1：将数组中的所有数字进行异或；
        int result = 0;
        for (int i = 0; i < array.length; i++) {
            result ^= array[i];    //将结果保存在result中，然后传给上面的方法进行判断1的位置
        }
        
        // 前三步工作做好之后，进行下面的操作
        int isOne = 0; //定义一个接收是1 的分组，让其相互异或，得到的结果就是第一个数；
        int isZore = 0; // 定义一个接收是0 的分组，让其相互异或，得到的结果就是第二个数； 
        for (int i = 0; i < array.length; i++) {
            if (idOne(array[i], indexOfOne(result))) {
                isZore ^= array[i];   // 得到第一个数字；
            } else {
                isOne ^= array[i];    // 得到第二个数字；
            }
        }
        int []resultArray=new int[2];   // 将结果保存在新定义的数组resultArray中！
        resultArray[0]=isZore;
        resultArray[1]=isOne;
        return  resultArray;
    }
    public  static void main(String [] args){
        int []array=new int[]{1,2,3,4,3,2,5,4};
        int []result=findNumApperOnce(array);
        System.out.println(Arrays.toString(result));
    }
}

4： 对array方法的操作：

 //往数组指定位置插入
    public static int[] inPut(int index, int[] array, int val) {
        int[] newArray = new int[array.length + 1];
        for (int i = 0; i < index; i++) {
            newArray[i] = array[i];
        }
        System.arraycopy(array, index, newArray, index + 1, array.length - index);
        newArray[index] = val;
        return newArray;

    }

    //  找最大数
    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;

    }

    //  找最小数
    public static int getMin(int[] arr) {
        int min = arr[0];
        for (int x = 1; x < arr.length; x++) {
            if (min > arr[x]) {
                min = arr[x];
            }
        }
        return min;

    }

    //合并数组
    public static void content(int a[], int b[]) {
        int[] c = Arrays.copyOf(a, a.length + b.length);
        System.arraycopy(b, 0, c, a.length, b.length);
        System.out.println(Arrays.toString(c));
    }
    //删除指定数组中数值

    public static void del(int[] a, int val) {

        for (int i = 0; i < a.length; i++) {
            if (a[i] == val) {
                System.arraycopy(a, i + 1, a, i, a.length - i - 1);
                a[a.length - 1] = 0;
            }
        }
        System.out.println(Arrays.toString(a));
    }

    // 从数组中查找常见的元素：
    public static int search(int[] a, int val) {
        for (int i = 0; i < a.length; i++) {
            if (a[i] == val) {
                return i;
            }
        }
        return -1;
    }

    // 填充数组
    public static void fill() {
        int a[] = new int[5];
        int b[] = new int[10];
        Arrays.fill(a, 500);// 将数组a全部填充为500；
        Arrays.fill(b, 2, 6, 20);//将数组b从下标第2个到第5个数部分填充为20 [2,6)
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(b));
    }


    //可变参数编程  ：实际上是数组
    public static void sum(int... array) {
        int sum = 0;
        for (int i : array) {
            sum += i;
        }
    }

1：数组克隆
（1）： for循环克隆：（浅拷贝）

int [] a=new int[]{1,2}
int [] b=new int[2];
for(int i=0;i<a.length;i++) {
	b[i]=a[i];
	}

( 2 ) ： clone();方法；（浅拷贝）
用法：

int [] a=new int[]{1,2}
int [] b=a.clone();                 //   直接调用clone()方法； 

（3）：System.arraycopy( Object src, int srcPos, Object dest, int destPos, int length)方法： （浅拷贝）
含义： src： 原数组；
srcPos： 原始数组拷贝起始位置；
dest：目标数组；
destPos：目标数组起始位置；
length： 拷贝长度；

		 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];            //t2[0]
     	  System.arraycopy(t1,0,t2,0,t1.length);  //  把 原始数组t1，从t1的0位置开始拷贝，目标数组t2，从t2的0位置开始，长度为t1数组的长度

（4） Arrays.copyof( ) 方法： （浅拷贝）
用法：

 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);            //    >>>>>> 第一个参数是被克隆的数组，第二个是长度；

四种拷贝方法区别：
for循环 ：利用循环依次拷贝
clone（） ， ： 本地方法，底层用c\c++ 代码实现，调用速度快，会返回object的对象；
System.arraycopy（）： 本地方法 ，使用c/c++实现，无返回值；
Arrays.copyof() ： 产生泛型数组，底层调用的还是arraycopy（）方法，产生新的对象;
引用类型数组拷贝堆栈分析：

2： 匿名数组：
使用：
System.out.println(new String[]{"a","b"}); // 》》》》》这里创建了一个匿名数组，并打印输出
1）、匿名数组是一个没有名字的数组
2）、匿名数组与普通的数组的语法是一样的，如：new [] { }，不同的是创建完数组后不会存储在任何一个变量身上。
3）、使用匿名数组的策略仅仅就是创建、初始化、应用，因为它没有任何名字因此你没法重用它。