函数式编程

概述

为什么学？

• 能够看懂公司里的代码
• 大数量下处理集合效率高
• 代码可读性高
• 消灭嵌套地狱

函数式编程思想

概念

面对对象思想需要关注用什么对象完成什么事情，而函数式编程思想就类似于我们数学中的函数，它主要关注的是对数据进行了什么操作。

优点

• 代码简洁，开发快速
• 接近自然语言，易于理解
• 易于“并发编程”

Lambda表达式

概述

Lambda是jdk8中的一个语法糖，它可以对某些匿名内部类的写法进行简化。

核心原则

可推到可省略

基本格式

(参数列表)->{代码}

例一：

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("你知道吗？我比你想象的更想在身边");
    }
}).start();

new Thread(()->{
    System.out.println("你知道吗？我比你想象的更想在身边");
}).start();

省略规则

• 参数类型可以省略
• 方法体只有一句代码时大括号、return和唯一一句代码的分号可以省略
• 方法只有一个参数是小括号可以省略
• 以上这些规则都记不住也可以省略不记

Stream流

概述

Java8的Stream使用的是函数式编程模式，它可以被用来对集合或者数组进行链状流式的操作，可以更方便的对集合或者数组进行操作。

案例数据准备

@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
public class Book {
    private Long id;
    private String name;
    private String catagory;
    private Integer score;
    private String intro;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
public class Author {
    private Long id;
    private String name;
    private Integer age;
    private String intro;
    private List<Book> books;
}

private static List<Author> getAuthors(){
    //data initial
    Author author = new Author(1L,"蒙多",33,"一个从菜刀中明哲理的祖安人",null);
    Author author2 = new Author(2L,"亚拉索",15,"狂风也追逐不上他的思考速度",null);
    Author author3 = new Author(3L,"易",14,"是这个世界在限制他的思维",null);
    Author author4 = new Author(3L,"易",14,"是这个世界在限制他的思维",null);

    //book list
    List<Book> books1 = new ArrayList<>();
    List<Book> books2 = new ArrayList<>();
    List<Book> books3 = new ArrayList<>();

    books1.add(new Book(1L,"刀的两侧是光明与黑暗","哲学，爱情",88,"用一刀划分了爱恨"));
    books1.add(new Book(2L,"一个人不能死在同一把刀下","个人成长，爱情",98,"讲述如何从失败中明悟真理"));

    books2.add(new Book(3L,"那风吹不到的地方","哲学",85,"带你用思维去领略世界的尽头"));
    books2.add(new Book(3L,"那风吹不到的地方","哲学",85,"带你用思维去领略世界的尽头"));
    books2.add(new Book(4L,"吹或不吹","爱情，个人传记",56,"一个哲学家的恋爱观注定很难把他所在的时代理解"));

    books3.add(new Book(5L,"你的剑就是我的剑","爱情",56,"无法想象一个武者能对他的伴侣这么的宽容"));
    books3.add(new Book(6L,"风与剑","个人传记",100,"两个哲学家灵魂和肉体的碰撞会激起怎么样的火花呢？"));
    books3.add(new Book(6L,"风与剑","个人传记",100,"两个哲学家灵魂和肉体的碰撞会激起怎么样的火花呢？"));
    
    author.setBooks(books1);
    author2.setBooks(books2);
    author3.setBooks(books3);
    author4.setBooks(books3);
    
    List<Author> authorList = new ArrayList<>(Arrays.asList(author,author2,author3,author4));
    return authorList;
}

快速入门

需求

需要打印所有年龄小于18岁的作家名字，并且要注意去重。

实现

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

常用操作

创建流

单列集合：集合对象.stream()

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

数组：Arrays.steam()或者使用Stream.of()来创建

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

双列集合：转换成单列集合后再创建

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

Stream<Map.Entry<String,Integer>> stream = map.entrySet().stream();

中间操作

filter：可以对流中的元素进行条件过滤，符合过滤条件的才能继续留在留中。

//打印所有姓名长度大于1的作家姓名
List<Author> authors = getAuthors();
authors.stream()
        .filter(author->author.getName().length()>1)
        .forEach(author-> System.out.println(author.getName()));

map：可以把流中的元素进行计算或者转换

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

distinct：可以去除流中的重复元素

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

注意：distinct方法是依赖Object的equals方法来判断是否相同对象的，所以需要注意重写equals方法。

sorted：可以对流中的元素进行排序

List<Author> authors = getAuthors();
authors.stream()
        .distinct()
        .sorted()  //无参
        .forEach(author-> System.out.println(author.getAge()));
        
authors.stream()
        .distinct()
        .sorted((o1, o2) -> o2.getAge()-o1.getAge())  //有参
        .forEach(author-> System.out.println(author.getAge()));

注意：如果调用空参的sorted()方法，需要对流中的元素实现Comparable接口。

limit：可以设置流的最大长度，超出的部分将被抛弃。

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

skip：跳过流中的前n个元素，返回剩下的元素。

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

flatMap：map只能把一个对象转换成另一个对象来作为流中的元素，而flatMap可以把一个对象转换成多个对象作为流中的元素。

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

List<Author> authors = getAuthors();
authors.stream()
        .flatMap(author->author.getBooks().stream())
        .distinct()
        .flatMap(book -> Arrays.stream(book.getCatagory().split("，")))
        .distinct()
        .forEach(catagory-> System.out.println(catagory));

终结操作

forEach：对流中的元素进行遍历操作，通过传入的参数去指定对遍历到的元素进行什么具体操作

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

count：用来获取当前流中元素的个数

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

max&min:用来获取流中的最值

List<Author> authors = getAuthors();
Optional<Integer> max = authors.stream()
        .flatMap(author -> author.getBooks().stream())
        .map(book -> book.getScore())
        .max((o1, o2) -> o1 - o2);
System.out.println(max.get());

List<Author> authors = getAuthors();
Optional<Integer> min = authors.stream()
        .flatMap(author -> author.getBooks().stream())
        .map(book -> book.getScore())
        .min((o1, o2) -> o1 - o2);
System.out.println(min.get());

collect：把当前流转换成一个集合

List<Author> authors = getAuthors();

//获取作者姓名List
List<String> nameList = authors.stream()
        .map(author -> author.getName())
        .distinct()
        .collect(Collectors.toList());
System.out.println(nameList);

//获取书籍Set
List<Author> authors = getAuthors();
Set<Book> bookSet = authors.stream()
        .flatMap(author -> author.getBooks().stream())
        .collect(Collectors.toSet());
System.out.println(bookSet);

//Map的key为作者名字，value为作者的书籍
List<Author> authors = getAuthors();
Map<String, List<Book>> map = authors.stream()
        .distinct()
        .collect(Collectors.toMap(author -> author.getName(), author -> author.getBooks()));
System.out.println(map);

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

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

List<Author> authors = getAuthors();
boolean flag = authors.stream()
        .noneMatch(author -> author.getAge() > 100);
System.out.println(flag)

findAny：获取流中的任意一个元素，该方法没有办法保证获取的一定是流中的第一个符合条件的元素

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;

示例：

List<Author> authors = getAuthors();
Integer sum = authors.stream()
        .distinct()
        .map(author -> author.getAge())
        .reduce(0, (result, age) -> result + age);
System.out.println(sum);

List<Author> authors = getAuthors();
Integer max = authors.stream()
        .distinct()
        .map(author -> author.getAge())
        .reduce(Integer.MIN_VALUE, (result, element) -> result < element ? element : result);
System.out.println(max);

List<Author> authors = getAuthors();
Integer min = authors.stream()
        .distinct()
        .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();

List<Author> authors = getAuthors();
Optional<Integer> min = authors.stream()
        .distinct()
        .map(author -> author.getAge())
        .reduce(new BinaryOperator<Integer>() {
            @Override
            public Integer apply(Integer result, Integer element) {
                return result > element ? element : result;
            }
        });
min.ifPresent(age-> System.out.println(age));

注意事项

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

Optional

概述

jdk8引入了Optional来避免代码中的空指针异常，并且在很多函数式编程相关的API中也都用到了Optional。 Optional就好像是封装类，可以把具体的数据封装到Optional对象内部，然后使用Optional中封装好的方法操作封装进去的数据，就可以非常优雅的避免空指针异常。

使用

创建对象

使用Optional.ofNullable创建

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

安全消费值

Author author = getAuthor();
Optional<Author> authorOptional = Optional.ofNullable(author);
//使用ifPresent
authorOptional.ifPresent(author1 -> System.out.println(author1.getName()));

获取值

//如果此Optional中存在值，则返回该值，否则抛出NoSuchElementException 。
public T get() {
    if (value == null) {
        throw new NoSuchElementException("No value present");
    }
    return value;
}

安全获取值

orElseGet：获取数据并且设置数据为空的默认值。

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

orElseThrow：获取数据，如果为空则根据传入的参数来创建异常抛出

Optional<Author> authorOptional = getAuthor();
Author author = authorOptional
            .orElseThrow((Supplier<Throwable>) () -> new RuntimeException("author为空"));

过滤

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

数据转换

Optional<Author> authorOptional = getAuthor();
Optional<List<Book>> books = authorOptional.map(author -> author.getBooks());
books.ifPresent(books1 -> System.out.println(books1));

函数式接口

概述

只有一个抽象方法的接口称之为函数式接口。 jdk的函数式接口都加上了@FunctionalInterface注解进行标识，但是无论是否加上该注解只要接口中只有一个抽象方法，都是函数式接口。

常见函数式接口

• Consumer消费接口

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
 }

• Function计算转换接口

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}

• Predicate判断接口

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
}

• Supplier生产型接口

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

常用的默认方法

• and 返回一个组合谓词，该谓词表示此谓词与另一个谓词的短路逻辑与。在评估组合谓词时，如果此谓词为false ，则不评估other谓词。

在评估任一谓词期间抛出的任何异常都将转发给调用者；如果此谓词的评估引发异常，则不会评估other谓词

default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
}

• or 返回一个组合谓词，该谓词表示此谓词与另一个谓词的短路逻辑或。在评估组合谓词时，如果此谓词为true ，则不评估other谓词。

在评估任一谓词期间抛出的任何异常都将转发给调用者；如果此谓词的评估引发异常，则不会评估other谓词。

default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) || other.test(t);
}

• negate：Predicate接口中的方法，相当于是在判断添加前面加了!,表示取反 返回表示此谓词的逻辑否定的谓词。

default Predicate<T> negate() {
    return (t) -> !test(t);
}

方法引用

在使用lambda时，如果方法体中只有一个方法的调用的话（包括构造方法），可以用方法引用进一步简化代码。

基本格式

类名或者对象名::方法名