集合

1. 集合类存放于java.util包中。
   集合类存放的都是对象的引用，而非对象本身。
2. 集合类型主要有3种：set(集）、list(列表）和map(映射)。
3. 集合接口分为：Collection和Map，list、set实现了Collection接口

Collection抽象接口

定义集合的相关操作
List接口 列表 数组 特点：有序 可重复
ArrayList
LinkedArrayList
Set集合 特点：无序 不重复

Map接口

映射关系 Key-Value 键值对 键不能相同

Collection接口的方法

       Collection<String> text = new ArrayList();
        text.add("Jack");
        text.add("Merry");
        System.out.println(text);

        //删除一个对象
        text.remove("Jack");
        System.out.println(text);

        //获取元素个数
        System.out.println(text.size());

        //判断是否包含一个元素
        if(text.contains("Merry")){
            System.out.println("有");
        }else{
            System.out.println("无");
        }

        //判断是否为空
        if(text.isEmpty()){
            System.out.println("kon");
        }

        //判断两个集合是否相同
        Collection<String> t2 =  new ArrayList<>();
        t2.add("Jack");
        t2.add("Merry");
        if(text.equals(t2)){
            System.out.println("相同");
        }else{
            System.out.println("不同");
        }
        //清空
        text.clear();;
        System.out.println(text);

集合的遍历

//1.使用Iterator来遍历
        //hasNext 判断是否有对象
        //next 获取下一个对象
        //remove 删除当前遍历过后的对象
        Iterator iterator = t2.iterator();

        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //2.for-each
        for(String obj: t2){
            System.out.println(obj);
        }
        //3.for - i
        for(int i = 0; i < t2.size(); i++){
            System.out.println(t2);
        }

List接口 extends Collection

        //ArrayList
        //LinkedArrayList
        //集合里面只能存放对象
        //自动将基本数据类型包装为对应的类
        ArrayList<Integer> score = new ArrayList<>();
        score.add(2);
        score.add(3);//在末尾添加
        score.add(0,1);//在指定位置插入
        System.out.println(score);

        //访问指定元素
        score.get(1);

        //修改一个元素
        score.set(0,0);
        System.out.println(score);

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

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

        score.clear();//删除所有 清空
        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);

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

        //访问某个对象在集合里面的索引
        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));

        //将ArrayList 转化为普通数组
        Integer[] objects = new Integer[a4.size()];
        a4.toArray(objects);
        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());
        }

        //获取集合某个范围的子集合
        List<Integer> integers = a4.subList(1,2);
        System.out.println(integers);
        
        ArrayList<Integer> nums=new ArrayList<>();
        nums.add(1);
        nums.add(2);
        nums.add(3);
        nums.add(4);

        //Lambda表达式
        //nums.removeIf(obj->obj%2==0);
        for(Integer obj:nums){
            if(obj%2==0){
                nums.remove(obj);
            }
        }
        for(int i=0;i<nums.size();i++){
            Integer obj=nums.get(i);
            if(obj%2==0){
                nums.remove(i);
                i--;
            }
        }
        System.out.println(nums);

闭包

enclusure 把函数作为一个方法的参数

class ArrayClass{
    public void test(int[] target, Show s){
        for (int element: target){
            s.customShow(element);
        }
    }
}

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

class PXDClass implements Show{
    @Override
    public void customShow(int element) {
        System.out.println(element);
    }
}
//1.使用方式: 定义一个类实现接口
//        ArrayClass ac = new ArrayClass();
//        int[] num = {1,2,3,4,5,6};
//        PXDClass pc = new PXDClass();
//        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);
////        });

体会

今天的内容超级无敌枯燥，人超级困