Java基础（三）

框架是个好东西，可早晚有一天会过时，这世界上就没有亘古不变的东西，来学下Java基础吧

枚举

枚举常用地方：用枚举类型去替换常量

基础用法：

public class Test {
    public static void main(String[] args) {
        System.out.println(PizzaStatus.ORDERED.name());
        System.out.println(PizzaStatus.ORDERED);
        System.out.println(PizzaStatus.ORDERED.name().getClass());
        System.out.println(PizzaStatus.ORDERED.getClass());
    }
}

enum PizzaStatus {
    ORDERED,
    READY,
    DELIVERED;
}

<<<ORDERED
<<<ORDERED
<<<class java.lang.String
<<<class cn.luckycurve.demo2.PizzaStatus

添加方法（通过继承接口方式）：

public class Test {
    public static void main(String[] args) {
//        查询订餐详细信息
        String s = "ORDERED";
        System.out.println(PizzaStatus.valueOf(s).info());
    }
}

interface PizzaDiscription{
    String info();
}

enum PizzaStatus implements PizzaDiscription{
    ORDERED{
        @Override
        public String info() {
            return "已经预定";
        }
    },
    READY{
        @Override
        public String info() {
            return "准备送餐";
        }
    },
    DELIVERED{
        @Override
        public String info() {
            return "已经送达";
        }
    };

}

如果以上例子不用枚举就要使用if/elas或者是switch语句，不方便

自定义构造函数（与上面的代码块达到同样的效果）：

public class Test {
    public static void main(String[] args) {
//        查询订餐详细信息
        String s = "ORDERED";
        System.out.println(PizzaStatus.valueOf(s).info());
    }
}

interface PizzaDiscription {
    String info();
}

enum PizzaStatus implements PizzaDiscription {

    ORDERED("已经预定"),
    READY("准备送餐"),
    DELIVERED("已经送达");

    //    菜品描述
    private final String desc;

    //    定义为普通构造，防止被外部调用破坏内部结构
    PizzaStatus(String desc) {
        this.desc = desc;
    }

    @Override
    public String info() {
        return desc;
    }
}

集合的工具类

主要就是Collections工具类和Arrays工具类

Collections的常用方法：

• 排序
• 查找
• 替换

由此可以看出，Collections是操作List的【有序集合】

排序操作：

void reverse(List list)//反转
void shuffle(List list)//随机排序
void sort(List list)//按自然排序的升序排序
void sort(List list, Comparator c)//定制排序，由Comparator控制排序逻辑
void swap(List list, int i , int j)//交换两个索引位置的元素
void rotate(List list, int distance)//旋转。当distance为正数时，将list后distance个元素整体移到前面。当distance为负数时，将 list的前distance个元素整体移到后面

代码事例：

public class Test {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(2);
        list.add(3);
        list.add(-1);
        list.add(1);
        list.add(0);
        System.out.println("原始数组：" + list);
        Collections.reverse(list);
        System.out.println("反转之后：" + list);
        Collections.shuffle(list);
        System.out.println("随机排序之后：" + list);
        Collections.sort(list);
        System.out.println("升序排序：" + list);
        Collections.sort(list, (a, b) -> {
//            升序，降序则反过来
            return b.compareTo(a);
        });
        System.out.println("自定义compare后："+list);
        Collections.swap(list,0,1);
        System.out.println("交换0和1之后的list："+list);

    }
}

<<<原始数组：[2, 3, -1, 1, 0]
<<<反转之后：[0, 1, -1, 3, 2]
<<<随机排序之后：[0, 2, 1, 3, -1]
<<<升序排序：[-1, 0, 1, 2, 3]
<<<自定义compare后：[3, 2, 1, 0, -1]
<<<交换0和1之后的list：[2, 3, 1, 0, -1]

查找替换操作：

int binarySearch(List list, Object key)//对List进行二分查找，返回索引，注意List必须是有序的
int max(Collection coll)//根据元素的自然顺序，返回最大的元素。 类比int min(Collection coll)
int max(Collection coll, Comparator c)//根据定制排序，返回最大元素，排序规则由Comparatator类控制。类比int min(Collection coll, Comparator c)
void fill(List list, Object obj)//用指定的元素代替指定list中的所有元素。
int frequency(Collection c, Object o)//统计元素出现次数
int indexOfSubList(List list, List target)//统计target在list中第一次出现的索引，找不到则返回-1，类比int lastIndexOfSubList(List source, list target).
boolean replaceAll(List list, Object oldVal, Object newVal), 用新元素替换旧元素

例子：

public class Test {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(2);
        list.add(3);
        list.add(-1);
        list.add(1);
        list.add(0);
        Collections.sort(list);
        System.out.println(list);
        int i = Collections.binarySearch(list, 0);
        System.out.println("0的索引为："+i);
//        默认返回最大元素
        Integer max = Collections.max(list);
        System.out.println("最大值为："+max);
//        根据compare排序
        Integer max1 = Collections.max(list, (a, b) -> {
            return b.compareTo(a);
        });
        System.out.println("改变排序规则后的："+max1);
        Collections.fill(list,0);
        System.out.println("全部用0填充后："+list);
        int frequency = Collections.frequency(list, 0);
        System.out.println("0出现的次数为："+frequency);
//        统计第一次出现的索引，找不到则返回-1
        ArrayList<Integer> list1 = new ArrayList<>(2);
        Collections.fill(list1,0);
        int index = Collections.indexOfSubList(list, list1);
        System.out.println("【0,0】数组第一次出现的位置为："+index);
        Collections.replaceAll(list,0,1);
        System.out.println("用1替换0之后的list为："+list);
    }
}

Arrays的常见操作为【多对数组进行操作】：

• 排序
• 查找
• 比较
• 填充
• 转列表
• 转字符串
• 复制

排序事例：

public class Test {
    public static void main(String[] args) {
        int[] a = {0, 3, 1, 2, -1};
        System.out.println("默认排序："+Arrays.toString(a));
//        默认排序
        Arrays.sort(a);
        System.out.println("排序之后"+Arrays.toString(a));


        int[] b = {0, 3, 2, 1, -1};
        System.out.println("默认排序："+Arrays.toString(b));
//      前闭后开
        Arrays.sort(b,1,3);
        System.out.println("指定范围排序："+Arrays.toString(b));
        
    }
}


<<<默认排序：[0, 3, 1, 2, -1]
<<<排序之后[-1, 0, 1, 2, 3]
<<<默认排序：[0, 3, 2, 1, -1]
<<<指定范围排序：[0, 2, 3, 1, -1]

查找【二分查找，先要排序】：

    public static void main(String[] args) {
        int[] a = {0, 3, 1, 2, -1};
//        二分查找，先要排序
        Arrays.sort(a);
        int i = Arrays.binarySearch(a, 3);
        System.out.println("3的下标为："+i);
    }

<<<3的下标为：4

比较【用数组的equals和==都直接返回false（没有重写equals）】：

    public static void main(String[] args) {
        int[] a = {0, 3, 1, 2, -1};
        int[] b = {0, 3, 1, 2, -1};
        boolean equals = Arrays.equals(a, b);
        System.out.println(a==b);
        System.out.println(a.equals(b));
        System.out.println(equals);
    }

<<<false
<<<false
<<<true

填充：

    public static void main(String[] args) {
        int[] a = {0, 3, 1, 2, -1};
        Arrays.fill(a, 2);
        System.out.println("全部填充：" + Arrays.toString(a));

//        指定范围填充，前闭后开
        Arrays.fill(a, 0, 2, 9);
        System.out.println("指定范围填充：" + Arrays.toString(a));
    }

<<<全部填充：[2, 2, 2, 2, 2]
<<<指定范围填充：[9, 9, 2, 2, 2]

转列表：

    public static void main(String[] args) {
        Integer[] a = {0, 3, 1, 2, -1};
        List<Integer> list = Arrays.asList(a);
        System.out.println(list);
    }

⚠️：数组中不能使用int类型了，因为如果使用int类型，转换过后集合里面是不能存储基本数据类型的

列表的复制：

    public static void main(String[] args) {
        int[] a = {0, 3, 1, 2, -1};
//        复制固定长度，长度超出补0
        int[] copy = Arrays.copyOf(a, 22);
        System.out.println(Arrays.toString(copy));

//        复制指定范围
        int[] copy1 = Arrays.copyOfRange(a, 0, 2);
        System.out.println(Arrays.toString(copy1));
        
<<<[0, 3, 1, 2, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
<<<[0, 3]