函数式接口和Stream流的完美搭配

1.函数式接口

函数式接口：有且仅有一个抽象方法的接口

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

/*
定义一个类（RunnableDemo），在类中提供两个方法
	一个方法是：startThread(Runnable r) 方法参数Runnable是一个函数式接口
	一个方法是主方法，在主方法中调用startThread方法
*/

public class RunnableDemo {
    public static void main(String[] args) {
        //匿名内部类
        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){
        //Thread t = new Thread(r,"stratThread");
        //t.start();
        new Thread(r,"stratThread").start();
    }
}
运行结果：stratThread启动了

如果方法的参数是函数式接口，我们可以使用Lambda表达式作为参数传递

• startThread(()->System.out.println(Thread.currentThread().getName()+“启动了”));

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

/*
    定义一个类（ComparatorDemo），在类中提供两个方法
        一个方法是：Comparator<String> getComparator()    方法返回值Comparator是一个函数式接口
        一个方法是主方法：在主方法中调用getComparator()方法

    需求：比较字符串的长度，按照长短来排序
 */

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

public class ComparatorDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("aaaa");
        list.add("bbb");
        list.add("sss");
        list.add("c");
        list.add("cddf");

        System.out.println(list); //排序前
        Collections.sort(list,getComparator());//第一个参数是集合对象，第二个参数是比较器
        System.out.println(list); //排序后
    }

    //当函数式接口作为方法的返回值时，返回的是接口的实现类对象
    private static Comparator<String> getComparator() {
        //使用匿名内部类返回一个Comparator对象
        /*Comparator c = new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        };
        return c;*/
        
       /* return new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        };*/
        //Lambda表达式
        return (s1, s2) -> s1.length() - s2.length();
    }
}

1.4 常用函数式接口

1.4.1 Supplier接口

Supplier接口主要是用来生产数据的，包含一个无参的方法

• T get(): 获得结果
• 该方法不需要参数，它会按照某种实现逻辑（有Lambda表达式实现）返回一个数据。
• Supplier接口也被称为生产型接口，如果我们指定了接口的泛型什么类型，那么接口中的get方法就会返回什么类型的数据给我们使用。

import java.util.Arrays;
import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
        Integer[] arr = {12,43,22,67,34,99};

        //使用匿名内部类
        /*Integer max = getMax(new Supplier<Integer>() {
            @Override
            public Integer get() {
                Arrays.sort(arr);
                return arr[arr.length - 1];
            }
        });
        */
        //Lambda表达式
        Integer max = getMax(()->{
            Arrays.sort(arr);
            return arr[arr.length - 1];
        });
        System.out.println(max);
    }

    //使用Supplier接口作为参数，获取数组中的最大值
    private static Integer getMax(Supplier<Integer> s){
        return s.get();
    }
}
运行结果： 99

1.4.2 Consumer接口

Consumer：包含两个方法

• void accept(T t)：对给定的参数执行此操作
• default Consumer andThen(Consumer after)：返回一个组合的Consumer，依次执行此操作，然后执行after操作
• Consumer接口也被称为消费型接口，它消费的数据的数据类型由泛型指定

使用accept(T t)

public class ConsumerDemo {
    public static void main(String[] args) {
        String[] strings = {"路飞,19","索隆,22","山治,21","娜美,19"};

        //使用匿名内部类
        /*useString(strings, new Consumer<String>() {
            @Override
            public void accept(String s) {
                String[] split = s.split(",");
                System.out.println("姓名；"+split[0]+",年龄："+split[1]);
            }
        });*/

        //Lambda表达式
        useString(strings,s-> System.out.println("姓名；"+s.split(",")[0]+",年龄："+s.split(",")[1]));
        
    }
    /**
     * @param strarr
     * @param con
     */
    private static void useString(String[] strarr, Consumer<String> con){
        //遍历数组获取元素，用于消费
        for (String s : strarr) {
            con.accept(s);//将String[] strarr集合中的元素依次取出，用于消费
        }
    }
}
运行结果：姓名；路飞,年龄：19
        姓名；索隆,年龄：22
        姓名；山治,年龄：21
        姓名；娜美,年龄：19

使用Consumer andThen(Consumer after)

public class ConsumerDemo {
    public static void main(String[] args) {
        String[] strings = {"路飞,19","索隆,22","山治,21","娜美,19"};
        //使用两个Consumer接口对象的方法
        //匿名内部类
       /* useString2(strings, new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.print("姓名；"+s.split(",")[0]);
            }
        }, new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(",年龄："+s.split(",")[1]);
            }
        });
*/
        //Lambda表达式
        useString2(strings,
                   s ->System.out.print("姓名；"+s.split(",")[0]),
                   s -> System.out.println(",年龄："+s.split(",")[1])
                  );
    }

    /**
     * @param strarr
     * @param con1
     * @param con2
     * 使用 andThen 方法将 Consumer 对象串联起来能够连续执行，消费同一个对象
     */
    private static void useString2(String[] strarr,Consumer<String> con1,Consumer<String> con2){
        for (String s : strarr) {
            con1.andThen(con2).accept(s);//使用两个Consumer对象对同一个s进行操作
        }
    }
}

1.4.3 Predicate接口

Predicate接口用于对参数进行判断是否满足指定条件

Predicate: 常用的四个方法

• boolean test(T t ): 对给定的参数进行判断（判断逻辑由Lambda表达式实现），返回一个布尔值
• default Predicate negate()：返回一个逻辑的否定，对应逻辑非
• default Predicate and(Predicate other): 返回一个组合的判断，对应短路与
• default Predicate or(Predicate other): 返回一个组合的判断，对应短路或

① test、negate方法使用

public class Demo {
    public static void main(String[] args) {

      /*  boolean result = usePredicate("hello", new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length()>8;
            }
        });*/

        boolean b1 = usePredicate("hello", s -> s.length()>8);
        System.out.println(b1);

        boolean b2 = usePredicate("hellowrold", s -> s.length() < 15);
        System.out.println(b2);
    }
    //

    //判断字符串是否满足条件
    private static boolean usePredicate(String str,Predicate<String> p){
//        boolean test = p.test(str);
//        return p.test(str);
        return p.negate().test(str);
    }
}
运行结果： true
    	 false

② and(Predicate other)、or(Predicate other)方法使用

public class Demo2 {
    public static void main(String[] args) {

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

    //同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算和逻辑或运算
    private static boolean checkString(String s, Predicate<String> p1, Predicate<String> p2) {
//        boolean b1 = p1.test(s);
//        boolean b2 = p2.test(s);
//        return b1&&b2;
        //使用and、or方法
//        return p1.and(p2).test(s);
        return p1.or(p2).test(s);
    }
}
运行结果：true

练习

• String[] strArr = {“林青霞,30”, “柳岩,43”, “张曼玉,35”, “貂蝉,28”, “王祖贤,33”};
• 字符串数组中有多条信息，请通过Predicate接口的拼装将符合条件的字符串筛选到集合ArrayList中，并遍历集合
• 同时满足如下要求：姓名长度大于2，年龄大于33

public class PredicateDemo1 {
    public static void main(String[] args) {
        String[] strArr = {"林青霞,30", "柳岩,43", "张曼玉,35", "貂蝉,28", "王祖贤,33"};

        //调用usePredicate方法
        //匿名内部类
       /* usePredicate(strArr, new Predicate<String>() {
            @Override
            public boolean test(String s) {//判断姓名长度是否大于3
                return s.split(",")[0].length() > 3;
            }
        }, new Predicate<String>() {
            @Override
            public boolean test(String s) {//判断年龄是否大于33
                return Integer.parseInt(s.split(",")[1]) > 33;
            }
        });*/

        //Lambda表达式
        usePredicate(strArr, 
                     s -> s.split(",")[0].length() > 2, //筛选姓名长度大于2的
                     s -> Integer.parseInt(s.split(",")[1]) > 33 //筛选年龄大于33的
                    );

    }

    private static void usePredicate(String[] strings, Predicate<String> pre1, Predicate<String> pre2) {
        //用于将存放满足条件的数据
        ArrayList<String> list = new ArrayList<>();

        //遍历字符串数组
        for (String string : strings) {
            boolean test = pre1.and(pre2).test(string);	//判断是否满足条件
            if (test) {//如果test为true，那么将strings放入list中
                list.add(string);
            }
        }

        //遍历ArrayList
        for (String s : list) {
            System.out.println(s);
        }
    }
}
运行结果：	张曼玉,35

1.4.4 Function接口

Function<T , R >接口通常用于对参数进行处理，转换（处理逻辑由Lambda表达式实现），然后返回一个新的值常用的两个方法

• R apply(T t)：将此函数应用于给定的参数
• default Function andThen(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果

public class Demo2 {
    public static void main(String[] args) {
        //定义一个方法，把一个字符串装换成int型，输出
//        convert("100",s->Integer.parseInt(s));

        //定义一个方法，把一个int型数据加上一个值后转成字符串，输出
//        convert(12,integer -> String.valueOf(integer+21));

        //定义一个方法，把一个字符串转换成int型，把int型的数据加上一个整数后，转为字符串输出
        convert("12", s -> Integer.parseInt(s), i -> String.valueOf(i + 21));
    }

    //定义一个方法，把一个字符串转换成int型，把int型的数据加上一个整数后，转为字符串输出
    private static void convert(String s, Function<String, Integer> f1, Function<Integer, String> f2) {
//        Integer i = f1.apply(s);
//        String ss = f2.apply(i);
//        System.out.println(ss);
        String apply = f1.andThen(f2).apply(s);
        System.out.println(apply);
    }

    //定义一个方法，把一个int型数据加上一个值后转成字符串，输出
    private static void convert(Integer i, Function<Integer, String> f) {
        String result = f.apply(i);
        System.out.println(result);
    }

    //定义一个方法，把一个字符串装换成int型，输出
    private static void convert(String s, Function<String, Integer> f) {
        Integer result = f.apply(s);
        System.out.println(result);
    }
}

2.Stream流

2.1 Stream流的生成方法

• Collection体系的集合可以使用默认方法stream()生成流

  ​ default Stream stream()

• Map体系的集合间接地生成流

• 数组可以通过Stream接口的静态方法of(T…values)生成流

public class Demo2 {
    public static void main(String[] args) {
        //Collection体系可以使用默认方法stream（）生成流
        List<String> list = new ArrayList<>();
        Stream<String> listStream = list.stream();

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

        //Map体系的集合间接地生成流
        Map<String,Integer> map = new HashMap<>();
        Stream<String> keyStream = map.keySet().stream();
        Stream<Integer> vlaueStream = map.values().stream();

        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

        //数组可以通过Stream接口的静态方法of(T...values)生成流
        String[] strArray = {"hello","world","java"};
        Stream<String> strArray1 = Stream.of(strArray);
        Stream<String> strArray2 = Stream.of("hello", "world", "java");


    }
}

2.2 Stream流常见中间操作方法

2.1.1 filter(Predicate p)

Stream filter (Predicate predicate)：用于对流中的数据进行过滤

​ Predicate 接口中的方法 Boolean test(T t)：对给定的参数进行判断，返回一个布尔值

public class Demo1 {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("张三");
        names.add("张曼玉");
        names.add("张无忌");
        names.add("林青霞");
        names.add("张开泰");
        names.add("王五");
		//筛选除姓张的
        ArrayList<String> zhangs = new ArrayList<>();
        for (String name : names) {
            if(name.startsWith("张")){
                zhangs.add(name);
            }
        }
		//在姓张的基础上筛选出姓名长度等于3的
        ArrayList<String> three = new ArrayList<>();
        for (String zhang : zhangs) {
            if(zhang.length()==3){
                three.add(zhang);
            }
        }
		//输出最终结果
        for (String s : three) {
            System.out.println(s);
        }

        System.out.println("----------");
        //使用stream流编程
        names.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(System.out::println);
        /**
         * names.stream(): 生成stream流对象
         * filter(s->s.startsWith("张"))：过滤出以“张”开头的字符串
         * filter(s->s.length()==3)：在上一个条件的基础上，过滤出名字长度为三的字符串
         * forEach(System.out::println)：使用方法引用输出最终结果
         */

    }
}

2.1.2 limit(long n)

Stream limit(long n)：返回截取的前 n 个元素组成的流

2.1.3 skip(long n)

Stream skip(long n)：跳过指定参数个数的元素，返回剩下元素组成的流

public class Demo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("宋七");
        list.add("刘九");

        //输出前4个元素
        list.stream().limit(4).forEach(System.out::println);

        System.out.println("----------");
        //跳过前2个，输出剩余的
        list.stream().skip(2).forEach(System.out::println);

        System.out.println("----------");
        //跳过前2个，输出剩余元素中的前2个
        list.stream().skip(2).limit(2).forEach(System.out::println);
    }
}
运行结果：	 张三
            李四
            王五
            赵六
            ----------
            王五
            赵六
            宋七
            刘九
            ----------
            王五
            赵六

2.1.4 concat(Stream a, Stream b)

Static Stream concat(Stream a, Stream b)：合并a和b两个流为一个流

2.1.5 distinct（）

Stream distinct（）：返回该流的不同元素（根据 Object.equals(Object o)）组成的流

public class Demo4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("宋七");
        list.add("刘九");

        //需求1：取出前4个元素组成一个流
        Stream<String> stream1 = list.stream().limit(4);

        //需求2：跳过前2个，剩余的组成一个流
        Stream<String> stream2 = list.stream().skip(2);

        //需求3：将上面的两个流组合成一个流,并输出
//        Stream.concat(stream1, stream2).forEach(System.out::println);

        //需求4：合并需求1和需求2的流，并去除重复元素输出
        Stream.concat(stream1, stream2).distinct().forEach(System.out::println);

    }
}

2.1.6 sorted()

Stream sorted(): 返回由此流的元素组成的流，自然排序

Stream sorted(Comparator comparator)：返回由此流的元素组成的流，根据提供的Comparator进行排序

public class Demo5 {
    public static void main(String[] args) {
        ArrayList<String> list  = new ArrayList<>();
        list.add("aas");
        list.add("acbds");
        list.add("sccd");
        list.add("cbffe");
        list.add("scce");

        //需求1：按照自然排序输出
//        list.stream().sorted().forEach(System.out::println);

        //需求2：按照字符串长度排序
//        list.stream().sorted((s1, s2) -> s1.length()-s2.length()).forEach(System.out::println);

        //需求3：按照长度排序，如果长度相同，那么再比较字母
        list.stream().sorted((s1,s2)->{
            int num = s1.length()-s2.length();
            return num==0?s1.compareTo(s2):num;
        }).forEach(System.out::println);
    }
}
运行结果：	 aas
            sccd
            scce
            acbds
            cbffe

2.1.7 map(Function m)

Stream map(Function m): 返回由给定函数应用于此流的元素的结果组成的流

• Function 接口中的方法 apply(T t)

2.1.8 mapToInt(ToIntFunction m)

IntStream mapToInt(ToIntFunction m): 返回一个IntStream 其中包含将给定函数应用于此流的元素的结果

IntStream接口

• int sum() 返回此流中元素的总和。

public class Demo6 {
    public static void main(String[] args) {
        //创建一个集合
        ArrayList<String> list = new ArrayList<>();
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("6");
        list.add("7");

        //需求1：将字符串转变成整数在控制台输出
//        list.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
//        list.stream().map(Integer::parseInt).forEach(System.out::println);

        //int sum() 返回此流中元素的总和。
        int sum = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(sum);
        //list.stream()生成一个stream流
        //mapToInt(Integer::parseInt) 返回一个IntStream流
        //sum()调用IntStream流的特有方法求和，返回一个整型
    }
}

2.3 Stream流的常见终结操作

• void forEach(Consumer action): 遍历元素并执行相应的操作

  ​ Consumer 接口中的方法 void accept(T t)：对给定的参数执行操作

• long count(): 返回此流中的元素个数

public class Demo7 {
    public static void main(String[] args) {
        ArrayList<String > list = new ArrayList<>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("赵敏");
        list.add("张天爱");

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

        //需求2：统计集合中姓名以“张”开头的个数，并把统计结果在控制台输出
        long count = list.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(count);
    }
}
运行结果： 3

综合练习

/*
    现有两个ArrayList集合，分别存储6名男演员名称和女演员名称，要求完成以下操作：
        男演员只要名字为三个字的前三人
        女演员只要姓林的并且不要第一个
        把过滤后的男演员姓名和女演员姓名合并到一起
        把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
            演员类Actor已经提供，里面有一个成员变量，一个带参构造，以及get、set方法
 */

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

class Actor {
    private String name;
    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Actor{" +
                "name='" + name + '\'' +
                '}';
    }

    public void setName(String name) {
        this.name = name;
    }

    public Actor(String name) {
        this.name = name;
    }
}

public class Test_02 {
    public static void main(String[] args) {
        ArrayList<String> maleList = new ArrayList<>();
        ArrayList<String> femaleList = new ArrayList<>();

        maleList.add("周润发");
        maleList.add("周星驰");
        maleList.add("张国荣");
        maleList.add("葛优");
        maleList.add("吴京");
        maleList.add("李连杰");

        femaleList.add("王祖贤");
        femaleList.add("林心如");
        femaleList.add("林青霞");
        femaleList.add("赵敏");
        femaleList.add("巩俐");
        femaleList.add("林黛玉");

        //男演员只要名字为三个字的前三人
        Stream<String> manStream = maleList.stream().filter(s -> s.length() == 3).limit(3);
        
        //女演员只要姓林的并且不要第一个
        Stream<String> womanStream = femaleList.stream().filter(s -> s.startsWith("林")).skip(1);

        //把过滤后的男演员姓名和女演员姓名合并到一起
        Stream<String> concatStream = Stream.concat(manStream, womanStream);

        //把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
        concatStream.map(s->new Actor(s)).forEach(System.out::println);
//        concatStream.map(Actor::new).forEach(a-> System.out.println(a.getName()));
    }
}
运行结果：	 Actor{name='周润发'}
            Actor{name='周星驰'}
            Actor{name='张国荣'}
            Actor{name='林青霞'}
            Actor{name='林黛玉'}

2.4 Stream 流的收集操作

对数据使用Stream流的方式操作完毕后，我想把流中的数据收集到集合中，该怎么办？

stream流的收集方法

• R collect（Collector collector）
• 但是这个收集方法的参数是一个Collector 接口

工具类Collectors 提供了具体的收集方法

• public static Collector toList(): 把元素收集到List集合中
• public static Collector toSet(): 把元素收集到Set集合中
• public static Collector toMap(Function keyMap, Function valueMap): 把元素收集到Map集合中

public class Demo8 {
    public static void main(String[] args) {
        //创建List集合
        List<String> list = new ArrayList<>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("赵敏");

        //需求1：得到名字长度为3的流
        Stream<String> lenStream = list.stream().filter(s -> s.length() == 3);
        //需求2：把上一步得到的流中的数据收集到List集合中,并遍历
        List<String> names = lenStream.collect(Collectors.toList());
        names.forEach(System.out::println);

        //创建Set集合
        Set<Integer> set = new HashSet<>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(40);

        //需求3：得到数字大于20的流
        Stream<Integer> num = set.stream().filter(i -> i > 20);
        //需求4：把上一步得到的流中的数据收集到Set集合中,并遍历
        Set<Integer> numStream = num.collect(Collectors.toSet());
        numStream.forEach(System.out::println);

        //定义一个字符串数组，每一个元素由姓名和年龄组合而成
        String[] strArray = {"魍魉,12","梅花十三,20","西凉,22","精卫,18"};

        //需求5：得到字符串中年龄大于18的流
        Stream<String> stringStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 18);

        //需求6：把上一步中得到的流存储到Map集合中，其中名字做键，年龄做值
        Map<String, String> student = stringStream.collect(Collectors.toMap(s -> s.split(",")[0], s -> s.split(",")[1]));

        //遍历集合
        Set<Map.Entry<String, String>> entries = student.entrySet();
        entries.forEach(s-> System.out.println("姓名："+s.getKey()+",年龄："+s.getValue()));

    }
}
运行结果：	 林青霞
            张曼玉
            王祖贤
            40
            30
            姓名：西凉,年龄：22
            姓名：梅花十三,年龄：20