Java实现类、lambda表达式、函数式接口

三大实现类怎么存取！

ArrayList类-->顺序存，
1、怎么存？ ---> list.add(1);
2、怎么取？ ---> list.get(i);
3、怎么遍历？--->for、for-each、Iterator迭代器

初始化以及存取ArrayList类

//初始化
List list = Arrays.asList(1, 2, 3, 4, 5, 6);
//另一种添加的方法
//        list.add(12);
//        list.add(34);
//        list.add(56);
//        list.add(78);

//取+遍历
System.out.println("===for-each实现list遍历===");
for (Integer i:list) {
	System.out.println(i);
}

System.out.println("===for-each+lambda实现list遍历===");
list.forEach(System.out::println);

HashSet类-->过滤重复元素
1、怎么存？ ---> set.add(1);
2、怎么取？ ---> set.get(i);
3、怎么遍历？--->for-each、Iterator迭代器

初始化以及存取HashSet类

//初始化
Set set = new HashSet();
//存
et.add("s1");
set.add("s2");
 set.add("s1");

 //取+遍历
System.out.println("===Iterator迭代器实现Set遍历===");
Iterator iterator = set.iterator();
while(iterator.hasNext()){
	String next = iterator.next();
	System.out.println(next);
}
System.out.println("===使用forEach+lambda实现Set遍历===");
set.forEach(System.out::println);

HashMap类-->过滤重复元素
1、怎么存？ ---> map.put(key,value);
2、怎么取？ ---> map.get(key);
3、怎么遍历？--->for-each、Iterator迭代器

初始化以及存取HashMap类

        //存
        Map map = new HashMap();
        map.put(1,"s1");
        map.put(2,"s2");
        map.put(3,"s1");

        //取+遍历
        
        //第一种：for-each
        System.out.println("===for-each实现Map遍历===");
        for (Map.Entry entry : map.entrySet()) {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }

        //第二种 for-each迭代key和values
        System.out.println("===for-each迭代key和value实现Map遍历===");
        //iterating over keys only
        for (Integer key : map.keySet()) {
            System.out.println("Key = " + key);
        }
        //iterating over values only
        for (String value : map.values()) {
            System.out.println("Value = " + value);
        }

        //第三种 使用Iterator迭代EntrySet
        System.out.println("===使用Iterator迭代EntrySet实现Map遍历===");
        Iterator> iterator01 = map.entrySet().iterator();
        while (iterator01.hasNext()) {
            Map.Entry entry = iterator01.next();
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }

        //第四种 使用Iterator迭代KeySet
        System.out.println("===使用Iterator迭代KeySet实现Map遍历===");
        Iterator iterator02 = map.keySet().iterator();
        while (iterator02.hasNext()) {
            Integer key = iterator02.next();
            System.out.println(key);
            System.out.println(map.get(key));
        }

        //第五种 Lambda
        System.out.println("===使用for-each+lambda实现Map遍历===");
        map.forEach((k,v)->{
            System.out.println(k);
            System.out.println(v);
        });

    }

//list接口

        
        List list= new ArrayList();

        list.add(12);
        list.add(34);
        list.add(56);
        list.add(78);
        //a)用普通for循环来遍历
        System.out.println("===for循环遍历===");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //b)使用增强for循环来遍历
        System.out.println("===增强for循环遍历===");
        for (Integer i:list) {
            System.out.println(i);
        }
        //c)使用Iterator迭代器

        //方式一：通过while循环来使用迭代器
        //1、获得一个Iterator迭代器
        System.out.println("===Iterator迭代器实现遍历===");
        Iterator iterator = list.iterator();
        //2、如果存在下一个元素，则继续循环遍历
        while(iterator.hasNext()){
            //3、获取下一个元素
            Integer next = iterator.next();
            System.out.println(next);
        }


        //方式二：通过for循环+Iterator来使用迭代器
        //1、通过for循环+Iterator迭代器来遍历集合中的元素
        for (Iterator iterator2 = list.iterator();iterator2.hasNext();){
            //2、获得下一个元素
            Integer next = iterator2.next();
            System.out.println(next);
        }


        //需求：使用迭代器遍历list集合的过程中，删除某一个元素
        //错误实现：通过Collection接口提供的remove()删除(错误的方法)
//        Iterator iterator = list.iterator();
//        while(iterator.hasNext()){
//            Integer next = iterator.next();
//            if (next == 34){
//                list.remove(new Integer(34));
//            }
//        }

        //正确实现：通过Iterator接口提供的remove()删除
        Iterator iterator1 = list.iterator();
        while(iterator1.hasNext()){
            Integer i = iterator1.next();
            if (i == 34){
                iterator1.remove();
            }
        }

        System.out.println("===删除34后===");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

定义：有且仅有一个抽象方法的接口，可以有其他的方法.
@FunctionalInterface：放在接口定义的上方，表示该接口是函数式接口。是可选的

    //供给型接口：Supplier,没有参数，只有返回值T
    //supplier.get()
    Supplier supplier = ()-> {
        return "供给型接口：Supplier";
    };
    System.out.println(supplier.get());

    // 函数式接口：Function, 传入参数T，返回参数R
    //function.apply(T)
    Function function = (str) -> {
        return str;
    };
    System.out.println(function.apply("函数式接口：Function"));


    // 消费型接口：Consumer，只有输入参数T，没有返回值
    //consumer.accept(T);
    Consumer consumer = (str)-> {
        System.out.println(str);
    };
    consumer.accept("消费型接口：Consumer");

    // 断定型接口：Predicate ，有一个输入参数T，返回布尔类型true或false
    // predicate.test(T)
    Predicate predicate = (str)-> {
        //判断输入字符长度是否大于3
        return(str.length() > 3);
    };
    boolean test = predicate.test("abcd");
    System.out.println(test);
}

在实际开发中，我们常常遇到这样的情况：一个接口/类的方法的某个实现方式在程序中只会执行一次，但为了使用它，我们需要创建它的实现类/子类去实现/重写。此时可以使用匿名内部类的方式，可以无需创建新的类，减少代码冗余。

new 接口/类名(参数1, 参数2...){
    实现方法1(){
        
    }
    实现方法2(){
        
    }
......
};

注意：匿名内部类可以用在具体类、抽象类、接口上，且对方法个数没有要求。

lambda表达式
当存在一个接口，且接口内仅存在一个抽象方法时，可以使用Lambda表达式。
格式：(形式参数) -> {代码块}

Collection.foreach(Consumer c)

Map.foreach(BiConsumer b)


stream流学习：https://blog.csdn.net/a850661962/article/details/114287330?spm=1001.2014.3001.5506