java数组

数组的定义

public class TestArr1 {
    public static void main(String[] args) {
        //int类型数组
        int[] arr;//声明
        //new 关键字创建类的模板对象
            //其他情况1:System.out方法内创建对象
            //其他情况2:String s = "";=new String("")
        arr = new int[5];//指定数组容量
        int len = arr.length;
        System.out.println(len);
        System.out.println(arr);
    }
}

数组默认值

public class TestArr2 {
    public static void main(String[] args) {
//        int[] arr = new int[-1];//编译不报错运行时报错
        int[] arr = new int[5];
        int a1 = arr[0];
        int a2 = arr[0];
        int a3 = arr[0];
        int a4 = arr[0];
        int a5 = arr[0];//默认0
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
        System.out.println(a4);
        System.out.println(a5);
//        int a6 = arr[6];//编译时报错 越界
        float[] arr2 =new float[2];//默认0.0
        System.out.println(arr2[0]);
        String[] arr3 = new String[2];//默认null
        System.out.println(arr3[0]);
        double[] arr4 = new double[2];//默认0.0
        System.out.println(arr4[0]);
        boolean[] arr5 = new boolean[2];//默认false
        System.out.println(arr5[0]);
    }
}

数组遍历

public class TestArr3 {
    public static void main(String[] args) {
        //方法一:先声明 后赋值 默认值
        XuanZeSort xuanZeSort = new XuanZeSort();
        int[] arr;
        arr= new int[2];
        //方法二:声明并赋值 默认值
        int[] arr2 =new int[2];
        //方法三:声明时并赋值 此时中括号不能填写数组长度
        int[] arr3 = new int[]{1,2,3,4};
        //简写
        int[] arr4 = {5,3,7,1};
        //数组遍历
        for (int i =0;i<arr4.length;i++){
            System.out.print(arr4[i]+" ");
        }
        System.out.println();
        xuanZeSort.selectsort(arr4);
    }
}

获取数组平均值

public class Demo1 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4};
        avg(arr);
    }

    private static void avg(int[] arr) {
        double sum =0;
        for (int i = 0; i < arr.length; i++) {
            int temp = arr[i];
            sum = sum+temp;
        }
        System.out.println(sum/ arr.length);
    }
}

冒泡排序，选择排序，插入排序

public class Demo2 {
    public static void main(String[] args) {
        int[] arr = {2,0,4,7,8,5,3};
        int[] arr2 = {2,3,4,6,8,5,9,1};
        //冒泡排序
        //选择排序
        //插入排序
//        bubberSort(arr);
//        selectSort(arr2);
        insertSort(arr);
    }

    /**
     * 插入排序
     * 数组分为左右两组 左边一组已排序 右边是未排
     * 默认第一个值已排
     * 新值 从未排的当前值与已排所有值比较，找到合适的位置
     *  默认当前位置是最合适的位置
     *  合适的位置:小的放左边 大的放右边
     *  外层循环
     *
     *  内层循环
     *      用当前值和已排所有值比较
     * @param arr
     */
    private static void insertSort(int[] arr) {
        //[1,7)
        for (int i = 1; i < arr.length; i++) {
            int shouldIndex = i;//默认最合适位置
            //临时值记录当前值
            int currentV = arr[i];
            for (int j =i-1;j>=0;j--){
                if (currentV<arr[j]){
                    //将j对的值往后移 将i的值放入j的位置
                    arr[j+1]=arr[j];
                    shouldIndex=j;//合适的位置
                }else {
                    break;
                }
            }
            //将值放入当前位置
            if (shouldIndex!=i) {
                arr[shouldIndex] = currentV;
            }
        }
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 选择排序
     * 每轮 选出最小值 放在当前轮的最小值 就放第一位
     * 轮数：arr.length -1
     * 每次 从未排序找出最小值
     * @param arr
     */
    private static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            //每轮都要初始化一个值
            int min = i;
            //内循环目的是为了找到最小值
            for (int j = i+1;j< arr.length;j++){
                if (arr[min]>arr[j]){
                    min=j;
                }
            }
            //找出最小值 和第一个交换
            if (i!=min) {
                int temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
            }

            System.out.println("第"+i+"轮的结果:"+Arrays.toString(arr));
        }
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 冒泡排序2149853
     * 每次相邻的两个数
     * 如果后面比前面大 交换顺序
     * 每轮n次 最终只能确定一个最大值 放最后
     * @param arr
     */
    private static void bubberSort(int[] arr) {
        //外循环 轮数 每轮只能确定最大值 放最后
        //[0-6)
        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;
                }
                System.out.println("第"+i+"轮第"+j+"次的结果"+Arrays.toString(arr));
            }
            System.out.println("第"+i+"轮的结果"+ Arrays.toString(arr));
        }
        //最终结果
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

数组拷贝

int[] arr = {5,8,0,2,3,1};
        //toString:将数组变成规则的字符串
        //String:[元素，元素]
        System.out.println(Arrays.toString(arr));//遍历方法

        //拷贝数组 并扩容 采用原数组arr=的话 原素组会被覆盖 也可以用新的数组接收
        arr = Arrays.copyOf(arr,arr.length<<1);
        System.out.println(Arrays.toString(arr));