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

一、常见三个实现类（ArrayList、HashSet、HashMap）

三大实现类怎么存取！

1、Arraylist

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

初始化以及存取ArrayList类

//初始化
List<Integer> 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);

2、HashSet

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

初始化以及存取HashSet类

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

 //取+遍历
System.out.println("===Iterator迭代器实现Set遍历===");
Iterator<String> 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);

3、HashMap

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

初始化以及存取HashMap类

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

        //取+遍历
        /*几个函数
        * 1、Map.Entry<Integer, String>
        * 2、map.entrySet()
        * 3、entry.getKey()；entry.getValue()
        * 4、map.keySet()；map.values()
        *
        * */
        //第一种：for-each
        System.out.println("===for-each实现Map遍历===");
        for (Map.Entry<Integer, String> 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<Map.Entry<Integer, String>> iterator01 = map.entrySet().iterator();
        while (iterator01.hasNext()) {
            Map.Entry<Integer, String> entry = iterator01.next();
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }

        //第四种 使用Iterator迭代KeySet
        System.out.println("===使用Iterator迭代KeySet实现Map遍历===");
        Iterator<Integer> 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);
        });

    }

2、Iterator迭代器

//list接口

        /*
         * 1、list实现类的遍历方法
         *  a)使用普通for循环来遍历
         *      -->因为list的实现类都是有序的，我们可以通过“索引或序号”来获得元素
         *  b)使用增强for循环来遍历
         *      -->使用增强for循环，不但能遍历List集合，还能遍历Set集合
         *  c)使用Iterator迭代器来实现
         *      -->使用Iterator迭代器，不但能遍历List集合，还能遍历Set集合
         *
         * 2、如何获得Iterator迭代器？
         *  通过Collection接口提供的“Iterator<E> iterator();”方法来获得一个terator迭代器
         * 3、Iterator迭代器有哪些方法？
         *  boolean hasNext();
         *      -->判断是否还有下一个元素，如果有则返回true，如果没有则返回false。
         *  E next();
         *      -->就是获得下一个元素
         *  public void remove();
         *      -->删除当前遍历出来的这个元素
         *
         * 需求：使用迭代器遍历list集合的过程中，删除某一个元素
         * 一、错误实现：通过Collection接口提供的remove()删除(错误的方法)
         * Iterator遍历时不可以通过list直接删除集合中的元素
         * 在使用Iterator的时候禁止对所遍历的容器进行改变其大小结构的操作。
         * 例如：在使用Iterator进行迭代时，如果对集合进行了add、remove操作就会出现ConcurrentModificationException异常。
         * 二、正确方法：通过Iterator接口提供的remove()删除
         * 4、增强for循环跟Iterator迭代器区别
         *  (1)for-each 不仅能够遍历集合，还能遍历数组。但是Iterator只能遍历集合
         *  (2)使用for-each遍历集合时不能删除元素，使用Iterator遍历集合时，可以使用Iterator的remove方法来删除元素
         */
        List<Integer> list= new ArrayList<Integer>();

        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<Integer> iterator = list.iterator();
        //2、如果存在下一个元素，则继续循环遍历
        while(iterator.hasNext()){
            //3、获取下一个元素
            Integer next = iterator.next();
            System.out.println(next);
        }


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


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

        //正确实现：通过Iterator接口提供的remove()删除
        Iterator<Integer> 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>,没有参数，只有返回值T
    //supplier.get()
    Supplier<String> supplier = ()-> {
        return "供给型接口：Supplier";
    };
    System.out.println(supplier.get());

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


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

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

四、匿名内部类、lambda表达式

匿名内部类

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

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

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

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

五、Stream流

Collection.foreach(Consumer c)

Map.foreach(BiConsumer<K,V> b)


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