数组，排序，枚举

数组

概念：只能存储同一个类型的元素的集合
注意： 创建数组的时候必须指定长度，并且长度是不可变

 

package com.array.demo;

/**
 * 成员变量： 定义在类的里面，方法的外面
 * 特点： 当前类初始化的时候会自动初始化缺省值(默认值)
 * 局部变量:  定义方法里面
 * 特点： 使用前必须初始化
 */
public class TestArray {

    private static float age;
    private static Object obj;

    public static void main(String[] args) {
        // 1个班级有40名同学的时候，想存储这些同学姓名的话，需要定义40个变量来存储学生的名称
        // 40名学生定义40个变量，如果是1000人呢，那么是不是要定义1000个变量来存储，不现实。
        // 数组： 用于存储同一个类型的元素[基本数据类型，引用数据类型]的集合。
        // 数组定义语法: 数据类型[] 数组名称 = 初始化数组
        // 注意： 数组的定义必须要指定长度。

        ////////////////// 数组的方式 /////////////////////
        String[] names1 = new String[1000];
        // 数组句柄
        // 局部变量： 使用前必须初始化
        String[] names2 = null;
        names2 = new String[100];

        int[] ages1 = {}; // ages！=null 但是length为0的
        int[] ages2 = new int[]{};
        System.out.println("数组长度为:"+ages2.length);

        ///////////////////// 数组的初始化 //////////////////
        float[] prices = {1.1F,3.2F,4.5F,6.7F};
        int[] numbers1 = new int[] {1,4,5,6,3,6,2};
        int[] numbers2 = new int[5];
        // 通过数组对应元素下标(从0开始的)来赋值
        numbers2[0] = 100;
        numbers2[1] = 110;
        numbers2[2] = 120;
        numbers2[3] = 130;
        numbers2[4] = 140;
        // numbers2[5] = 200; // java.lang.ArrayIndexOutOfBoundsException(数组下标越界)

        //////////////// 数组的读取 ////////////////////
        // 通过指定下标获取
        // 语法： 数组对象变量[索引]
        System.out.println("numbers[3] = " + numbers2[3]);
        System.out.println("------------------------------------");
        // 遍历数组中的每一个元素
        // 只要你在java中操作的对象存储容量，那么必须判断这个对象是否为null&& 判断容量是否>0
        if (numbers2 != null && numbers2.length > 0) {
            // 普通遍历集合元素
            for (int i = 0; i < numbers2.length; i++) {
                System.out.println("numbers2["+i+"]="+numbers2[i]);
            }
            System.out.println("----------------------------");
            // 增强for循环
            for (int element : numbers2) {
                System.out.println(element);
            }
        }
    }
}

排序

package com.array.demo;

import java.util.Arrays;

/**
 * 数组的排序
 */
public class TestArraySort {
    public static void main(String[] args) {
        // 定义待排序的数组
        int[] numbers = {4,6,3,7,5,2,1};
        // 求和
        sum(numbers);
        // 求平均数
        avg(numbers);
        // 最大数
        max(numbers);
        // 排序（冒泡，选择，插入） // 希尔，二分法排序，归并排序
        // bubboSort(numbers);
        // 选择排序
        // selectedSort(numbers);
        // 插入排序
        insertSort(numbers);
    }

    private static void insertSort(int[] numbers) {
        // 插入排序(将数列分为有序和无序两部分,
        // 每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较, 找出插入位置，将该元素插入有序系列中)
        for (int i = 1; i < numbers.length; i++) {
            for (int j = i; j >0; j--) {
                if (numbers[j] < numbers[j - 1]) {
                    int temp  = numbers[j];
                    numbers[j] = numbers[j-1];
                    numbers[j - 1] = temp;
                }
            }
        }

        for (int el : numbers) {
            System.out.print(el+" ");
        }

        System.out.println("\n\r");
    }

    /**
     * 选择排序(每次从待排序的数据源元素中选出最小/最大一个元素顺序放到排好序的最后)
     * @param numbers
     */
    private static void selectedSort(int[] numbers) {
        // 定义存储最小值
        int minVal = 0;
        // 存储最小值下标
        int minIndex = 0;

        for (int i =0 ; i < numbers.length; i++) {
            // 假设第一个元素就是最小值
            minVal = numbers[i];
            // 记录最小值得下标
            minIndex = i;
            for (int j = i + 1; j < numbers.length; j++) {
                if (numbers[j] < minVal) {
                    // 存储最小值
                    minVal = numbers[j];
                    // 存储最小值得下标
                    minIndex =  j;
                }
            }

            if (minVal != numbers[i] && minIndex != i) {
                numbers[minIndex] = numbers[i];
                numbers[i] = minVal;
            }
        }

        for (int el : numbers) {
            System.out.print(el+" ");
        }

        System.out.println("\n\r");


    }

    /**
     * 冒泡排序
     * @param numbers
     */
    private static void bubboSort(int[] numbers) {
        for (int i = 0; i < numbers.length; i++) {
            for (int j = 0; j < numbers.length - i - 1; j++) {
                if (numbers[j] > numbers[j + 1]) {
                    // 交换2个元素
                    int temp = numbers[j];
                    numbers[j] = numbers[j + 1];
                    numbers[j + 1] = temp;
                }
            }
            System.out.println(Arrays.toString(numbers));
        }

        for (int el : numbers) {
            System.out.print(el+" ");
        }

        System.out.println("\n\r");
    }

    private static void max(int[] numbers) {
        // 假设第一个元素为最大值
        int max = numbers[0];

        if (isNotEmpty(numbers)) {
            for (int i = 1; i < numbers.length; i++) {
                if (max < numbers[i]) {
                    max = numbers[i];
                }
            }
        }

        System.out.println("最大值为:"+max);

    }

    private static void avg(int[] numbers) {
        // 定义存储总和遍历
        int sum = 0;
        if (isNotEmpty(numbers)) {
            for (int number : numbers) {
                sum+=number;
            }
        }

        System.out.println("所有元素平均值为:"+sum/numbers.length);
    }

    /**
     * 求数组中所有元素的和
     * @param numbers
     */
    private static void sum(int[] numbers) {
        // 定义存储总和遍历
        int sum = 0;
        if (isNotEmpty(numbers)) {
            for (int number : numbers) {
                sum+=number;
            }
        }

        System.out.println("元素之和为:"+sum);
    }




    // 判断数组是否为空方法
    private static boolean isNotEmpty(int[] array) {
        return array != null && array.length > 0;
    }
}

二维数组:一个一维数组中的每一个元素就是一个一维数组

package com.array.demo;

/**
 * 多维数组:
 */
public class TestManyArray {
    public static void main(String[] args) {
        // 二位数组就是表格结构
        int[][] table1 =new int[4][];
        int[][] table2 =new int[4][4];
        table2[0][0] = 100;
        table2[0][1] = 200;
        table2[0][2] = 300;
        table2[0][3] = 400;

        table2[1][0] =20;
        table2[1][1] = 30;
        table2[1][2] = 40;
        table2[1][3] = 50;

        // 遍历二位数组
        int[][] numbers = {{1,2,3,4},{11,2,3,4},{3,2,23,12},{23,323,2,3}};

        for(int i = 0; i < numbers.length; i++) {
            for (int j = 0; j < numbers[i].length; j++) {
                System.out.print("numbers["+i+"]["+j+"]="+numbers[i][j]+"   ");
            }
            System.out.println();
        }

        int[][] map = {
                {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1},
                {1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1}
        };

        for (int[] m : map) {
            for (int n : m) {
                if (n ==0) {
                    System.out.print("*");
                } else if (n == 2) {
                    System.out.print("@");
                }else {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }

    }
}

枚举

package com.enums.demo;

import java.util.Arrays;

/**
 * 枚举是值类型， 它里面的元素都是常量
 * 特点:
 * 1、私有构造函数，避免被继承和扩展。
 * 2、定义方法的参数时，必须用枚举常量类类型，如上面的Constant,这样就转变成了强类型，不会出现弱类型引用的问题。
 * 3、常量值地址唯一，可以用==直接对比，性能会有提高。
 * 4、编译时，没有把常量值编译到代码里，即使常量的值发生变化，也不会影响引用常量的类。
 */
public class MyEnum {
    public static void main(String[] args) {
        // 声明枚举对象
        Direction direction = Direction.DOWN;
        // 获取枚举元素中的值
        System.out.println(direction.ordinal());
        System.out.println(direction);
        // 获取枚举的所有值
        Direction[] values = Direction.values();
        System.out.println(Arrays.toString(values));
        // 获取枚举元素对应值
        System.out.println(Direction.valueOf("LEFT"));

        // 定义一个枚举对象
        ResultCode code = ResultCode.ERROR_CODE;
        System.out.println(ResultCode.getCodeName(10000001));

        // 定义一个带抽象方法的枚举
        AbstractMark mark = AbstractMark.JAVA;
        System.out.println(mark.getInfo());

    }

    // 方向枚举
    enum Direction {
        UP,
        DOWN,
        LEFT,
        RIGHT,
        NONE
    }

    // 带构造函数的枚举
    enum ResultCode {
        ERROR_CODE(20001, "支付失败"),
        INFO_CODE(300031, "订单取消"),
        STATUS_CODE(10000001, "支付正常"),
        FAIL_CODE;

        private int code;
        private String codeName;

        private ResultCode() {

        }

        private ResultCode(int code, String codeName) {
            this.code = code;
            this.codeName = codeName;
        }

        /**
         * 通过编码获取到对象的信息
         * @param code
         * @return
         */
        public static String getCodeName(int code) {
            for (ResultCode c : ResultCode.values()) {
                if (c.code == code) {
                    return c.codeName;
                }
            }

            return null;
        }

    }

    // 带构造函数的枚举
    enum AbstractMark {
        CSS {
            @Override
            public String getInfo() {
                return "层叠样式表";
            }
        },
        HTML {
            @Override
            public String getInfo() {
                return "超文本标记语言";
            }
        },
        JAVA {
            @Override
            public String getInfo() {
                return "面向对象编程";
            }
        },
        SQLSERVER {
            @Override
            public String getInfo() {
                return "SQLSERVER数据库";
            }
        };

        public abstract String getInfo();
    }
}