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

0x00 概述

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

0x01 函数式接口

1.1 函数式接口概述

概念有且仅有一个抽象方法的接口
如果检测一个接口是不是函数式接口 @FunctionalInterface 放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败
注意事项我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样式函数式接口。但是，建议加上该注解

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

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

代码语言：javascript复制

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()方法返回值
示例

代码语言：javascript复制

package ComparatorDemo;

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

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

        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<String> getComparator() {
        /*
        // 匿名内部类的方式实现
        return new Comparator<String>() {
            @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方法就会生产指定类型的数据供我们使用
常用方法只有一个无参的方法

示例

代码语言：javascript复制

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<Integer> sup) {
        return sup.get();
    }

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

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

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

代码语言：javascript复制

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<arr.length;i  ) {
                if(arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(maxValue);
    }

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

1.6 常用函数接口之Consumer

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

示例

代码语言：javascript复制

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<String> con1, Consumer<String> con2) {
        // con1.accept(name);
        // con2.accept(name);
        con1.andThen(con2).accept(name);
    }

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

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

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

代码语言：javascript复制

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<String> con1, Consumer<String> con2) {
        for (String str : strArray) {
            con1.andThen(con2).accept(str);
        }
    }
}

1.8 常用函数接口之Predicate

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

示例

代码语言：javascript复制

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<String> pre) {
        // return !pre.test(s)
        return pre.negate().test(s);
    }
}

代码语言：javascript复制

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<String> pre1, Predicate<String> pre2) {
        return pre1.or(pre2).test(s);
    }

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

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

练习描述 String[] strArray = {"Alice,13", "Bob,12","Claire 15"} 字符串数组中有多条信息，请通过Predicate接口的拼接将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合同时满足如下要求：姓名长度大于3；年龄大于13
分析有两个判断条件，所以需要使用两个Predicate接口，对条件进行判断必须同时满足两个条件，所以可以使用and方法连接两个判断条件
示例

代码语言：javascript复制

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<String> 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<String> myFilter(String[] strArr,
                                              Predicate<String> pre1,
                                              Predicate<String> pre2) {
        // 定义一个集合
        ArrayList<String> array = new ArrayList<String>();
        
        // 遍历数组
        for (String str : strArr) {
            if (pre1.add(pre2).test(str)) {
                array.add(str);
            }
        }
        return array;
    }
}

1.10 常用函数接口之Function

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

示例

代码语言：javascript复制

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<String, Integer> fun) {
        // Integer i = fun.apply(s);
        int i = fun.apply(s);
        System.out.println(i);
    }

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

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

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

代码语言：javascript复制

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<String, String> func1,
                                Function<String, Integer> func2, Function<Integer, Integer> fun3) {
        int i = fun1.andThen(func2).andThen(func3).apply(s);
        System.out.println(i);
    }
}

0x02 Stream流

2.1 Stream流原理

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

代码语言：javascript复制

package StreamDemo;

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

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

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

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

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

       // 把Alist内长度大于3的元素存储到一个新的结合
       ArrayList<String> A3list = new ArrayList<String>();
       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)生成流
示例

代码语言：javascript复制

package StreamDemo2;

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

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

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

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

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

2.3 Stream流中间操作方法

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

filter示例

代码语言：javascript复制

package StreamDemo4;

import java.util.ArrayList;

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

        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示例

代码语言：javascript复制

package StreamDemo3;

import java.util.ArrayList;

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

        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示例

代码语言：javascript复制

package StreamDemo5;

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

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

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

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

        // 需求2：跳过2个数据组成一个流
        Stream<String> 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示例

代码语言：javascript复制

package StreamDemo6;

import java.util.ArrayList;

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

        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示例

代码语言：javascript复制

package StreamDemo7;

import java.util.ArrayList;

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

        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流将不能再执行其他操作
常见方法

示例

代码语言：javascript复制

package StreamDemo8;

import java.util.ArrayList;

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

        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类已提供
示例

代码语言：javascript复制

package StreamTest;

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

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

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

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

        // 把过滤后的男演员和女演员合并到一起
        Stream<String> 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提供了具体的收集方式

示例

代码语言：javascript复制

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<String> list = new ArrayList<String>();

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

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

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

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

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

        // 需求4： 把使用Stream流操作完毕的数据收集到Set集合并遍历
        Set<Integer> 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<String> arrayStream = Stream.of(strArray).filter
                (s -> Integer.parseInt(s.split(",")[1]) > 13);

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

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

编程算法 serverless java

0 人点赞