Java函数式编程

基础使用

1
2
String[] array = new String[] { "Apple", "Orange", "Banana", "Lemon" };
Arrays.sort(array,(o1,o2)->o2.compareTo(o1));

传入方法

方法签名和接口一致时,在这里,方法签名只看参数类型和返回类型,不看方法名称,也不看类的继承关系

1
2
3
4
5
6
7
8
9
public static void main(String[] args) {
    String[] array = new String[] { "Apple", "Orange", "Banana", "Lemon" };
    Arrays.sort(array, Main::cmp);
}

// 
static int cmp(String s1, String s2) {
    return s1.compareTo(s2);
}

构造方法引用

流式API

全新的流式API:Stream API,位于Java.util.stream包

这个Stream不同于Java.io的InputStream和OutputStream,它代表的是任意Java对象的序列

这个Stream和List也不一样,List存储的每个元素都是已经存储在内存中的某个Java对象,而Stream输出的元素可能并没有预先存储在内存中,而是实时计算出来的,惰性计算

1
2
3
4
Stream<BigInteger> naturals = createNaturalStream(); // 不计算
Stream<BigInteger> s2 = naturals.map(BigInteger::multiply); // 不计算
Stream<BigInteger> s3 = s2.limit(100); // 不计算
s3.forEach(System.out::println); // 计算

惰性计算的特点是:一个Stream转换为另一个Stream时,实际上只存储了转换规则,并没有任何计算发生

Stream API的基本用法就是:创建一个Stream,然后做若干次转换,最后调用一个求值方法获取真正计算的结果

1
2
3
4
5
int result = createNaturalStream() // 创建Stream
             .filter(n -> n % 2 == 0) // 任意个转换
             .map(n -> n * n) // 任意个转换
             .limit(100) // 任意个转换
             .sum(); // 最终计算结果

创建Stream

  1. Stream.of:Stream<String> stream = Stream.of("A", "B", "C", "D")

    1
    
    Stream.of("A","B","C").forEach(System.out::println);
    
  2. 基于数组或Collection:Arrays.stream(),collection.stream()

    1
    2
    
    Stream<String> stream1 = Arrays.stream(new String[] { "A", "B", "C" });
    Stream<String> stream2 = List.of("X", "Y", "Z").stream();
    
  3. 基于Supplier:Stream.generate()方法,它需要传入一个Supplier对象;基于Supplier创建的Stream会不断调用Supplier.get()方法来不断产生下一个元素,这种Stream保存的不是元素,而是算法,它可以用来表示无限序列

  4. 基本类型:IntStream、LongStream和DoubleStream这三种使用基本类型的Stream

Stream.map()

map()方法用于将一个Stream的每个元素映射成另一个元素并转换成一个新的Stream;

可以将一种元素类型转换成另一种元素类型。

1
2
3
4
5
6
//字符串转化为日期,并打印
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
List.of("2021-12-12","2021-12-13","2021-12-14")
    .stream()
    .map(n->sdf.parse(n))
    .forEach(System.out::println);

Stream.flatMap()

flatMap()对流扁平化处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
private static void streamTest4() {
    List<String> list = new ArrayList<>();
    list.add("123,234");
    list.add("3456");
    list.add("456,789");

    Set<String> strings = list.stream().map(e -> e.split(","))
        .flatMap(Arrays::stream)
        .collect(Collectors.toSet());
    
   // 输出:[123, 234, 3456, 456, 789]
    System.out.println(strings);
}

解释:map 操作获得一个 String[] 流,然后通过 flatMap 将 String[] 生成的新流的新流

Stream.filter()

filter()操作,就是对一个Stream的所有元素一一进行测试,不满足条件的就被“滤掉”了,剩下的满足条件的元素就构成了一个新的Stream

filter()方法接收的对象是Predicate接口对象,它定义了一个test()方法,负责判断元素是否符合条件

1
2
3
4
5
6
7
// 过滤成绩小于15的Person
Person p1=new Person("张三",12);
Person p2=new Person("李四",21);
Person p3=new Person("王五",35);
List.of(p1,p2,p3).stream()
    .filter(n->n.score>15)
    .forEach(System.out::println);

Stream.reduce()

reduce()是Stream的一个聚合方法,它可以把一个Stream的所有元素按照聚合函数聚合成一个结果

reduce()方法传入的对象是BinaryOperator接口,它定义了一个apply()方法,负责把上次累加的结果和本次的元素 进行运算,并返回累加的结果

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
int sum = 0;
for (n : stream) {
    sum = (sum, n) -> sum + n;
}

// 将配置文件的每一行配置通过map()和reduce()操作聚合成一个Map<String, String>
List<String> props = List.of("profile=native", "debug=true", "logging=warn", "interval=500");
Map<String,String> map=props.stream()
    .map((kv)->{
        String[] ss = kv.split("\\=", 2);
        return Map.of(ss[0],ss[1]);
    })
    .reduce(new HashMap<>(),(o,v)->{
        o.putAll(v);
        return o;
    });
map.forEach((k,v)->{
    System.out.println(k+":"+v);
});

//分组后根据某个属性分组,然后每组再次聚合,自定义收集器,返回Map
Map<String,BigDecimal> res=list.stream().collect(
    Collectors.groupingBy(Material::getType,
                          Collectors.reducing(BigDecimal.ZERO, Material::getMoney, BigDecimal::add)));
    
    
//对 bigdecimal 求和
BigDecimal bigDecimal = decimalList.stream().filter(Objects::nonNull).reduce(BigDecimal.ZERO, (res,v)->{
    return res.add(v);
});

输出集合

  1. 输出为List:调用collect()并传入Collectors.toList()对象,类似有Collectors.toSet()输出集合

    1
    2
    3
    4
    5
    6
    7
    
    //输出list,并过滤掉无用元素
    List<String> list=Stream.of("Apple", "", null, "Pear", "  ", "Orange")
        .filter(s -> s != null && !s.isBlank())
        .collect(Collectors.toList());
    list.forEach((v)->{
        System.out.println(v);
    });
    
  2. 输出为数组:toArray(String[]::new)

    1
    2
    
    List<String> list = List.of("Apple", "Banana", "Orange");
    String[] array = list.stream().toArray(String[]::new);
    
  3. 输出为Map

    1
    2
    3
    4
    5
    6
    7
    
    Stream<String> stream = Stream.of("APPL:Apple", "MSFT:Microsoft");
    Map<String, String> map = stream
        .collect(Collectors.toMap(
            // 把元素s映射为key:
            s -> s.substring(0, s.indexOf(':')),
            // 把元素s映射为value:
            s -> s.substring(s.indexOf(':') + 1)));
    
  4. 分组输出:分组输出使用Collectors.groupingBy(),它需要提供两个函数:一个是分组的key,第二个是分组的value

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    
    // 根据classID,分组,返回Map(Integer,List<Student>)
    List<Student> studentList=new ArrayList<>();
    for (int i=1;i<10;i++){
        Student s1=new Student(20%i,"张"+i);
        studentList.add(s1);
    }
    Map<Integer, List<Student>> groups=studentList.stream()
        .collect(Collectors.groupingBy(stu->stu.classId,Collectors.toList()));
    
    groups.forEach((k,v)->{
        System.out.print(k+":");
        v.forEach((lv)->{
            System.out.print(lv+",");
        });
        System.out.println();
    });
    
  5. anyMatch表示,判断的条件里,任意一个元素成功,返回true

    allMatch表示,判断条件里的元素,所有的都是,返回true

    noneMatch跟allMatch相反,判断条件里的元素,所有的都不是,返回true

    1
    2
    3
    4
    5
    6
    7
    8
    9
    
    List<String> strs = Arrays.asList("a", "a", "a", "a", "b");
            boolean aa = strs.stream().anyMatch(str -> str.equals("a"));
            boolean bb = strs.stream().allMatch(str -> str.equals("a"));
            boolean cc = strs.stream().noneMatch(str -> str.equals("a"));
            long count = strs.stream().filter(str -> str.equals("a")).count();
            System.out.println(aa);// TRUE
            System.out.println(bb);// FALSE
            System.out.println(cc);// FALSE
            System.out.println(count);// 4
    

collectingAndThen()

Collectors.collectingAndThen(Collector下游,函数完成器),先进行结果集的收集,然后将收集到的结果集进行下一步的处理

第一个参数是Collector接口的子类,所以还是对于Collector的处理,Collectors工具类里面的toList()、toSet()、joining()、mapping()、collectingAndThen()等几乎所有的方法都可以使用

第二个参数是一个Function函数,Function函数是这样的:R apply(T t),他调用的ArrayList的有参构造方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
// list去重
//将集合放到TreeSet中,然后再将TreeSet转为List, 其中TreeSet要传入一个根据哪个属性进行比较的比较器,然后使用public ArrayList(Collection<? extends E> c)将TreeSet放入构造器中生成List
collect = personList.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(()->
    new TreeSet<>(Comparator.comparing(e->e.name+e.score))
), ArrayList::new));

//创建不变map
personList.stream().collect(Collectors.collectingAndThen(Collectors.toMap(e ->
     e.score+e.name, e -> e.score
), HashMap::new));

Collector与Collectors

Collector是专门用来作为Stream的collect方法的参数的

Collectors是作为生产具体Collector的工具类

Collector

Collector主要包含五个参数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/*
* T 入参类型
* A 容器类型
* R 结果类型
*/
public interface Collector<T, A, R> {
    /*
     * supplier参数用于生成结果容器,容器类型为A
     * 返回一个结果为空的 Supplier,也就是一个无参数函数,在调用时它会创建一个空的累加器实例,供数据收集过程使用
    */ 
    Supplier<A> supplier();
    
    /*
     * accumulator用于消费元素,也就是归纳元素,这里的T就是元素,它会将流中的元素一个一个与结果容器A发生操作
     * 返回执行归约操作的函数,当遍历到流中第n个元素时,
     * 这个函数执行时会有两个参数:保存归约结果的累加器(已收集了流中的前 n-1 个项目),还有第n个元素本身
     * 该函数将返回 void ,因为累加器是原位更新,即函数的执行改变了它的内部状态
    */ 
    BiConsumer<A, T> accumulator();
    
    /* 
     * combiner用于两个两个合并并行执行的线程的执行结果,将其合并为一个最终结果A
     * combiner 方法会返回一个供归约操作使用的函数,
     * 它定义了对流的各个子部分进行并行处理时,各个子部分归约所得的累加器要如何合并
    */
    BinaryOperator<A> combiner();
    
    /* finisher用于将之前整合完的结果R转换成为A
     * 在遍历完流后, finisher 方法必须返回在累积过程的最后要调用的一个函数,
     * 以便将累加器对象转换为整个集合操作的最终结果
    */
    Function<A, R> finisher();
    
    /*
     * NORDERED —— 归约结果不受流中项目的遍历和累积顺序的影响
     * CONCURRENT —— accumulator 函数可以从多个线程同时调用,且该收集器可以并行归约流。如果收集器没有标为 UNORDERED ,那它仅在用于无序数据源时才可以并行归约
     * IDENTITY_FINISH —— 这表明完成器方法返回的函数是一个恒等函数,可以跳过。这种情况下,累加器对象将会直接用作归约过程的最终结果。这也意味着,将累加器 A 不加检查地转换为结果 R 是安全的
     */
    Set<Characteristics> characteristics();
}

Collector拥有两个of方法用于生成Collector实例,其中一个拥有上面所有五个参数,另一个四个参数,不包括finisher

Collectors

Collectors是一个工具类,是JDK预实现Collector的工具类,它内部提供了多种Collector,我们可以直接拿来使用

通过Collector的of方法自定义Collector收集器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
//自定义collector实现,作用将BigDecimal求和,对于null忽略
Collector<BigDecimal,BigDecimal[],BigDecimal> collector=Collector.of(
    ()-> new BigDecimal[1],
    (a, t) -> {
        //这里对结果容器赋初始值
        if (a[0] == null) {
            a[0] = BigDecimal.ZERO;
        }
        //这里忽略流中null元素
        if (t!=null){
             a[0] = a[0].add(t);
        }
    },
    (a, b) -> {
        a[0] = a[0].add(b[0]);
        return a;
    },
    a -> a[0],
    Collector.Characteristics.IDENTITY_FINISH);

list.stream().collect(collector);

自定义实现类实现Collectors

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
// T 是流中要收集的项目的泛型
// A 是累加器的类型,累加器是在收集过程中用于累积部分结果的对象
// R 是收集操作得到的对象(通常但并不一定是集合)的类型
new Collector<BigDecimal, BigDecimal[], String>() {
    /**
     * 建立新的结果容器
     */
    @Override
    public Supplier<BigDecimal[]> supplier() {
        return () -> new BigDecimal[1];
    }

    /**
     * 将元素添加到结果容器
     */
    @Override
    public BiConsumer<BigDecimal[], BigDecimal> accumulator() {
        return (a,t)->{
            if (a[0]==null){
                a[0]=BigDecimal.ZERO;
            }
            if (t != null){
                a[0]=a[0].add(t);
            }
        };
    }

    /**
     * 合并两个结果容器
     */
    @Override
    public BinaryOperator<BigDecimal[]> combiner() {
        return (a1,a2)->{
            a1[0]=a1[0].add(a2[0]);
            return a1;
        };
    }

    /**
     * 对结果容器应用最终转换
     */
    @Override
    public Function<BigDecimal[], String> finisher() {
        return (a)-> a[0].toString();
    }

    /**
     * 定义了收集器特性
     */
    @Override
    public Set<Characteristics> characteristics() {
        return Collections.unmodifiableSet(EnumSet.of(
                Characteristics.CONCURRENT,
                Collector.Characteristics.UNORDERED));
    }
}

其他

Stream提供的常用操作有:

转换操作:map(),filter(),sorted(),distinct();

合并操作:concat(),flatMap();

并行处理:parallel();

聚合操作:reduce(),collect(),count(),max(),min(),sum(),average();

其他操作:allMatch(), anyMatch(), forEach()

java提供的函数接口

Function函数

接口描述
Function<T,R>接收一个参数并返回结果的函数
BiFunction<T,U,R>接受两个参数并返回结果的函数
DoubleFunction<R>接收一个double类型的参数并返回结果的函数
DoubleToIntFunction接收一个double类型的参数并返回int结果的函数
DoubleToLongFunction接收一个double类型的参数并返回long结果的函数
IntFunction<R>接收一个int类型的参数并返回结果的函数
IntToDoubleFunction接收一个int类型的参数并返回double结果的函数
IntToLongFunction接收一个int类型的参数并返回long结果的函数
LongFunction<R>接收一个long类型的参数并返回结果的函数
LongToDoubleFunction接收一个long类型的参数并返回double结果的函数
LongToIntFunction接收一个long类型的参数并返回int结果的函数
ToDoubleBiFunction<T,U>接收两个参数并返回double结果的函数
ToDoubleFunction<T>接收一个参数并返回double结果的函数
ToIntBiFunction<T,U>接收两个参数并返回int结果的函数
ToIntFunction<T>接收一个参数并返回int结果的函数
ToLongBiFunction<T,U>接收两个参数并返回long结果的函数
ToLongFunction<T>接收一个参数并返回long结果的函数

Consumer消费者

接口描述
Consumer<T>提供一个T类型的输入参数,不返回执行结果
BiConsumer<T,U>提供两个自定义类型的输入参数,不返回执行结果
DoubleConsumer表示接受单个double值参数,但不返回结果的操作
IntConsumer表示接受单个int值参数,但不返回结果的操作
LongConsumer表示接受单个long值参数,但不返回结果的操作
ObjDoubleConsumer<T>表示接受object值和double值,但是不返回任何操作结果
ObjIntConsumer<T>表示接受object值和int值,但是不返回任何操作结果
ObjLongConsumer<T>表示接受object值和long值,但是不返回任何操作结果

Predicate谓语

接口描述
Predicate<T>对给定的输入参数执行操作,返回一个boolean类型的结果(布尔值函数)
BiPredicate<T,U>对给定的两个输入参数执行操作,返回一个boolean类型的结果(布尔值函数)
DoublePredicate对给定的double参数执行操作,返回一个boolean类型的结果(布尔值函数)
IntPredicate对给定的int输入参数执行操作,返回一个boolean类型的结果(布尔值函数)
LongPredicate对给定的long参数执行操作,返回一个boolean类型的结果(布尔值函数)

Supplier供应商

接口描述
Supplier<T>不提供输入参数,但是返回结果的函数
BooleanSupplier不提供输入参数,但是返回boolean结果的函数
DoubleSupplier不提供输入参数,但是返回double结果的函数
IntSupplier不提供输入参数,但是返回int结果的函数
LongSupplier不提供输入参数,但是返回long结果的函数

Operator操作员

接口描述
UnaryOperator<T>提供单个类型参数,并且返回一个与输入参数类型一致的结果
BinaryOperator<T>提供两个相同类型参数,并且返回结果与输入参数类型一致的结果
DoubleBinaryOperator提供两个double参数并且返回double结果
DoubleUnaryOperator提供单个double参数并且返回double结果
IntBinaryOperator提供两个int参数并且返回int结果
IntUnaryOperator提供单个int参数并且返回int结果
LongBinaryOperator提供两个long参数并且返回long结果
LongUnaryOperator提供单个long参数并且返回long结果

常用操作

求最大最小值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
List<BigDecimal> decimalList = Arrays.asList(
    new BigDecimal("1"),
    new BigDecimal("2"),
    new BigDecimal("3"),
    new BigDecimal("-10"),
    null,
    new BigDecimal("0")
);

//过滤null,并取最大值
Optional<BigDecimal> max = decimalList.stream().filter(Objects::nonNull).max(BigDecimal::compareTo);
if (max.isPresent()) {
    BigDecimal maxdecimal = max.get();
}

//过滤null,并取最小值
Optional<BigDecimal> min = decimalList.stream().filter(Objects::nonNull).max(BigDecimal::compareTo);
if (max.isPresent()) {
    BigDecimal mindecimal = max.get();
}

求decimal积

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
List<BigDecimal> decimalList = List.of(
    new BigDecimal("1"),
    new BigDecimal("2"),
    new BigDecimal("3"),
    null,
    new BigDecimal("-10"),
    new BigDecimal("0")
);

//求decimalList所有元素乘积,并忽略null元素
String res = decimalList.stream().collect(Collector.of(
    () -> new BigDecimal[1],
    (a, t) -> {
        if (a[0] == null) {
            a[0] = BigDecimal.ONE;
        }
        if (t != null && t.compareTo(BigDecimal.ZERO) != 0) {
            a[0] = a[0].multiply(t);
        }
    },
    (a1, a2) -> {
        a1[0] = a1[0].multiply(a2[0]);
        return a1;
    },
    (a) -> a[0].toString()
));

切分list

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
List<String> arr=new ArrayList<>();
for (int i = 0; i < 10950; i++) {
    arr.add(String.valueOf(i));
}

int step = 100;

List<List<String>> lists = Stream.iterate(0L, n -> n + 1L)   //返回一个无限有序流 0123456.......
    .limit((arr.size() + step - 1) / step)   //指定最后返回的 list大小,
    .parallel()  //转换并行流
    .map(a -> arr.stream().skip(a * step)
         .limit(step).parallel()   //转换为并行流并进行归约
         .collect(Collectors.toList()))
    .collect(Collectors.toList());