目的

通常，我们的程序需要根据程序运行时才知道创建多少个对象。但若非程序运行，程序开发阶段，我们根本不知道到底需要多少个数量的对象，甚至不知道它的准确类型。为了满足这些常规的编程需要，我们要求能在任何时候，任何地点创建任意数量的对象，而这些对象用什么来容纳呢？我们首先想到了数组，但是数组只能放统一类型的数据，而且其长度是固定的，那怎么办呢？集合便应运而生；学习集合使用方法，可以更好地掌握Java语言用法

集合Collection

概念

Java集合类存放于 java.util 包中，是一个用来存放对象的容器
注意：
①、集合只能存放对象。比如你存一个 int 型数据 1放入集合中，其实它是自动转换成 Integer 类后存入的，Java中每一种基本类型都有对应的引用类型。
②、集合存放的是多个对象的引用，对象本身还是放在堆内存中。
③、集合可以存放不同类型，不限数量的数据类型。

类别

1.jpg

集合类型主要有3种：set(集）、list(列表）和map(映射)，而集合接口分为：Collection和Map，其中list、set实现了Collection接口
Collection接口是定义集合的相关操作，其中：
1，List（有序，可重复）
List里存放的对象是有序的，同时也是可以重复的，List关注的是索引，拥有一系列和索引相关的方法，查询速度快。因为往list集合里插入或删除数据时，会伴随着后面数据的移动，所有插入删除数据速度慢，具体实现为ArrayList和LinkedArrayList
2，Set（无序，不能重复）
Set里存放的对象是无序，不能重复的，集合中的对象不按特定的方式排序，只是简单地把对象加入集合中，具体实现为HashSet
而Map接口是一种映射关系，即Key-Value；键值对，键不能相同，但值可以相同；具体实现为HashMap

集合的元素个数一定是可变的

Collection集合方法

• 1.添加元素（add，addAll）

add是添加一个元素，而addAll是在一个集合中添加另外一个集合

        // Collection接口
        Collection<String> t1 = new ArrayList();

        t1.add("Jack");
        t1.add("Merry");

        System.out.println(t1);

        ArrayList<Integer> score = new ArrayList<>();
        score.add(2);
        score.add(3);// 在末尾添加
        score.add(0,1);// 在指定位置插入
        System.out.println(score);

        ArrayList<Integer> a2 = new ArrayList<>();
        a2.add(1);
        a2.add(2);
        a2.add(3);

        // 讲一个集合里面的内容添加到当前集合中
        score.addAll(a2);
        System.out.println(score);

• 2.删除元素（remove）

        t1.remove("Jack");
        System.out.println(t1);

        score.remove(0);//删除指定位置的元素
        System.out.println(score);

        score.remove((Integer)2);// 删除指定的元素
        System.out.println(score);

• 3.获取集合中元素个数(size)

       System.out.println(t1.size());

• 4.判断是否包含一个元素(contains)

        if (t1.contains("Merry")){
            System.out.println("有Merry");
        }else{
            System.out.println("无Merry");
        }

• 5.判断集合是否为空（isEmpty）

        if (t1.isEmpty()){
            System.out.println("为空");
        }

• 6.比较集合元素是否相同（equals）

        Collection<String> t2 = new ArrayList<>();
        t2.add("Merry");
        t2.add("Jack");

        if (t1.equals(t2)){
            System.out.println("两个集合相同");
        }else{
            System.out.println("两个集合不同");
        }

• 7.清空集合（clear）

        t1.clear();

• 8.集合的遍历

使用Iterator来遍历

hasNext判断是否有元素，next获取下一个对象，remove删除当前遍历过后的对象

        Iterator iterator = t2.iterator();

        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

for-each 增强for循环 快速循环

        for (String obj:t2){
            System.out.println(obj);
        }

for-i循环

        for (int i = 0;i < t2.size(); i++){
            System.out.println(((ArrayList<String>) t2).get(i));
        }

• 9.访问指定元素（get）

        score.get(1);

• 10.修改集合元素（set）

        score.set(0,0);
        System.out.println(score);

• 11.取两个集合交集（retainAll）

        ArrayList<Integer> a3 = new ArrayList<>();
        a3.add(1);
        a3.add(2);
        score.retainAll(a3);// 取两个集合的交集
        System.out.println(score);

• 12.访问某个对象在集合里面的索引（indexOf）

        ArrayList<Integer> a4 = new ArrayList<>();
        a4.add(1);
        a4.add(2);
        a4.add(2);
        a4.add(1);
        System.out.println(a4.indexOf(1));// 第一次出现的位置
        System.out.println(a4.lastIndexOf(1));// 最后一次出现的位置

• 13.将ArrayList转为普通数组（toArray）

        Integer[] objects = new Integer[a4.size()];
        a4.toArray(objects);
        for(Integer i:objects){
            System.out.println(i);
        }
        Object[] objects1 = a4.toArray();
        for(Object i: objects1){
            System.out.println(1);
        }

        Iterator iterator = a4.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

• 14.获取集合某个范围的子集合（subList）

        List<Integer> integers = a4.subList(1,2);
        System.out.println(integers);

闭包 enclusure

        // 1.使用方式:定义一个类实现接口
        ArrayClass ac = new ArrayClass();
        int[] num = {1,2,3,4,5,6};
        Class pc = new Class();
        ac.test(num,pc);

        // 2.使用匿名类
        ArrayClass ac = new ArrayClass();
        int[] num = {1,2,3,4,5,6};
        ac.test(num, new Show() {
            @Override
            public void customShow(int element) {
                System.out.println(element);
            }
        });

        // 3.使用Lambda
        // 如果参数是一个接口类对象 且接口里面只有一个方法
        // 可以省略方法名
        ArrayClass ac = new ArrayClass();
        int[] num = {1,2,3,4,5,6};
        ac.test(num, (int element) -> {
            System.out.println(element);
        });

        // 4.如果只有一个参数 参数类型可以省略
        ArrayClass ac = new ArrayClass();
        int[] num = {1,2,3,4,5,6};
        ac.test(num,element -> {
            System.out.println(element);
        });

        // 5.如果代码块里面只有一行语句 大括号可以省略
        ArrayClass ac = new ArrayClass();
        int[] num = {1,2,3,4,5,6};
        ac.test(num,element -> System.out.println(element));

    }
}

// 闭包 enclusure 把函数作为一个方法的参数
class ArrayClass{
    public void test(int[] target, Show s){
        for (int element: target){
            s.customShow(element);
        }
    }
}

// 必须是接口 并且这个接口里面只有一个方法
interface Show{
    void customShow(int element);
}

class Class implements Show{
    @Override
    public void customShow(int element) {
        System.out.println(element);
    }
}

心得感想

又是走神的一天嘻嘻；认真反省，坚决不改哈哈哈哈哈哈哈；还是要认真kkkk