一，函数式接口

1.1　概念

函数式接口在Java中是指：有且仅有一个抽象方法的接口。

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

• 备注：
  • “语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实
  • 底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部
  • 类的“语法糖”，但是二者在原理上是不同的。

1.2　格式

只要确保接口中有且仅有一个抽象方法即可：

修饰符 interface 接口名称 {
    public abstract 返回值类型 方法名称(可选参数信息);
    // 其他非抽象方法内容
}

接口当中抽象方法的 public abstract 是可以省略的，所以定义一个函数式接口很简单

public interface MyFunctionalInterface {
    void myMethod();
}

1.3　@FunctionalInterface注解

与 @Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解： @FunctionalInterface 。该注解可用于一个接口的定义上：

1.4　自定义函数式接口

对于刚刚定义好的 MyFunctionalInterface 函数式接口，典型使用场景就是作为方法的参数：

public class Demo09FunctionalInterface {
    // 使用自定义的函数式接口作为方法参数
    private static void doSomething(MyFunctionalInterface inter) {
        inter.myMethod(); // 调用自定义的函数式接口方法
    }
    public static void main(String[] args) {
        // 调用使用函数式接口的方法
        doSomething(() ‐> System.out.println("Lambda执行啦！"));
    }
}

二，常用函数接口

Supplier-生产型接口

• Supplier接口

  Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用。

常用方法

只有一个无参的方法

• 代码演示

  public class SupplierDemo {
      public static void main(String[] args) {
  ​
          String s = getString(() -> "林青霞");
          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();
      }
  ​
  }

Consumer-消费型接口

• Consumer接口

  Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定

常用方法

Consumer<T>：包含两个方法

• 代码演示

  public class ConsumerDemo {
      public static void main(String[] args) {
  //操作一
          operatorString("林青霞", s -> System.out.println(s));
  //操作二
          operatorString("林青霞", s -> System.out.println(new StringBuilder(s).reverse().toString()));
          
          System.out.println("--------");
  //传入两个操作使用andThen完成
          operatorString("林青霞", 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);
      }
  }

Predicate-判断参数接口

• Predicate接口

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

常用方法

• 代码演示

  public class PredicateDemo01 {
      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);
      }
  }
  ​
  public class PredicateDemo02 {
      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);
      }
  }

Function-对参数进行处理，转换，返回接口

• Function接口

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

常用方法

• 代码演示

  public class FunctionDemo {
      public static void main(String[] args) {
  //操作一
          convert("100",s -> Integer.parseInt(s));
  //操作二
          convert(100,i -> String.valueOf(i + 566));
  
          //使用andThen的方式连续执行两个操作
          convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566));
      }
  ​
      //定义一个方法，把一个字符串转换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.andThen(fun2).apply(s);
          System.out.println(ss);
      }
  ​
  }

三，Stream流

3.1　概念

“Stream流”其实是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素（或其地址值）。

3.2　Stream（流）

　　是一个来自数据源的元素队列

• 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
• 数据源 流的来源。 可以是集合，数组 等。

和以前的Collection操作不同， Stream操作还有两个基础的特征：

• Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluentstyle）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
• 内部迭代： 以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。

当使用一个流的时候，通常包括三个基本步骤：获取一个数据源（source）→ 数据转换→执行操作获取想要的结果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道。

3.3　生成Stream流的方式

Collection体系集合

使用默认方法stream()生成流， default Stream<E> stream()

Map体系集合

把Map转成Set集合，间接的生成流

数组

通过Stream接口的静态方法of(T... values)生成流

代码演示

public class StreamDemo {
    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<String> strArrayStream = Stream.of(strArray);
        Stream<String>  world", "java");
        Stream<Integer> intStream = Stream.of(10, 20, 30);
    }
}

3.4　Stream流常用方法

3.5　Stream流终结操作方法

概念

终结操作的意思是，执行完此方法之后，Stream流将不能再执行其他操作。

常见方法

代码演示

public class StreamDemo {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<String>();
​
        list.add("林青霞");
        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.6　Stream流的收集操作

概念

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

常用方法

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

示例

public class CollectDemo {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        //创建Set集合对象
        Set<Integer> set = new HashSet<Integer>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(33);
        set.add(35);  
       //定义一个字符串数组，每一个字符串数据由姓名数据和年龄数据组合而成
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33", "柳岩,25"};

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

        //需求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);
        }
    }
}