Java学习——函数式接口

一 概述

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

PS：以下几种情况下，有多个方法但是不报错：

• default方法：接口中所定义的方法式默认方法，使用default修饰，有其默认实现。
• 静态方法，因为静态方法不能是抽象方法，而是一个已经实现了的方法。
• 继承来自 Object 类的public方法，因为任何一个接口或类都继承了 Object 的方法

共同特点：都已实现

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

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

package day214;

public class RunnableDemo {
    public static void main(String[] args) {
        //匿名内部类
//        startThread(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName()+"线程启动了");
//            }
//        });

//    函数式接口作为方法的参数
        startThread(() -> System.out.println(Thread.currentThread().getName()+"启动了"));
    }

    private static void startThread(Runnable r){
//        Thread t = new Thread(r);
//        t.start();

        new Thread(r).start();
    }
}

Runnable是一个函数式接口

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

如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回

public class ComparatorDemo {
    public static void main(String[] args) {
//         构造使用场景
        //定义集合，存储字符串元素
        ArrayList<String> arrayList = new ArrayList<String>();

        arrayList.add("ccc");
        arrayList.add("a");
        arrayList.add("bb");

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

        Collections.sort(arrayList);

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

    }

    private static Comparator<String> getComparator(){
//Lambda表达式
        return (s1,s2)->s1.length()-s2.length();
    }
}

四 常用的函数式接口

1.Supplier接口

功能方法——一个无参的方法  T get():获得结果

Supplier<T> 接口也被成为生产型接口，会生产出T类型的数据供我们使用

2.ConSumer接口

Consumer<T>

• void accept(T t):对给定的参数执行此操作
• default Consumer<T> andThen(Consumer after):

package day214;

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {
//        operateorString("zt",(String s)->{
//            System.out.println(s);
//        });
        operateorString("zt",s -> System.out.println(s));
        operateorString("zt",System.out::println);

        operateorString("zt",s -> {
            System.out.println(new StringBuilder(s).reverse().toString());
        });

        operateorString("zt",s -> System.out.println(new StringBuilder(s).reverse().toString()));
        System.out.println("-------");

        operateorString("ztxh",s-> System.out.println(s),
                s -> System.out.println(new StringBuilder(s).reverse().toString()));

    }
//    定义一个方法，用不同的方式消费同一个字符串数据两次
    private static void operateorString(String name,Consumer<String> con1,Consumer<String> con2){
//        con1.accept(name);
//        con2.accept(name);
        //等同于下面这句
        con1.andThen(con2).accept(name);//执行了2次
    }

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

输出结果：

zt
zt
tz
tz
-------
ztxh
hxtz

PS：我的理解：传入的是Consumer<T> 中T类型的字段，然后要执行的操作在调用时指定。

3.Predicate接口

Predicate<T> 常用的四个方法

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

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

4.Function接口

Function<T,R>：常用的两个方法

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

package day214;

import java.util.function.Function;


public class FunctionDemo {
    public static void main(String[] args) {
        convert("100",s -> {return Integer.parseInt(s);});
        convert("100",s -> Integer.parseInt(s));
        convert("100",Integer::parseInt);
    }

    private static void convert(String s, Function<String,Integer> fun){
        int i = fun.apply(s);
        System.out.println(i);
    }
}

5.Strem流

• list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length()==3)
          .forEach(System.out::println);

• 直接阅读代码，即可展示无关逻辑方式的语义：生成流、过滤姓张、过滤长度为3、逐一打印
• Stream流把真正的函数式编程风格引入到java中

1.Stream流的使用

• 生成流

              通过数据源（集合、数组等）生成流

              list.stream()

• 中间操作

              一个流后面可以跟随0个/多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用

              filter()

• 终结操作

              一个流只能有一个终结操作，当这个操作结束后，流就使用”光“了，无法再被操作

              forEach()

2.Stream流的常见生成方式

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

              default Stream<E> stream()

• Map体系的集合间接的生成流
• 数组可以通过Stream接口的静态方法of(T... values)生成流

  package day214;
  
  import java.util.*;
  import java.util.stream.Stream;
  
  /**
   * @date 2020/12/21
   */
  
  public class StreamDemo01 {
      public static void main(String[] args) {
          List<String> list = new ArrayList<String>();
          Stream<String> listStream = list.stream();
  
          Set<String> set = new HashSet<String>();
          Stream<String> setStream = set.stream();
  
          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();
  
          String[] strArray = {"hello","w","java"};
          Stream<String> strArrayStream = Stream.of(strArray);
          
          Stream<Integer> integerStream = Stream.of(10,20,30);
      }
  }
  

  常见中间操作方法

• Stream<T> filter(Predicate predicate): 过滤

• Stream<T> limit(long maxSize):截取前指定参数个数的数据

• Stream<T> skip(long n):跳过指定参数个数的数据，返回由该流的剩余元素组成的流

•  Stream<T> concat(Stream a,Stream b) 合并a和b两个流为一个流

• Stream<T> distinct() 返回由该流的不同元素（根据Object.equals(Object))组成的流

• Stream<T> sorted() 返回此流元素组成的流，根据自然顺序（字母）排序

• Stream<T> sorted(Comparator comparator):返回由该流的元素组成的流，根据提供的Comparator进行排序(在提供的规则相同时，按照添加顺序排序）

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

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

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

        IntStream ：表示原始int流   ToIntFunction接口中的方法     int  applyAsInt(T value)

常见终结操作方法

• void forEach(Consumer action):对此流的每个元素执行操作

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

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

Stream流的收集操作

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

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

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

仅学习记录，共同进步。