打印一个整型数组 * 2.2 将一个整型数组反序排列。 * 2.3 求一个整型数组元素中的最大值。 * 2.4 将一个整型数组每一个元素向前（向标号小的方向）移动一个位置，第一个元素移到最后一个位置。2.5 找出前n个质数，以数组的形式返回结果。 * 2.6 求一个整型数组各元素之和。

/**
 * 2.1 打印一个整型数组
 * 2.2 将一个整型数组反序排列。
 * 2.3 求一个整型数组元素中的最大值。
 * 2.4 将一个整型数组每一个元素向前（向标号小的方向）移动一个位置，第一个元素移到最后一个位置。
 * 2.5 找出前n个质数，以数组的形式返回结果。
 * 2.6 求一个整型数组各元素之和。
 * 2.7 编写一个方法，其功能是对一个整型数组升序排列（请采用冒泡算法）。
 * 2.8 用选择法对若干个数排序（由大到小）。
 * 2.9 用插入法对若干个数排序（由小到大）。
 * 2.10    用折半查找法在一组排好序(递增有序或递减有序)的值中查找某个数据。
 * 2.11    求一个整型数组元素中最接近其平均值的整数。
 * 2.12    实现一个数组复制方法，参数为:源数组、起始下标、复制长度，返回值为新数组
 */
public class TestArray {
    public static void main(String[] args) {
        int[] sum={126,64,123,6,15,84,1,31,16,63,999};
    //    prt(sum);
    //    add(sum);
    //    move(sum);
    //    age(sum);
    //    arrayCopy(sum,0,3);
    //    antitone(sum);
        Insertsort(sum);
        Selectsort(sum);
    }
    //打印一个整型数组
    public static int[] prt(int[] arr) {
        for (int i : arr) {
            System.out.println(i);
        }
        return arr;
    }
    //将一个整型数组反序排列。
    public static int[] antitone(int[] arr) {
            if (arr == null || arr.length == 0) {
                System.out.println("输入的数组不合法！");
            }
            for (int i = arr.length - 1; i >= 0; i--) {
                System.out.print(arr[i] + " ");
            }
            System.out.println();
        return arr;
    }
    //求一个整型数组元素中的最大值。
    public static int max(int[] arr){
        int max=arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max =arr[i];

            }
        }
        return max;
    }
    //将一个整型数组每一个元素向前（向标号小的方向）移动一个位置，第一个元素移到最后一个位置。
    public static int[] move(int[] arr){
        int[] arr1=new int[arr.length];
        if (arr1.length<1){
            return new int[0];
        }else{
        for (int i = 0; i < arr.length-1; i++) {
            arr1[i]=arr[i+1];
        }
        arr1[arr.length-1]=arr[0];
            for (int i : arr1) {
                System.out.println(i);
            }
        return arr1;
        }
    }

//找出前n个质数，以数组的形式返回结果。
public static int[] prime() {
    int n = 5;
    int[] nums = new int[n];

    int num = 2;
    int index = 0;
    while (true) {
        boolean flag = true;
        for (int i = 2; i < num; i++) {
            if (num % i == 0) {
                flag = false;//不是质数
                break;
            }
        }
        if (flag) {
            nums[index++] = num;
            if (index == nums.length) {
                break;
            }

        }
        num++;
    }
    System.out.println(Arrays.toString(nums));
    return nums;

}

    //求一个整型数组各元素之和。
    public static int add(int[] arr){
        int add=0;
        for (int i = 0; i < arr.length; i++) {
            add+=arr[i];

        }
        System.out.println("整型数组各元素之和:"+add);
        return add;
    }
    //编写一个方法，其功能是对一个整型数组升序排列（请采用冒泡算法）。
    public static int maoPao(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
        for (int j = 0; j < arr.length-1-i; j++) {
            if (arr[j]>arr[j+1]){
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }

        }
    }
        for (int i = 0; i < arr.length; i++) {
        System.out.print(" "+arr[i]);
    }
        return 0;
 }
    //用选择法对若干个数排序（由大到小）。
    public static void Selectsort(int[] arr) {
        if (arr == null || arr.length == 0) {
            System.out.println("输入的数组不合法！");
        }
        int i, j, t;
        for (i = 0; i < arr.length - 1; i++) {
            for (j = i + 1; j < arr.length; j++) {
                if (arr[i] < arr[j]) {
                    t = arr[i];
                    arr[i] = arr[j];
                    arr[j] = t;
                }
            }
        }
        for (i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    //用插入法对若干个数排序（由小到大）。
    public static void Insertsort(int[] arr) {
        if (arr == null || arr.length == 0) {
            System.out.println("输入的数组不合法！");
        }
        for (int i = 0; i < arr.length - 1; i++) {
            int j = arr[i + 1];
            int k = i;
            while (k >= 0 && j < arr[k]) {
                arr[k + 1] = arr[k];
                k--;
            }
            arr[k + 1] = j;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    //用折半查找法在一组排好序(递增有序或递减有序)的值中查找某个数据。
    public static int refengfa(int[] arr,int stat,int end,int a){
        if(stat > end){
            return -1;
        }

        int middle=(stat+end)/2;
        if (arr[middle]<a){//右边
            return refengfa(arr,middle+1,end,a);
        }else if(arr[middle]>a){//左边
            return refengfa(arr, 0,middle-1, a);
        }else{
            return middle;
        }
    }
    //求一个整型数组元素中最接近其平均值的整数。
    public static int age(int[] arr) {
        if (arr == null || arr.length == 0) {
            System.out.println("输入的数组不合法！");
        }
        int i, sum = 0;
        for (i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        int y = sum / arr.length;
        if (arr == null) {
            return -1;
        }
        if (arr.length == 1) {
            return arr[0];
        }
        int k = -1;
        for (int j = 0; j < arr.length; j++) {
            if (arr[j] > y) {
                k = j;
                break;
            } else if (arr[j] == y) {
                return y;
            }
        }
        int z;
        if (k == -1) {
            return arr[arr.length - 1];
        } else if (k == 0) {
            return arr[0];
        } else {
            z = y - arr[k - 1] < arr[k] - y ? arr[k - 1] : arr[k];
        }
        System.out.println(z);
        return z;
    }
    //实现一个数组复制方法，参数为:源数组、起始下标、复制长度，返回值为新数组
    public static void arrayCopy(int[] arr,int start,int length) {
        for (int i = start; i < length + start; i++) {
            System.out.println(arr[i]);

        }
    }
}