JavaSE（十四）集合

集合

• 集合类型，好多个类型，JDK提供好的 位于java.util包中 需要显示导入进来；

• 集合类型和数组类似，都是容器

• 数组使用起来不太方便，集合类型使用起来非常简单

• 数组 数组元素；集合 集合元素；集合中只能存放对象，集合元素必须都是对象，基本数据类型的值需要转换为包装类型

1.1.Collection接口

• Collection集合元素是单值，一个对象就是一个集合元素

Collection父接口定义的方法

    /**
     * Collection接口中定义的非常常用的方法
     */
    private static void method2() {
        Collection collection = new ArrayList();
        //isEmpty方法 判断是否是一个空集合
        System.out.println("是否是空集合 元素个数为0： " + collection.isEmpty());
        //添加不需要考虑扩容 删除的时候不需要考虑元素移动
        //add方法用于向集合中添加集合元素对象
        collection.add("java");
        //int ->Integer 集合中只能放对象 基本数据类型都要转换为包装类型
        collection.add(123);
        collection.add(new Monkey());
        //remove方法删除 指定对象；如果删除成功返回true
        System.out.println(collection.remove(123));
        System.out.println("contains集合中是否包含指定对象: " + collection.contains("java"));
        //clear方法 用于清空集合
        collection.clear();
        //size方法 用于获取集合大小  也就是集合元素的个数
        System.out.println("集合大小 集合元素个数： " + collection.size());
        //集合类型都已经重写了toString方法 内部实现是把内部每个元素的字符串形式拼接为一个字符串对象
        System.out.println(collection);
    }
​
 /**
     * Collection接口中定义的常用的方法
     */
    private static void method3() {
        Collection collection1 = new ArrayList();
        collection1.add("java1");
        collection1.add("java2");
        collection1.add("java3");
        Collection collection2 = new ArrayList();
        //addAll 添加指定集合中的所有元素
        collection2.addAll(collection1);
        collection2.add(6.9);
        collection2.add(9.9);
        collection2.add("java2");
        collection2.add("java3");
        // collection2.remove("java1");
        //containsAll 判断是否包含指定集合中的所有元素对象
        System.out.println("containsAll:  " + collection2.containsAll(collection1));
        //removeAll当前集合元素对象 只要位于 指定集合中 都进行删除(只要相等 都进行删除)
//        collection2.removeAll(collection1);
        //把集合类型 转换为 数组类型
        Object[] objects = collection2.toArray();
        System.out.println(collection2);
        System.out.println(Arrays.toString(objects));
    }

remove的注意点

 /**
     * remove方法 注意
     */
    private static void method4() {
        Collection collection = new ArrayList();
        collection.add("java");
        collection.add("java");
        //如果有多个相同对象 只删除第一个
        collection.remove("java");
        System.out.println(collection);
    }

1.1.1. List子接口

• 集合元素是单值; List的集合元素是 有序而且可以重复的

• /**
      * List和Set的特点
      */
     private static void method5() {
         List list = new ArrayList();
         //  List的集合元素是  有序(存取有序 添加的顺序就是存放的顺序 有索引)而且可以重复的
         list.add("java2");
         list.add("java1");
         list.add("java3");
         System.out.println(list);
   
         // Set 的集合元素是  无序（没有索引）而且不可重复的
         Set set = new HashSet<>();
         set.add("java2");
         set.add("java1");
         set.add("java3");
         System.out.println("set: " + set);
     }

1.1.1.1. List方法定义与使用

1，常用方法

/**
     * List子接口 新增方法
     */
    private static void method6() {
        //List的元素是有索引 值从0开始 索引有效取值范围[0,size-1]
        List list = new ArrayList();
        list.add("java2");
        list.add("java1");
        list.add("java3");
        list.add("java2");
        //add方法 指定索引位置 插入元素对象
        list.add(0, "python");
        //get方法 根据指定索引 获取元素对象
        Object o = list.get(3);
        System.out.println(o);
        System.out.println("indexOf指定对象首次出现的索引值： " + list.indexOf("java2"));
        System.out.println("lastIndexOf指定对象最后一次出现的索引值： " + list.lastIndexOf("java2"));
        //remove方法 根据指定索引 删除元素对象
        list.remove(0);
        //set方法 改值 根据指定索引值 使用新的元素对象替换旧的元素对象
        list.set(0, "JS");
        System.out.println(list);
    }

2，泛型的使用

 /**
     * 泛型在集合中的应用
     */
    private static void method9() {
        List<Monkey> list = new ArrayList<>();
        list.add(new Monkey());
        Monkey monkey1 = list.get(0);
        //集合中只能放对象
        List<Integer> list2 = new ArrayList<>();
    }
​
    private static void method8() {
        //泛型在集合的使用 为了约束集合元素的类型
        List<String> arr = new ArrayList();
        arr.add("java1");
        arr.add("java2");
​
        String s = arr.get(0);
        //泛型 如果不指定 统统来看Object来看
        List arr2 = new ArrayList();
        List<Object> arr3 = new ArrayList();
    }

3，泛型指定为容器类型

/**
     * List的泛型指定为 容器类型
     */
    private static void method10() {
        //<引用类型>
        List<int[]> list = new ArrayList<>();
        int[] arr1 = {12, 77, 99};
        list.add(arr1);
        System.out.println(list.size());
​
        //存放所有班级的所有学生
        //list2的集合元素类型也是List类型
        List<List<Monkey>> list2 = new ArrayList<>();
        List<Monkey> sonList1 = new LinkedList<>();
        sonList1.add(new Monkey(101, "monkey1"));
        sonList1.add(new Monkey(102, "monkey2"));
        list2.add(sonList1);
        List<Monkey> monkeys = list2.get(0);
        System.out.println(monkeys);
    }

4，List的遍历方式

 /**
     * List的遍历
     */
    private static void method11() {
        ArrayList<String> list = new ArrayList();
        list.add("java2");
        list.add("java1");
        list.add("java3");
        //1 普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("===============");
        //2 增强for循环
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("++++++++++++++++s");
        //3 迭代器遍历
        Iterator<String> iterator = list.iterator();
        //
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        System.out.println("######################");
        // 4 forEach方法遍历
//        list.forEach(new ConsumerImpl());
    }

5，forEach遍历

/**
     * forEach方法 使用匿名内部类或lambda表达式
     */
    private static void method12() {
    /*class T {
    }*/
        //List: 有序 而且 可以重复
        ArrayList<String> list = new ArrayList<>();
        list.add("java2");
        list.add("java1");
        list.add("java3");
        //匿名内部类 无名类; 一次性的类
        list.forEach(new Consumer<String>() {