Java学习笔记之函数式接口 Stream流

0x00 概述

本文涉及Java知识点：函数式接口，Stream流。

0x01 函数式接口

1.1 函数式接口概述

• 概念
  有且仅有一个抽象方法的接口

• 如果检测一个接口是不是函数式接口
  @FunctionalInterface
  放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败

• 注意事项
  我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样式函数式接口。但是，建议加上该注解

1.2 函数式接口作为方法参数

• 需求
  定义一个类(RunnableDemo)，在类中提供两个方法
  一个方法是：startThread(Runnable r)方法参数Runnable是一个函数式接口
  一个方法是主方法，在主方法中调用startThread方法
• 示例

package RunnableDemo;

public class RunnableDemo {
    public static void main(String[] args) {
        // 在主方法中调用startThread方法

        // 匿名内部类的方式
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程启动了");
            }
        });

        // Lambda方式
        startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));

    }

    private static void startThread(Runnable r) {
        new Thread(r).start();
    }
}  

1.3 函数式接口作为方法的返回值

• 需求
  定义一个类(ComparatorDemo),在类中提供两个方法
  一个方法是：Comparator getComparator()方法返回值

• 示例

package ComparatorDemo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ComparatorDemo {
    public static void main(String[] args) {
        // 定义集合，存储字符元素
        ArrayList array = new ArrayList();

        array.add("cccc");
        array.add("aa");
        array.add("b");
        array.add("ddd");

        System.out.println("排序前： " + array);
        System.out.println("-----------------");

        Collections.sort(array, getComparator());

        System.out.println("排序后：" + array);

    }

    private static Comparator getComparator() {
        /*
        // 匿名内部类的方式实现
        return new Comparator() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        };

         */

        // Lambda方式实现
        return (s1, s2) -> s1.length() - s2.length();
    }
}

  

1.4 常用函数式接口之Supplier

• Supplier接口
  Supplier接口也被称为生产型接口，如果我们指定了接口的泛型类型，那么接口中的get方法就会生产指定类型的数据供我们使用
   
• 常用方法
  只有一个无参的方法
  
   
• 示例

package SupplierDemo;

import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
        String s = getString(() -> "Alice");
        System.out.println(s);

        Integer i = getInteger(() -> 30);
        System.out.println(i);
    }

    // 定义一个方法，返回一个整数数据
    private static Integer getInteger(Supplier sup) {
        return sup.get();
    }

    // 定义一个方法，返回一个字符串数据
    private static String getString(Supplier sup) {
        return sup.get();
    }
}

1.5 Supplier接口练习之获取最大值

• 需求
  定义一个类(SupplierTest)，在类中提供两个方法
  一个方法是：int getMax(Supplier sup)用于返回一个int数组中的最大值
  一个方法是主方法，在主方法中调用getMax方法
   
• 示例

package SupplierTest;

import java.util.function.Supplier;

public class SupplierTest {
    public static void main(String[] args) {
        // 定义一个int数组
        int[] arr = {19, 50, 28, 37, 46};

        int maxValue = getMax(() -> {
            int max = arr[0];

            for(int i =1;i max) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(maxValue);
    }

    // 返回一个int数组中最大的值
    private static int getMax(Supplier sup) {
        return sup.get();
    }
}

1.6 常用函数接口之Consumer

• Consumer接口
  Consumer接口也被称为消费型接口，它消费的数据的数据类型由由泛型指定
   
• 常用方法
  Consumer：包含两个方法
  
   
• 示例

package ConsumerDemo;

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {
        // 操作一
        operatorString("Alice", s -> System.out.println(s));
        // 操作二
        operatorString("Alice", s -> System.out.println(
                new StringBuilder(s).reverse().toString()
        ));

        System.out.println("--------");

        // 传入两个操作使用andThen完成
        operatorString("Alice", s -> System.out.println(s), s ->
                System.out.println(new StringBuilder(s).reverse().toString()));
    }

    // 定义一个方法，用不同的方式消费同一个字符串数据两次
    private static void operatorString(String name, Consumer con1, Consumer con2) {
        // con1.accept(name);
        // con2.accept(name);
        con1.andThen(con2).accept(name);
    }

    // 定义一个方法，消费一个字符串数据
    private static void operatorString(String name, Consumer con) {
        con.accept(name);
    }
}

1.7 Consumer接口练习之按要求打印信息

• 需求
  String[] strArray = {"Alice,13", "Bob,12","Claire 15"};
  字符串数组中有多条信息，请按照格式: "姓名： XX， 年龄： XX"的格式将信息打印出来
  要求：
  把打印姓名的动作作为第一个Consumer接口的Lambda实例
  把打印年龄的动作作为第二个Consumer接口的Lambda实例
  将两个Consumer接口按照顺序组合到一起使用
   
• 示例

package ConsumerTest;

import java.util.function.Consumer;

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};

        printInfo(strArray,
                str -> System.out.println("姓名： " + str.split(",")[0]),
                str -> System.out.println(("年龄：") + Integer.parseInt(str.split(",")[1])));
    }

    private static void printInfo(String[] strArray, Consumer con1, Consumer con2) {
        for (String str : strArray) {
            con1.andThen(con2).accept(str);
        }
    }
}

1.8 常用函数接口之Predicate

• Predicate接口
  Predicate接口通常用于判断参数是否满足指定的条件

• 常用方法
  

• 示例

package PredicateDemo1;

import java.util.function.Predicate;

public class PredicateDemo1 {
    public static void main(String[] args) {
        boolean b1 = checkString("hello", s -> s.length() > 8);
        System.out.println(b1);

        boolean b2 = checkString("helloworld", s -> s.length() > 8);
        System.out.println(b2);
    }

    //
    private static boolean checkString(String s, Predicate pre) {
        // return !pre.test(s)
        return pre.negate().test(s);
    }
}

package PredicateDemo2;

import java.util.function.Predicate;

public class PredicateDemo2 {
    public static void main(String[] args) {
        boolean b1 = checkString("hello", s -> s.length() > 8);
        System.out.println(b1);

        boolean b2 = checkString("helloworld", s -> s.length() > 8);
        System.out.println(b2);

        boolean b3 = checkString("hello", s -> s.length() > 8, s -> s.length() < 15);
        System.out.println(b3);

        boolean b4 = checkString("helloworld", s -> s.length() > 8, s -> s.length() < 15);
        System.out.println(b4);

    }

    // 同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算，将该结果作为最终的结果返回
    private static boolean checkString(String s, Predicate pre1, Predicate pre2) {
        return pre1.or(pre2).test(s);
    }

    // 判断给定的字符串是否满足要求
    private static boolean checkString(String s, Predicate pre) {
        return pre.test(s);
    }
}

1.9 Predicate接口练习之筛选满足条件数据

• 练习描述
  String[] strArray = {"Alice,13", "Bob,12","Claire 15"}
  字符串数组中有多条信息，请通过Predicate接口的拼接将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
  同时满足如下要求： 姓名长度大于3；年龄大于13

• 分析
  有两个判断条件，所以需要使用两个Predicate接口，对条件进行判断
  必须同时满足两个条件，所以可以使用and方法连接两个判断条件

• 示例

package PredicateTest;

import java.util.ArrayList;
import java.util.function.Predicate;

public class PredicateTest {
    public static void main(String[] args) {
        String[] strArray = {"Alice,13", "Bob,12", "Claire 15"};

        ArrayList arr = myFilter(strArray, s -> s.split(",")[0].length() > 2,
                s -> Integer.parseInt(s.split(",")[1] > 13));

        for (String str : arr) {
            System.out.println(str);
        }
    }

    // 通过Predicate接口的拼装将符和要求的字符串筛选到集合ArrayList中
    private static ArrayList myFilter(String[] strArr,
                                              Predicate pre1,
                                              Predicate pre2) {
        // 定义一个集合
        ArrayList array = new ArrayList();
        
        // 遍历数组
        for (String str : strArr) {
            if (pre1.add(pre2).test(str)) {
                array.add(str);
            }
        }
        return array;
    }
}

1.10 常用函数接口之Function

• Function皆苦
  Funcation接口通常用于对参数进行处理，转换（处理逻辑由Lambda表达式实现），然后返回一个新的值

• 常用方法
  

• 示例

package FunctionDemo;

import java.util.function.Function;

public class FuncitonDemo {
    public static void main(String[] args) {
        // 操作一
        convert("100", s -> Integer.parseInt(s));
        // 操作二
        convert(100, i -> String.valueOf(i + 666));

        // 使用andThen的方式连续执行两个操作
        convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 666));
    }

    // 定义一个方法，把一个字符串转换成int类型，在控制台输出
    private static void convert(String s, Function fun) {
        // Integer i = fun.apply(s);
        int i = fun.apply(s);
        System.out.println(i);
    }

    // 定义一个方法，把一个int类型的数据加上一个整数后，转为字符串在控制台输出
    private static void convert(int i, Function fun) {
        String s = fun.apply(i);
        System.out.println(s);
    }
    
    // 定义一个方法，把一个字符串转换成int类型，把int类型的数据加上一个整数后，转为字符在控制台输出
    private static void convert(String s, Function fun1, Function fun2) {
        String ss = fun1.addThen(fun2).apply(s);
        System.out.println(ss);
    }
}

1.11 Function接口练习之按照指定要求操作数据

• 练习描述
  String s = "Alice，13"
  请按照指定的要求进行操作：
  将字符串截取得到的数字年龄部分
  将上一步的年龄字符串转换成int类型的数据
  将上一步的int数据加70，得到一个int结果，在控制台输出
  通过Function接口来实现函数拼接

• 示例

package FunctionTest;

import java.util.function.Function;

public class FunctionTest {
    public static void main(String[] args) {
        String s = "Alice, 14";
        convert(s, ss -> ss.split(",")[1], Integer::parseInt, i -> i + 70);
    }

    private static void convert(String s, Function func1,
                                Function func2, Function fun3) {
        int i = fun1.andThen(func2).andThen(func3).apply(s);
        System.out.println(i);
    }
}

0x02 Stream流

2.1 Stream流原理

• 需求
  按照下面的要求完成集合的创建和遍历
  创建一个集合，存储多个字符串元素
  把集合中所有以“A”开头的元素存储到一个新的集合
  把“A”开头的集合中长度为5的元素存储到一个新的集合
  遍历上一步得到的集合

• 示例

package StreamDemo;

import java.sql.SQLSyntaxErrorException;
import java.util.ArrayList;

public class StreamDemo {
   public static void main(String[] args) {
       // 创建一个集合，存储多个字符串元素
       ArrayList list = new ArrayList();

       list.add("Aio");
       list.add("Archer");
       list.add("Ajax");
       list.add("Alice");
       list.add("Bob");
       list.add("Beta");
       list.add("Charlie");

       // 把集合中所有以A开头的元素存储到一个新的集合
       ArrayList Alist = new ArrayList();

       for(String s: Alist) {
           if(s.startsWith("A")) {
               Alist.add(s);
           }
       }
       System.out.println(Alist);
       System.out.println("---------");

       // 把Alist内长度大于3的元素存储到一个新的结合
       ArrayList A3list = new ArrayList();
       for(String s: Alist) {
           if(s.length() > 3) {
               A3list.add(s);
           }
       }
       System.out.println(A3list);
       System.out.println("---------");

       // Stream流改进
       list.stream().filter(s -> s.startsWith("A")).filter(s -> s.length() > 3).forEach(s -> System.out.println(s));
       list.stream().filter(s -> s.startsWith("A")).filter(s -> s.length() > 3).forEach(System.out::println);
   }
}

• Stream流的好处
  直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流，过滤A，过滤长度为5，逐一打印
  Stream流把真正的函数式编程风格引入Java中

2.2 Stream流的常见生成方式

• Stream流的思想
  获取流，过滤A，过滤长度为5，逐一打印

• 生成Stream流的方式
  Collection体系集合
  使用默认方法stream()生成流，default Stream stream()
  Map体系集合
  把Map转成Set集合，间接的生成流
  数组
  通过Stream接口的静态方法of(T ...values)生成流

• 示例

package StreamDemo2;

import java.util.*;
import java.util.stream.Stream;

public class StreamDemo2 {
    public static void main(String[] args) {
        // Collection体系的集合可以用默认方法stream()生成流
        List list = new ArrayList();
        Stream listStream = list.stream();

        Set set = new HashSet();
        Stream setStream = set.stream();

        // Map体系的集合间接的生成流
        Map map = new HashMap();
        Stream keyStream = map.keySet().stream();
        Stream valueStream = map.values().stream();
        Stream> entryStream = map.entrySet().stream();

        // 数组可以通过Stream接口的静态方法of(T... values)生成流
        String[] strArray = {"Hello", "world", "Java"};
        Stream strArrayStream = Stream.of(strArray);
        Stream strArrayStream2 = Stream.of("Hello", "world", "Java");
        Stream intStream = Stream.of(10, 20, 30);
        
    }
}

2.3 Stream流中间操作方法

• 概念
  中间操作的意思，执行完此方法后，Stream流依然剋继续执行其他操作

• 常见方法
  

• filter示例

package StreamDemo4;

import java.util.ArrayList;

public class StreamDemo4 {
    public static void main(String[] args) {
        // 创建一个集合，存储多个字符串元素
        ArrayList list = new ArrayList();

        list.add("Aio");
        list.add("Archer");
        list.add("Ajax");
        list.add("Alice");
        list.add("Bob");
        list.add("Beta");
        list.add("Charlie");
        
        // 需求1： 把list集合中以A开头的元素在控制台输出
        list.stream().filter(s -> s.startsWith("A")).forEach(System.out::println);
        
        // 需求2：把list集合中长度为3的元素在控制台输出
        list.stream().filter(s -> s.length() > 3).forEach(System.out::println);
        
        // 需求3： 把list集合中以A开头且长度为3的元素在控制台输出
        list.stream().filter(s -> s.startsWith("A")).filter(s -> s.length() > 3).forEach(System.out::println); 
    }
}

• limit&skip示例

package StreamDemo3;

import java.util.ArrayList;

public class StreamDemo3 {
    public static void main(String[] args) {
        // 创建一个集合，存储多个字符串元素
        ArrayList list = new ArrayList();

        list.add("Aio");
        list.add("Archer");
        list.add("Ajax");
        list.add("Alice");
        list.add("Bob");
        list.add("Beta");
        list.add("Charlie");
        
        // 需求1： 取前3个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("---------");
        
        // 需求2：跳过3个元素，把剩下的元素在控制台输出
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("----------");
        
        // 需求3：跳过2个元素，把剩下的元素中前2个在控制台输出
        list.stream().skip(2).limit(3).forEach(System.out::println);
        
    }
}

• concat&distinct示例

package StreamDemo5;

import java.util.ArrayList;
import java.util.stream.Stream;

public class StreamDemo5 {
    public static void main(String[] args) {
        // 创建一个集合，存储多个字符串集合
        ArrayList list = new ArrayList();

        list.add("Aio");
        list.add("Archer");
        list.add("Ajax");
        list.add("Alice");
        list.add("Bob");
        list.add("Beta");
        list.add("Charlie");

        // 需求1： 取前4个数据组成一个流
        Stream s1 = list.stream().limit(4);

        // 需求2：跳过2个数据组成一个流
        Stream s2 = list.stream().skip(2);

        // 需求3：合并需求1和需求2得到的流，并把结果在控制台输出
        Stream.concat(s1, s2).forEach(System.out::println);

        // 需求4： 合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串不能重复
        Stream.concat(s1, s2).distinct().forEach(System.out::println);

    }
}

• sorted示例

package StreamDemo6;

import java.util.ArrayList;

public class StreamDemo6 {
    public static void main(String[] args) {
        // 创建一个集合，存储多个字符串集合
        ArrayList list = new ArrayList();

        list.add("Aio");
        list.add("Archer");
        list.add("Ajax");
        list.add("Alice");
        list.add("Bob");
        list.add("Beta");
        list.add("Charlie");

        // 需求1：按照字母顺序把数据在控制台输出
        list.stream().sorted().forEach(System.out::println);

        // 需求2：按照字符串长度把数据在控制台输出
        list.stream().sorted((s1, s2) -> {
            int num = s1.length() - s2.length();
            int num2 = num == 0 ? s1.compareTo(s2) : num;
            return num2;
        }).forEach(System.out::println);
    }
}

• map&mapToInt示例

package StreamDemo7;

import java.util.ArrayList;

public class StreamDemo7 {
    public static void main(String[] args) {
        // 创建一个集合，存储多个字符串元素
        ArrayList list = new ArrayList();

        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");
        list.add("60");

        // 需求：将集合中的字符串数据转换为整数后在控制台输出
        list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
        list.stream().map(Integer::parseInt).forEach(System.out::println);
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);

        // int sum()  返回此流中元素的总和
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);
    }
}

2.4 Stream流终结操作方法

• 概念
  终结操作的意思，执行完此方法后，Stream流将不能再执行其他操作

• 常见方法
  

• 示例

package StreamDemo8;

import java.util.ArrayList;

public class StreamDemo8 {
    public static void main(String[] args) {
        // 创建一个集合，存储多个字符串集合
        ArrayList list = new ArrayList();

        list.add("Aio");
        list.add("Archer");
        list.add("Ajax");
        list.add("Alice");
        list.add("Bob");
        list.add("Beta");
        list.add("Charlie");

        // 需求1：把集合中的元素在控制台输出
        list.stream().forEach(System.out::println);

        // 需求2：统计集合中有几个以A开头的元素，并把统计结果输出在控制台
        long count = list.stream().filter(s -> s.startsWith("A")).count();
        System.out.println(count);

    }
}

2.5 Stream流综合练习

• 需求
  现有两个ArrayList集合，分别存储6个男性和6名女性，要求完成如下操作

  • 男性只要名为为4个字的前三位
  • 女性只要姓林的，且不要第一个
  • 把过滤后的男性和女性名字拼接到一起
  • 把上一步操作后的元素作为构造方法的参数创建对象，遍历数组
  • 演员Actor类已提供

• 示例

package StreamTest;

import java.util.ArrayList;
import java.util.stream.Stream;

public class StreamTest {
    public static void main(String[] args) {
        // 创建集合
        ArrayList manList = new ArrayList();
        manList.add("周润发");
        manList.add("成龙");
        manList.add("刘德华");
        manList.add("吴京");
        manList.add("周星驰");
        manList.add("李连杰");

        ArrayList womanList = new ArrayList();
        womanList.add("林心如");
        womanList.add("张曼玉");
        womanList.add("林青霞");
        womanList.add("柳岩");
        womanList.add("林志玲");
        womanList.add("王祖贤");
        
        /*
        // 男演员只要名字为3个字的前三人
        Stream manStream = manList.stream().filter(s -> s.length() > 3).limit(3);

        // 女演员只要姓林的，并且不要第一个
        Stream womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);

        // 把过滤后的男演员和女演员合并到一起
        Stream stream = Stream.concat(manStream, womanStream);
        
        // 把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
        stream.map(Actor::new).forEach(System.out::println);
        Stream.map(Actor::new).forEach(p -> System.out.println(p.getName()));
        
         */
        Stream.concat(manList.stream().filter(s -> s.length() == 3).limit(3), s.startsWith("林")).
                skip(1)).map(Actor::new).forEach(p -> System.out.println(p.getName()));
    }
}

2.6 Stream流的收集操作

• 概念
  对数据使用Stream流的方式操作完毕后，可以把流中的数据收集到集合中

• 常用方法
  

• 工具类Collector提供了具体的收集方式
  

• 示例

package CollectDemo;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class CollectDemo {
    public static void main(String[] args) {
        // 创建List集合对象
        List list = new ArrayList();

        list.add("Alice");
        list.add("Bob");
        list.add("Charlie");
        list.add("Delta");

        // 需求1： 得到名字为3个字的流
        Stream listStream = list.stream().filter(s -> s.length() == 3);

        // 需求2：把使用Stream流操作完毕的数据
        List names = listStream.collect(Collectors.toList());
        for (String name : names) {
            System.out.println(name);
        }

        // 创建Set集合对象
        Set set = new HashSet();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(40);
        set.add(50);
        set.add(60);

        // 需求3： 得到年龄大于25的流
        Stream setStream = set.stream().filter(age -> age > 25);

        // 需求4： 把使用Stream流操作完毕的数据收集到Set集合并遍历
        Set ages = setStream.collect(Collectors.toSet());
        for (Integer age : ages) {
            System.out.println(age);
        }

        // 定义一个字符串数组，每个字符串数组由姓名和年龄组合而成
        String[] strArray = {"Alice, 13", "Bob, 14", "Charlie, 13", "Doggie, 15"};

        // 需求5： 得到的字符串中年林个大雨13的流
        Stream arrayStream = Stream.of(strArray).filter
                (s -> Integer.parseInt(s.split(",")[1]) > 13);

        // 需求6： 把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名做键，年龄为值
        Map map = arrayStream.collect(Collectors.toMap(s -> s.split(",")[0],
                s -> Integer.parseInt(s.split(",")[1])));

        Set keySet = map.keySet();
        for (String key : keySet) {
            Integer value = map.get(key);
            System.out.println(key + ", " + value);
        }
    }
}