函数式编程（Lambda && Stream）

函数式编程（Lambda && Stream）

参考：《Java8实战》+《B站三更草堂》

以sort引入

匿名内部类->lambda

​ 我们常常用传入Comparator来完成排序行为的传入，这里我们传进去的实际上是如何排序这个行为，lambda实际上就是让我们尽可能的去关注这个行为本身，至于Comparator这个接口里面要覆盖重写的方法叫啥，我们其实没必要过多的关心，关注一下返回类型就够了。

public static void main(String[] args) {
        List<Integer> integers = Arrays.asList(1, 5, 2, 7, 10);
        Collections.sort(integers, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        System.out.println(integers);
}

​ 这个简单例子很容易转换为lambda，这里刚开始不熟悉，可以直接使用IDEA的自动转换功能

 public static void main(String[] args) {
        List<Integer> integers = Arrays.asList(1, 5, 2, 7, 10);
        Collections.sort(integers, (o1, o2) -> o1-o2);
        System.out.println(integers);
 }

几个官方提供的接口

Predicate

​ 再来几个官方提供的常用接口，其实接口叫什么名字并不重要，具体的行为是我们程序员去设计的，我们只需要关注它的返回值类型就行了，比如Predicate这个接口

​ 比如我们要对一组数做相同的判定操作，这个判定操作返回的就是布尔类型，每个数字是或否，那么官方提供的IntPredicate这个接口的test方法就能满足我们这个需求，我们只需要在调用printNum方法时，传入判定的具体内容，就可以灵活改变判定行为了，这个在《Java8实战》中聊的比较多，主要是为了方法的扩展性，当需求不断变更时，我们只需要去改变传入的行为即可，而不是整篇代码大幅度修改，那么显得并不那么优雅！

 public static void main(String[] args) {
        printNum(new IntPredicate() {
            @Override
            public boolean test(int value)
            {
                return value%2==0;

            } });
    }

    public static void printNum(IntPredicate predicate){
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for (int i : arr) {
            if(predicate.test(i)){ System.out.println(i);
            } }
    }

Function

​ Function函数简单来说，就是传入一个类型T，返回一个类型R，具体怎么操作T这个传入，自己来定行为即可！

这样就大大扩展了我们实际想去传入的这个行为，因为这个行为的扩展还包括了我们想灵活定制的传入传出类型！比如这里我们将字符串接受，返回Integer类型：

public static void main(String[] args) {

        Integer result = typeConver(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.valueOf(s);
            }
        });
        System.out.println(result);
    }

    public static <R> R typeConver(Function<String, R> function) {
        String str = "1235";
        R result = function.apply(str);
        return result;
    }

还可以对输出类型做改变，比如改成双层List：

public static void main(String[] args) {

        List<List<Integer>> result = typeConver(new Function<String, List<List<Integer>>>() {
            @Override
            public List<List<Integer>> apply(String s) {

                List<Integer> integers = new ArrayList<>();
                integers.add(Integer.valueOf(s));
                List<List<Integer>> list = new ArrayList<>();
                list.add(integers);
                return list;
            }
        });
        System.out.println(result);
    }

    public static <R> R typeConver(Function<String, R> function) {
        String str = "1235";
        R result = function.apply(str);
        return result;
    }

Consumer

​ 这个接口返回的类型最简单，因为它没有返回，比如这个IntConsumer，接受的Int类型，啥也不返回，一般我们主要用于打印语句上：

​ 当然还有Consumer，void accept(T t)接受泛型输入

 public static void main(String[] args) {
        foreachArr(new IntConsumer() {
            @Override
            public void accept(int value) {
                System.out.println(value);
            }
        });
    }

    public static void foreachArr(IntConsumer consumer) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        for (int i : arr) {
            consumer.accept(i);
        }
    }

Supplier

生产型接口

根据其中抽象方法的参数列表和返回值类型知道，我们可以在方法中创建对象，把创建好的对象返回

流Stream

​ 流的操作主要分为创建、中间操作、终结操作：

创建

​ 创建很简单，分为集合单列对象、数组、双列集合（Map->entrySet）

集合：

 List<Author> authors = getAuthors(); 
Stream<Author> stream = authors.stream();

数组：

Integer[] arr = {1,2,3,4,5};
Stream<Integer> stream = Arrays.stream(arr); 
Stream<Integer> stream2 = Stream.of(arr);

双列集合：

本质上还是将Map转化为单列集合entrySet 再做流操作，和前面一致

Map<String,Integer> map = new HashMap<>(); 
map.put("蜡笔小新",19);
map.put("黑子",17);
map.put("日向翔阳",16);
Stream<Map.Entry<String, Integer>> stream = map.entrySet().stream();

中间操作

流式debug

filter

​ 过滤操作，简单来说就是对集合中的元素根据每个判定条件筛选过滤，比如年龄都大于18、名字长度都小于3…
​ 前面调到了Predicate，返回一个布尔类型判定, 这里的filter传入的就是该匿名内部类，可以对集合里面的元素对象的属性做任何值的判定

 List<Author> authors = getAuthors();
        authors.stream()//把集合转换成流
                .distinct()//先去除重复的作家
                .filter(new Predicate<Author>() {
                    @Override
                    public boolean test(Author author) {
                        return  author.getAge() < 18;
                    }
                })//筛选年龄小于18的
                .forEach(author -> System.out.println(author.getName()));//遍历打印名字

简化：

public static void main(String[] args) {
//打印所有年龄小于18的作家的名字，并且要注意去重
        List<Author> authors = getAuthors();
        authors.stream()//把集合转换成流
                .distinct()//先去除重复的作家
                .filter(new Predicate<Author>() {
                    @Override
                    public boolean test(Author author) {
                        return  author.getAge() < 18;
                    }
                })//筛选年龄小于18的
                .forEach(author -> System.out.println(author.getName()));//遍历打印名字
    }

map

​ map操作相当于是将集合里面的对象一一映射到另一个对象上去，比如我想拿到作者集合中的所有人名，类型为List而不是List，这里就已经改变了集合中的元素类型了，按传统方法不用流的话，就要再new一个List，遍历一遍List，不断的add，相当不优雅！这里直接用map操作得到想要的映射对象。

​ 那么此处传入的接口应该是啥呢？很明显是前后类型不一致，传入的就是Function接口：

.map(new Function<Author, String>() {
  @Override
  public String apply(Author author) {
    return author.getName();
  }
})

简化：

   public static void main(String[] args) {

//打印所有年龄小于18的作家的名字，并且要注意去重
        List<Author> authors = getAuthors();
        authors.stream()//把集合转换成流
                .map(author -> author.getName())
                .forEach(authorName -> System.out.println(authorName));//遍历打印名字
    }

distinct

​ 这个很简单，就是去重操作，基于对象的equals重写方法，一般默认去比较对象的属性值是否相等，如果作者的名字、年龄等其他属性都相等的情况下，说明是同一个对象。

List<Author> authors = getAuthors(); 
authors.stream()
       .distinct()
				.forEach(author -> System.out.println(author.getName()));

sorted

​ 这个排序操作，本文一开始就引入了，这里就不赘述了，直接上代码。

List<Author> authors = getAuthors(); 对流中的元素按照年龄进行降序排序，并且要求不能有重复的元素。
authors.stream() 
  		.distinct()
			.sorted((o1, o2) -> o2.getAge()-o1.getAge()) 
 		 .forEach(author ->System.out.println(author.getAge()));

flatMap

​ flatMap，翻译过来就是平铺下去，和map的区别在于，map是一个对象对应一个值做映射，而flatMap中一个对象可以对应多个值，比如这里每个作者有一个Book集合，我们想把所有Book都放在一个集合中，就可以这样做：

​ 这里Function第二个参数是Stream，要记得转换一下

public static void main(String[] args) {
 
   //     打印所有书籍的名字。要求对重复的元素进行去重。
        List<Author> authors = getAuthors();
        authors.stream()
                .flatMap(new Function<Author, Stream<? extends Book>>() {
                    @Override
                    public Stream<? extends Book> apply(Author author) {
                        return author.getBooks().stream();
                    }
                }) .distinct()
                .forEach(book -> System.out.println(book.getName()));
    }

public static void main(String[] args) {
 
   //     打印所有书籍的名字。要求对重复的元素进行去重。
        List<Author> authors = getAuthors();
        authors.stream()
                .flatMap(author -> author.getBooks().stream()) .distinct()
                .forEach(book -> System.out.println(book.getName()));
    }

limit

​ 设置一个返回的长度限制。

 
List<Author> authors = getAuthors(); 
authors.stream()
.distinct()
.sorted()
.limit(2)
.forEach(author -> System.out.println(author.getName()));

skip

​ 跳过几个

//打印除了年龄最大的作家外的其他作家，要求不能有重复元素，并且按照年龄降序排序。
List<Author> authors = getAuthors(); 
authors.stream()
.distinct()
.sorted()
.skip(1)
.forEach(author -> System.out.println(author.getName()));

终结操作

​ 在前面流已经经过了一些列中间操作，对元素中的对象比如做了筛选过滤、去重、后者映射等等，现在已经有这些元素了，下面要对这些元素进行最终的输出，可以采用以下几种方式，最简单的遍历foreach（最常用的就是打印输出每个元素），count统计个数、max&min计算值的最值、collect用于将元素转化为List输出或者合并字符串等等。

foreach

public static void main(String[] args) {

//打印所有年龄小于18的作家的名字，并且要注意去重
        List<Author> authors = getAuthors();
        authors.stream()//把集合转换成流
                .map(author -> author.getName())
                .forEach(authorName -> System.out.println(authorName));//遍历打印名字
 
    }

max&min

​ 可以用来或者流中的最值。 例子:

分别获取这些作家的所出书籍的最高分和最低分并打印。

 
 public static void main(String[] args) {
 
        List<Author> authors = getAuthors();
        Optional<Integer> max = authors.stream()
                .flatMap(author -> author.getBooks().stream()).map(book -> book.getScore())
                .max((score1, score2) -> score1 - score2);
        Optional<Integer> min = authors.stream().flatMap(author -> author.getBooks().stream()).map(book -> book.getScore())
                .min((score1, score2) -> score1 - score2);
        System.out.println(max.get());
        System.out.println(min.get());
    }

collect

把当前流转换成一个集合。 例子:

获取一个存放所有作者名字的List集合。

public static void main(String[] args) {
 
        List<Author> authors = getAuthors();
        List<String> nameList = authors.stream()
                .map(author -> author.getName())
                .collect(Collectors.toList());
        System.out.println(nameList);
    }

这里还有个骚操作，可以转化为Map，设定好key和value分别是什么即可，类型可以自定义，依旧还是Function接口：

public static void main(String[] args) {
 
 List<Author> authors = getAuthors();
//        Map<String, List<Book>> map = authors.stream().distinct()
//                .collect(Collectors.toMap(author -> author.getName(), author -> author.getBooks()));
        Map<String, Integer> map = authors.stream().distinct()
                .collect(Collectors.toMap(author -> author.getName(), author -> author.getAge()));
        System.out.println(map);
    }

查找与匹配

anyMatch

可以用来判断是否有任意符合匹配条件的元素，结果为boolean类型。

例子: 判断是否有年龄在29以上的作家

 
// 判断是否有年龄在29以上的作家 
List<Author> authors = getAuthors(); 
boolean flag = authors.stream()
							.anyMatch(author -> author.getAge() > 29); 
System.out.println(flag);

allMatch

可以用来判断是否都符合匹配条件，结果为boolean类型。如果都符合结果为true，否则结果为false。 例子:

 
// 判断是否所有的作家都是成年人 
List<Author> authors = getAuthors(); 
boolean flag = authors.stream()
.allMatch(author -> author.getAge() >= 18); 
System.out.println(flag);

noneMatch

可以判断流中的元素是否都不符合匹配条件。如果都不符合结果为true，否则结果为false 例子:

判断作家是否都没有超过100岁的。

 
// 判断作家是否都没有超过100岁的。 
List<Author> authors = getAuthors();
boolean b = authors.stream()
.noneMatch(author -> author.getAge() > 100);
System.out.println(b);

findAny

​ 获取流中的任意一个元素。该方法没有办法保证获取的一定是流中的第一个元素。

例子：

​ 获取任意一个年龄大于18的作家，如果存在就输出他的名字

//        获取任意一个年龄大于18的作家，如果存在就输出他的名字
        List<Author> authors = getAuthors();
        Optional<Author> optionalAuthor = authors.stream()
                .filter(author -> author.getAge()>18)
                .findAny();

        optionalAuthor.ifPresent(author -> System.out.println(author.getName()));

findFirst

​ 获取流中的第一个元素。

例子：

​ 获取一个年龄最小的作家，并输出他的姓名。

//        获取一个年龄最小的作家，并输出他的姓名。
        List<Author> authors = getAuthors();
        Optional<Author> first = authors.stream()
                .sorted((o1, o2) -> o1.getAge() - o2.getAge())
                .findFirst();

        first.ifPresent(author -> System.out.println(author.getName()));

reduce归并

​ 对流中的数据按照你指定的计算方式计算出一个结果。（缩减操作）

​ reduce的作用是把stream中的元素给组合起来，我们可以传入一个初始值，它会按照我们的计算方式依次拿流中的元素和初始化值进行计算，计算结果再和后面的元素计算。

​ reduce两个参数的重载形式内部的计算方式如下：

T result = identity;
for (T element : this stream)
	result = accumulator.apply(result, element)
return result;

​ 其中identity就是我们可以通过方法参数传入的初始值，accumulator的apply具体进行什么计算也是我们通过方法参数来确定的。

例子：

​ 使用reduce求所有作者年龄的和

//        使用reduce求所有作者年龄的和
        List<Author> authors = getAuthors();
        Integer sum = authors.stream()
                .distinct()
                .map(author -> author.getAge())
                .reduce(0, (result, element) -> result + element);
        System.out.println(sum);

​ 使用reduce求所有作者中年龄的最大值

//        使用reduce求所有作者中年龄的最大值
        List<Author> authors = getAuthors();
        Integer max = authors.stream()
                .map(author -> author.getAge())
                .reduce(Integer.MIN_VALUE, (result, element) -> result < element ? element : result);

        System.out.println(max);

​ 使用reduce求所有作者中年龄的最小值

//        使用reduce求所有作者中年龄的最小值
        List<Author> authors = getAuthors();
        Integer min = authors.stream()
                .map(author -> author.getAge())
                .reduce(Integer.MAX_VALUE, (result, element) -> result > element ? element : result);
        System.out.println(min);

​ reduce一个参数的重载形式内部的计算

 	 boolean foundAny = false;
     T result = null;
     for (T element : this stream) {
         if (!foundAny) {
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.apply(result, element);
     }
     return foundAny ? Optional.of(result) : Optional.empty();

​ 如果用一个参数的重载方法去求最小值代码如下：

        //        使用reduce求所有作者中年龄的最小值
        List<Author> authors = getAuthors();
        Optional<Integer> minOptional = authors.stream()
                .map(author -> author.getAge())
                .reduce((result, element) -> result > element ? element : result);
        minOptional.ifPresent(age-> System.out.println(age));

注意事项

• 惰性求值（如果没有终结操作，没有中间操作是不会得到执行的）
• 流是一次性的（一旦一个流对象经过一个终结操作后。这个流就不能再被使用）
• 不会影响原数据（我们在流中可以多数据做很多处理。但是正常情况下是不会影响原来集合中的元素的。这往往也是我们期望的）

Optional

​ 我们在编写代码的时候出现最多的就是空指针异常。所以在很多情况下我们需要做各种非空的判断。

​ 例如：

        Author author = getAuthor();
        if(author!=null){
            System.out.println(author.getName());
        }

​ 尤其是对象中的属性还是一个对象的情况下。这种判断会更多。

​ 而过多的判断语句会让我们的代码显得臃肿不堪。

​ 所以在JDK8中引入了Optional,养成使用Optional的习惯后你可以写出更优雅的代码来避免空指针异常。

​ 并且在很多函数式编程相关的API中也都用到了Optional，如果不会使用Optional也会对函数式编程的学习造成影响。

使用

创建对象

​ Optional就好像是包装类，可以把我们的具体数据封装Optional对象内部。然后我们去使用Optional中封装好的方法操作封装进去的数据就可以非常优雅的避免空指针异常。

​ 我们一般使用Optional的静态方法ofNullable来把数据封装成一个Optional对象。无论传入的参数是否为null都不会出现问题。

        Author author = getAuthor();
        Optional<Author> authorOptional = Optional.ofNullable(author);

​ 你可能会觉得还要加一行代码来封装数据比较麻烦。但是如果改造下getAuthor方法，让其的返回值就是封装好的Optional的话，我们在使用时就会方便很多。

​ 而且在实际开发中我们的数据很多是从数据库获取的。Mybatis从3.5版本可以也已经支持Optional了。我们可以直接把dao方法的返回值类型定义成Optional类型，MyBastis会自己把数据封装成Optional对象返回。封装的过程也不需要我们自己操作。

​ 如果你确定一个对象不是空的则可以使用Optional的静态方法of来把数据封装成Optional对象。

        Author author = new Author();
        Optional<Author> authorOptional = Optional.of(author);

​ 但是一定要注意，如果使用of的时候传入的参数必须不为null。（尝试下传入null会出现什么结果）

​ 如果一个方法的返回值类型是Optional类型。而如果我们经判断发现某次计算得到的返回值为null，这个时候就需要把null封装成Optional对象返回。这时则可以使用Optional的静态方法empty来进行封装。

		Optional.empty()

​

​ 所以最后你觉得哪种方式会更方便呢？ofNullable

安全消费值

​ 我们获取到一个Optional对象后肯定需要对其中的数据进行使用。这时候我们可以使用其ifPresent方法对来消费其中的值。

​ 这个方法会判断其内封装的数据是否为空，不为空时才会执行具体的消费代码。这样使用起来就更加安全了。

​ 例如,以下写法就优雅的避免了空指针异常。

        Optional<Author> authorOptional = Optional.ofNullable(getAuthor());

        authorOptional.ifPresent(author -> System.out.println(author.getName()));

获取值

​ 如果我们想获取值自己进行处理可以使用get方法获取，但是不推荐。因为当Optional内部的数据为空的时候会出现异常。

安全获取值

​ 如果我们期望安全的获取值。我们不推荐使用get方法，而是使用Optional提供的以下方法。

• orElseGet

  获取数据并且设置数据为空时的默认值。如果数据不为空就能获取到该数据。如果为空则根据你传入的参数来创建对象作为默认值返回。

          Optional<Author> authorOptional = Optional.ofNullable(getAuthor());
          Author author1 = authorOptional.orElseGet(() -> new Author());
  

• orElseThrow

  获取数据，如果数据不为空就能获取到该数据。如果为空则根据你传入的参数来创建异常抛出。

          Optional<Author> authorOptional = Optional.ofNullable(getAuthor());
          try {
              Author author = authorOptional.orElseThrow((Supplier<Throwable>) () -> new RuntimeException("author为空"));
              System.out.println(author.getName());
          } catch (Throwable throwable) {
              throwable.printStackTrace();
          }
  

过滤

​ 我们可以使用filter方法对数据进行过滤。如果原本是有数据的，但是不符合判断，也会变成一个无数据的Optional对象。

        Optional<Author> authorOptional = Optional.ofNullable(getAuthor());
        authorOptional.filter(author -> author.getAge()>100).ifPresent(author -> System.out.println(author.getName()));

判断

​ 我们可以使用isPresent方法进行是否存在数据的判断。如果为空返回值为false,如果不为空，返回值为true。但是这种方式并不能体现Optional的好处，更推荐使用ifPresent方法。

        Optional<Author> authorOptional = Optional.ofNullable(getAuthor());

        if (authorOptional.isPresent()) {
            System.out.println(authorOptional.get().getName());
        }

数据转换

​ Optional还提供了map可以让我们的对数据进行转换，并且转换得到的数据也还是被Optional包装好的，保证了我们的使用安全。

例如我们想获取作家的书籍集合。

    private static void testMap() {
        Optional<Author> authorOptional = getAuthorOptional();
        Optional<List<Book>> optionalBooks = authorOptional.map(author -> author.getBooks());
        optionalBooks.ifPresent(books -> System.out.println(books));
    }