八、guava 函数式接口和工具

guava 函数式接口提供了Function，Supplier和Predicate，都继承了JDK的函数式接口，并提供了Functions，Suppliers和Predicates工具类。

示例：

package org.example.model.guava;

import com.google.common.base.*;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.SneakyThrows;
import org.junit.Test;

import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

import static org.assertj.core.api.Assertions.assertThat;

public class FunctionalTest {
    @AllArgsConstructor
    @NoArgsConstructor
    @Getter
    public static class Person {
        private String name;
        private int age;

        @Override
        public String toString() {
            return MoreObjects.toStringHelper(this)
                    .add("name", name)
                    .add("age", age)
                    .toString();
        }
    }

    @Test
    public void testFunction() {
        // Functions定义了一些常用的Function实现（后面的示例仅是功能演示，并非最佳使用方式）
        // 1. ToStringFunction调用对象的toString方法获取对象的字符串表示
        Person person = new Person("张三", 25);
        assertThat(Functions.toStringFunction().apply(person))
                .isEqualTo("Person{name=张三, age=25}");

        // 2. forMap 将map转换为key到value的Functional接口
        ImmutableMap<Integer, String> map = new ImmutableMap.Builder<Integer,String>()
                .put(1, "a")
                .put(2, "b")
                .build();
        Function<Integer, String> mapFun = Functions.forMap(map, "default");
        assertThat(mapFun.apply(1)).isEqualTo("a");
        assertThat(mapFun.apply(3)).isEqualTo("default");

        // 3. 忽略入参的Functional接口
        assertThat(Functions.forSupplier(person::getName).apply(new Object())).isEqualTo("张三");
        Map<String, List<Person>> listMap = Maps.newHashMap();
        assertThat(listMap.computeIfAbsent("a", Functions.forSupplier(Lists::newArrayList)).add(person))
                .isTrue();

        // 4. 返回常量的Functional接口
        assertThat(Functions.constant(10).apply(new Object())).isEqualTo(10);

        // 5. 将guava的Predicate接口转换为Function接口
        assertThat(Functions.forPredicate(map::containsKey).apply(3)).isFalse();

        // 6. identity 直接将入参返回, 功能等价于JDK Function.identity()
        assertThat(Functions.identity().apply("name")).isEqualTo("name");
        assertThat(Function.identity().apply("name")).isEqualTo("name");

        // 7.                                                                                                tttttbnnn          多个Function接口组合，后面的Function返回结果为前面Function的入参（先执行后面的，后执行前面的
        assertThat(Functions.compose(Person::getName, (List<Person> list) -> list.get(0)).compose(listMap::get).apply("a"))
                .isEqualTo("张三");
        assertThat(Functions.compose((List<Person> list) -> list.get(0), listMap::get).andThen(Person::getName).apply("a"))
                .isEqualTo("张三");
    }

    @SneakyThrows
    @Test
    public void testSupplier() {
        // Suppliers定义了一些常用的Supplier实现（后面的示例仅是功能演示，并非最佳使用方式）
        // 1. 将对象包装成Supplier
        Person person = new Person("张三", 25);
        assertThat(Suppliers.ofInstance(person).get()).isSameAs(person);

        // 2. 构建一次对象并缓存
        Supplier<Person> personSupplier = Suppliers.memoize(Person::new);
        Person person1 = personSupplier.get();
        assertThat(personSupplier.get()).isSameAs(person1);

        // 3. 构建对象并缓存一定时间
        personSupplier = Suppliers.memoizeWithExpiration(Person::new, 1L, TimeUnit.MILLISECONDS);
        person1 = personSupplier.get();
        assertThat(personSupplier.get()).isSameAs(person1);
        Thread.sleep(2L);
        assertThat(personSupplier.get()).isNotSameAs(person1);

        // 4. 获取以supplier为入参，以supplier结果作为返回值的function
        assertThat(Suppliers.supplierFunction().apply(Person::new)).isNotNull().isInstanceOf(Person.class);

        // 5. supplier结果转给另外一个function处理，可用于对象创建后的初始化处理
        assertThat(Suppliers.compose(Person::getName, Person::new).get()).isNull();
    }

    @Test
    public void testPredicates() {
        // 1. 返回真和返回假的谓词
        assertThat(Predicates.alwaysFalse().apply("")).isFalse();
        assertThat(Predicates.alwaysTrue().apply("")).isTrue();

        // 2. 判断空/非空
        assertThat(Predicates.isNull().apply("")).isFalse();
        assertThat(Predicates.notNull().apply("")).isTrue();

        // 3. 判断类型
        assertThat(Predicates.instanceOf(String.class).apply("")).isTrue();

        // 4. 此外还支持and，not， or操作
        assertThat(Predicates.not(Predicates.alwaysTrue()).apply("")).isFalse();
        assertThat(Predicates.and(Predicates.alwaysTrue(), Predicates.alwaysFalse()).apply("")).isFalse();
        assertThat(Predicates.or(Predicates.alwaysFalse(), Predicates.alwaysTrue()).apply("")).isTrue();

        // 5. 支持和function组合，predicate(function(x))
        Person person = new Person("张三", 25);
        assertThat(Predicates.compose(Predicates.notNull(), Person::getName).apply(person)).isTrue();

        // 6. 正则匹配
        assertThat(Predicates.containsPattern("abc").apply("abcdefg")).isTrue();
    }
}