nineteen day("函数式接口","Stream流")

函数式接口

函数式接口就是指有且仅有一个抽象方法的接口
Java中的函数式编程体现就是Lambda表达式,所以函数式接口就是可以适用于Lambda使用的接口
只有确保接口中有且仅有一个抽象方法,Java中的Lambda才能顺利地进行推导

如何检测一个接口是不是函数式接口呢?

• 使用注解:@Functionallnterface
• 放在接口定义的上方:如果接口是函数式接口,编译通过;如果不是,编译失败

注意

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

常用的函数式接口

• Supplier接口
• Consumer接口
• Predicate接口
• Function接口

Supplier接口
Supplier:包含一个无参的方法

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

public class Demo {
    public static void main(String[] args) {
        String str = getSting(() -> "浮云知州");
        System.out.println(str);
    }
    public static String getSting(Supplier<String> sup){
        return sup.get();
    }
}

Consumer接口
Consumer:包含两个方法

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

public class Demo {
    public static void main(String[] args) {
        operatorString("床前明月光",System.out::println);
        operatorString("疑是银河落九天",System.out::println,s-> System.out.println(new StringBuilder(s).reverse().toString()));
    }
    public static void operatorString(String s, Consumer<String> con){
        con.accept(s);
    }
    public static void operatorString(String s, Consumer<String> con1,Consumer<String> con2){
        con1.andThen(con2).accept(s);
    }
}

Predicate接口
Predicate:常用的四个方法

• bollean test(T t):对给定的参数进行判断(判断逻辑由Lambda表达式实现),返回一个布尔值
• default Predicate negate():返回一个逻辑的否定,对应逻辑非
• default Predicate and(Predicate other):返回一个组合判断,对应短路与
• default Predicate or(Predicate other):返回一个组合判断,对应短路或
• Predicate接口通常用于判断参数是否满足指定的条件

public class Demo {
    public static void main(String[] args) {
        //判断字符串长度是否大于5
        boolean flag = checkString("asfsffa", s -> s.length() > 5);
        System.out.println(flag);
        //判断字符串长度是否大于5,并且字符串中是否包含z
        boolean flag2 =checkString("safasavw",s->s.length()>5,s->s.contains("z"));
        System.out.println(flag2);
    }

    public static boolean checkString(String s, Predicate<String> pre){
        return pre.test(s);
    }
    public static boolean checkString(String s, Predicate<String> pre1,Predicate<String> pre2){
        return pre1.and(pre2).test(s);
    }
}

Function接口
Function<T,R>:常用的两个方法

• R apply(T t):将此函数应用于给定的参数
• default Function andThen(Function after):返回一个组合函数,首先将该函数应用于输入,然后将after函数应用于结果
• Function<T,R>接口通常用于对参数进行处理,转换(处理逻辑由Lambda表达式实现),然后返回一个新的值

public class Demo {
    public static void main(String[] args) {
        convert("336",Integer::parseInt);
        convert("123",Integer::parseInt,s->String.valueOf(s+55));
    }
    //将字符串数字转换为数字
    public static void convert(String s, Function<String,Integer> fun){
        Integer num = fun.apply(s);
        System.out.println(num);
    }
    //将字符串数字转换为数字进行运算后,再转换为字符串数字
    public static void convert(String s,Function<String,Integer> fun1,Function<Integer,String> fun2){
        String str = fun1.andThen(fun2).apply(s);
        System.out.println(str);
    }
}

Stream流

Stream流的生成方式

Stream流的使用

• 生成流
  通过数据源(集合,数组等)生成流
  list.stream()
• 中间操作
  一个流后面可以跟随零个或多个中间操作,其目的主要是打开流,做出某种程度的数据过滤/映射,然后返回一个新的流,交给下一个操作使用
  filter()
• 终结操作
  一个流只能有一个终结操作,当这个操作执行后,流就被使用"光"了,无法再被操作,所以这必定是流的最后一个操作
  forEach()

Stream流的常见生成方式

• Collection体系的集合可以使用默认方法stream()生成流
• Map体系的集合间接的生成流
• 数组可以通过Stream接口的静态方法of(T…values)生成流

//Collection体系的集合通过使用默认方法stream()生成流
        ArrayList<String> str=new ArrayList<> ();
        Stream<String> liststream = str.stream();
        
        //Map集合生成流,需要将键和值分开生成流
        HashMap<Integer, String> map=new HashMap<> ();
        //键的流
        Stream<Integer> keystream = map.keySet().stream();
        //值的流
        Stream<String> valuestream = map.values().stream();
        
        //数组生成流
        String[] arr={"张三","李四","王五"};
        Stream<String> arrstream = Stream.of(arr);
        //传可变参数生成流
        Stream<Integer> integerStream = Stream.of(12, 13, 14);

Stream流的常见中间操作方法

• Stream filter(Predicate predicate):用于对流中的数据进行过滤
  Predicate接口中的方法 boolean test(T t):对给定的参数进行判断,返回一个布尔值
• Stream limit(long maxSize):返回此流中的元素组成的流,截取前指定参数个数的数据
• Stream skip(long n):跳过指定参数个数的数据,返回由该流的剩余元素组成的流
• static Stream concat(Stream a,Stream b):合并a和b两个流为一个流
• Stream distinct():返回由该流的不同元素(根据Object.equals(Object))组成的流
• Stream sorted():返回由此流的元素组成的流,根据自然顺序排序
• Stream sorted(Comparator comparator):返回由该流的元素组成的流,根据提供的Comparator进行排序
• Stream map(Function mapper):返回由给定函数应用于此流的元素的结果组成的流
  Function接口中的方法 R apply(T t)
• IntStream map ToInt(ToIntFunction mapper):返回一个IntStream其中包含将给定函数应用于此流的元素的结果
  IntStream:表示原始int流
  ToIntFunction接口中的方法 int applyAsInt(T value)

Stream流的常见终结操作方法
Stream流的常见终结操作方法

• void forEach(Consumer action):对此流的每个元素执行操作
  Consumer接口中的方法 void accept(T t):对给定的参数执行此操作
• long count():返回此流中的元素数

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

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

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

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

public class Demo {
    public static void main(String[] args) {
        ArrayList<String> array=new ArrayList<> ();
        array.add("afaf");
        array.add("av");
        array.add("agsfsa");
        array.add("sfasf");
        array.add("gafasgag");
        //把达到一定长度的字符串收集到一个新的集合
        List<String> list = array.stream().filter(s -> s.length() >= 5).collect(Collectors.toList());
        for (String s : list) {
            System.out.println(s);
        }
        Set<Integer> num=new HashSet<>();
        num.add(18);
        num.add(21);
        num.add(17);
        num.add(39);
        num.add(66);
        Set<Integer> set = num.stream().filter(age -> age > 20).collect(Collectors.toSet());
        for (Integer integer : set) {
            System.out.println(integer);
        }

        String[] peron={"张三,18","李四,22","王五,32"};
        Stream<String> stringStream = Stream.of(peron).filter(s -> Integer.parseInt(s.split(",")[1]) > 20);
        Map<String, String> map = stringStream.collect(Collectors.toMap(s -> s.split(",")[0], s -> s.split(",")[1]));
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key+","+map.get(key));
        }
    }
}