java8函数式编程实例

什么是函数式编程

函数式编程是java8的一大特色,也就是将函数作为一个参数传递给指定方法。别人传的要么是基本数据类型,要么就是地址引用 ,我们要穿一个“动作”。

Stream

说到函数式编程,就不得不提及Stream,Stream跟我们熟知的io流可不是同一个东西,泛指可以顺序执行或者并行执行的元素序列,主要是针对集合,可以将多个函数通过“.”串起来执行,其特点如下:

  • stream不会存储数据,只是将集合流化,比如说 声明一个stream之后,往集合里面扔东西,stream可以取到新扔到集合里面的数据,你可以理解为操作时stream会实时从堆中的集合对象提取数据。
  • stream不会改变原集合,我的理解是stream 是一堆元素顺序或者并行执行我们串起来的函数,改变后并不会对集合中的元素造成影响。
  • steam是延迟执行的,也就是说在聚合操作之前 的其他操作,都会阻塞,直到执行聚合函数,其他的函数才开始一并执行。

解析相关接口

我们看看跟函数式编程相关的接口

java.long.FunctionalInterface是一个注解接口,函数接口都会实现它,看看它有什么特别的

从这里我们可以看出来一个函数接口只有一个抽象方法,但是如果要加一切其他的功能怎么办呢?接口中添加功能的话相当麻烦,接口相关实现类都需要修改,接下来“default”就登场了

default方法只能在接口出现,它不是抽象方法,可以通过methodInstance.isDefault()辨认,咦,弄啥勒,接口还能有普通方法?是的你没看错,添加default方法是为了方便修改接口,不至于每次修改过后都要将他的“儿子,孙子”等实现一一修改;如果在接口中default修饰的方法不加body会怎么样呢?   没错, 会编译失败!贴图:

接口中的default方法不用强制在实现类中 出现,当然业务需要的话,也可以重写来进行多态;

下面是java.util.function中的函数接口描述

序号 接口 & 描述
1 BiConsumer<T,U>

代表了一个接受两个输入参数的操作,并且不返回任何结果

2 BiFunction<T,U,R>

代表了一个接受两个输入参数的方法,并且返回一个结果

3 BinaryOperator<T>

代表了一个作用于于两个同类型操作符的操作,并且返回了操作符同类型的结果

4 BiPredicate<T,U>

代表了一个两个参数的boolean值方法

5 BooleanSupplier

代表了boolean值结果的提供方

6 Consumer<T>

代表了接受一个输入参数并且无返回的操作

7 DoubleBinaryOperator

代表了作用于两个double值操作符的操作,并且返回了一个double值的结果。

8 DoubleConsumer

代表一个接受double值参数的操作,并且不返回结果。

9 DoubleFunction<R>

代表接受一个double值参数的方法,并且返回结果

10 DoublePredicate

代表一个拥有double值参数的boolean值方法

11 DoubleSupplier

代表一个double值结构的提供方

12 DoubleToIntFunction

接受一个double类型输入,返回一个int类型结果。

13 DoubleToLongFunction

接受一个double类型输入,返回一个long类型结果

14 DoubleUnaryOperator

接受一个参数同为类型double,返回值类型也为double 。

15 Function<T,R>

接受一个输入参数,返回一个结果。

16 IntBinaryOperator

接受两个参数同为类型int,返回值类型也为int 。

17 IntConsumer

接受一个int类型的输入参数,无返回值 。

18 IntFunction<R>

接受一个int类型输入参数,返回一个结果 。

19 IntPredicate

:接受一个int输入参数,返回一个布尔值的结果。

20 IntSupplier

无参数,返回一个int类型结果。

21 IntToDoubleFunction

接受一个int类型输入,返回一个double类型结果 。

22 IntToLongFunction

接受一个int类型输入,返回一个long类型结果。

23 IntUnaryOperator

接受一个参数同为类型int,返回值类型也为int 。

24 LongBinaryOperator

接受两个参数同为类型long,返回值类型也为long。

25 LongConsumer

接受一个long类型的输入参数,无返回值。

26 LongFunction<R>

接受一个long类型输入参数,返回一个结果。

27 LongPredicate

R接受一个long输入参数,返回一个布尔值类型结果。

28 LongSupplier

无参数,返回一个结果long类型的值。

29 LongToDoubleFunction

接受一个long类型输入,返回一个double类型结果。

30 LongToIntFunction

接受一个long类型输入,返回一个int类型结果。

31 LongUnaryOperator

接受一个参数同为类型long,返回值类型也为long。

32 ObjDoubleConsumer<T>

接受一个object类型和一个double类型的输入参数,无返回值。

33 ObjIntConsumer<T>

接受一个object类型和一个int类型的输入参数,无返回值。

34 ObjLongConsumer<T>

接受一个object类型和一个long类型的输入参数,无返回值。

35 Predicate<T>

接受一个输入参数,返回一个布尔值结果。

36 Supplier<T>

无参数,返回一个结果。

37 ToDoubleBiFunction<T,U>

接受两个输入参数,返回一个double类型结果

38 ToDoubleFunction<T>

接受一个输入参数,返回一个double类型结果

39 ToIntBiFunction<T,U>

接受两个输入参数,返回一个int类型结果。

40 ToIntFunction<T>

接受一个输入参数,返回一个int类型结果。

41 ToLongBiFunction<T,U>

接受两个输入参数,返回一个long类型结果。

42 ToLongFunction<T>

接受一个输入参数,返回一个long类型结果。

43 UnaryOperator<T>

接受一个参数为类型T,返回值类型也为T。

除了上面列出的,还有个别函数接口没列出来,例如Comparator(), 但总归是个函数接口都会基于FunctionalInterface注解

总结

这些函数主要还是分为几个主要函数,其余都是以其为基础的分化;

  • Supplier<T> 无参数,返回一个结果。
  • Consumer<T> 代表了接受一个输入参数并且无返回的操作。
  • Function<T,R> 接受一个输入参数,返回一个结果,返回的结果跟参数的类型无关。
  • Predicate<T> 接受一个输入参数,返回一个布尔值结果。
  • BinaryOperator<T> 代表了一个作用于于两个同类型操作符的操作,并且返回了操作符同类型的结果,xxxOperator 函数都是接受类型跟返回值类型相同。

而且,从上面五个主要函数接口命名也可以看出其作用,"Bi"作为前缀的都是属于二元操作,接受两个参数。

T1toT2是从接受T1类型参数,返回T2类型结果,比如IntToLongFunction 接受一个int类型参数,返回long类型结果。

实战1

下面我写了一个功能,拳击手有分组跟体重两个属性,然后给一组拳击手集合,根据小组或者体重级排序,用到的是Comparator(),也是一个函数接口

上码:

 
  1. /**
  2. * Created by zhanghe
  3. * 拳击手
  4. */
  5. public class Boxer {
  6. //分组
  7. private String group;
  8. //重量级
  9. private Integer weight;
  10. public Boxer(String group, Integer weight) {
  11. this.group = group;
  12. this.weight = weight;
  13. }
  14. public static <T> List<List<T>> divider(List<T> datas, Comparator<T> c) {
  15. //声明一个列表来接收各个分组
  16. List<List<T>> list = new ArrayList<>();
  17. for (T t : datas) {
  18. //通过isSameGroup 标识来判断分组是否已创建
  19. boolean isSameGroup = false;
  20. for (int i = 0; i < list.size(); i++) {
  21. //compare函数返回值为int,正数说明param1>param2,0说明param1=param2,负数说明param1<param2
  22. //这里用到的原理是将List列表datas中的各项与分组列表list中的元素比较(比较的规则由外面作为参数传递,这就是函数式编程),
  23. // 值为0表示规则相符即为同一组
  24. if (c.compare(t, list.get(i).get(0)) == 0) {
  25. isSameGroup = true;
  26. list.get(i).add(t);
  27. break;
  28. }
  29. }
  30. //比较完了发现没有规则相符的,即自成一系
  31. if (!isSameGroup) {
  32. List<T> e = new ArrayList<>();
  33. e.add(t);
  34. list.add(e);
  35. }
  36. }
  37. return list;
  38. }
  39. public static void main(String[] args) {
  40. List<Boxer> boxers = Arrays.asList(
  41. new Boxer("红队", 120),
  42. new Boxer("绿队", 180),
  43. new Boxer("蓝队", 200),
  44. new Boxer("绿队", 220),
  45. new Boxer("蓝队", 120),
  46. new Boxer("红队", 80),
  47. new Boxer("红队", 90),
  48. new Boxer("绿队", 240)
  49. );
  50. List<List<Boxer>> dividByGroup = divider(boxers, new Comparator<Boxer>() {
  51. @Override
  52. public int compare(Boxer o1, Boxer o2) {
  53. //分组一样 即认为 相同
  54. return o1.group.equals(o2.group) == true ? 0 : 1;
  55. }
  56. });
  57. System.out.println("根据小组区分:");
  58. dividByGroup.stream().forEach(e->{
  59. System.out.println(e);
  60. });
  61. List<List<Boxer>> dividByWeight = divider(boxers, new Comparator<Boxer>() {
  62. @Override
  63. public int compare(Boxer o1, Boxer o2) {
  64. //体重/100 即体重百分位相同 即认为 相同
  65. return (o1.weight / 100 - o2.weight / 100) == 0 ? 0 : 1;
  66. }
  67. });
  68. System.out.println("根据体重区分:");
  69. dividByWeight.stream().forEach(e->{
  70. System.out.println(e);
  71. });
  72. }
  73. @Override
  74. public String toString() {
  75. return "Boxer{" +
  76. "小组=‘" + group + ‘\‘‘ +
  77. ", 体重=" + weight +
  78. ‘}‘;
  79. }
  80. }

这个是结果

实战2

我用Predicate 写了个具有匹配功能的方法,当然 匹配的规则还是作为一个函数参数传递,撸码不是很优雅,只看功能就好~

闲话不多说,上码:

 
  1. List<Object> list = Arrays.asList(1, 2,"",100,"3", ‘c‘);
  2. List<Object> matchList = match(list, a -> {
  3. return a instanceof Integer && (Integer) a > 10;
  4. });
  5. System.out.println(matchList);//100
  6. Set set = new HashSet<>();
  7. set.add("haha");
  8. set.add(1);
  9. set.add(100);
  10. Set matchSet = match(set, a -> a instanceof Integer);
  11. System.out.println(matchSet);//[1, 100]
  12. String matchString = match("java", a -> {
  13. return a instanceof String && ((String) a).startsWith("j");
  14. });
  15. System.out.println(matchString);//java
  16. Integer noMatch = match(100, a -> {
  17. return a instanceof String && ((String) a).startsWith("j");
  18. });
  19. System.out.println(noMatch);//null
  20. }
  21. /**
  22. *
  23. * @param t 入参 需要匹配规则的参数
  24. * @param p 函数接口 匹配的动作
  25. * @param <T>
  26. * @return 验证成功 是集合 则只留匹配元素,是String,Integer ..匹配成功返回本身,反之返回null
  27. */
  28. public static <T> T match(T t, Predicate p) {
  29. if (t instanceof Collection) {
  30. if (t instanceof List) {
  31. t = (T) ((List) t).stream().filter(a -> p.test(a)).collect(Collectors.toList());
  32. }
  33. if (t instanceof Set) {
  34. t = (T) ((Set) t).stream().filter(a -> p.test(a)).collect(Collectors.toSet());
  35. }
  36. } else {
  37. if (!p.test(t)) {
  38. return null;
  39. }
  40. }
  41. return t;

原文地址:https://www.cnblogs.com/liuys635/p/11012723.html

时间: 2024-10-08 09:15:15

java8函数式编程实例的相关文章

Java8函数式编程 (一) 数据流和lambda表达式

JDK 1.8中引入了函数式编程(functional programming,FP),如果您已习惯OOP,一定会感到困惑:什么是函数式编程?这样的编程模式有什么好处? 本文将通过简单的实例令读者对函数式编程有一个大体的了解. 我们知道OOP是以类为基础的,程序中必须首先抽象和定义class.那么FP创建的基础是什么?或者说在Java 8中,至少需要了解什么知识点才能实现基本的函数式编程呢? 本文将首先介绍在Java 8中使用FP所需的基本知识点: Lambda表达式 数据流 基本实例 Map<

漫漫人生路,学点Jakarta基础-Java8函数式编程

接口默认方法 Java8版本以后新增了接口的默认方法,不仅仅只能包含抽象方法,接口也可以包含若干个实例方法.在接口内定义实例方法(但是注意需要使用default关键字) 在此定义的方法并非抽象方法,而是具有特定逻辑的实例方法. 举例说明:定义接口Animal,其中包含默认方法eat(). /** * Created by zjc on 2018/4/9. */ public interface Animal { void call(); default void eat() { System.o

Java8函数式编程的宏观总结

1.java8优势通过将行为进行抽象,java8提供了批量处理数据的并行类库,使得代码可以在多核CPU上高效运行. 2.函数式编程的核心使用不可变值和函数,函数对一个值进行处理,映射成另一个值. 3.Lambda表达式一种紧凑的.传递行为的方式. 4. 静态类型语言java8依旧是静态类型语言,javac依旧会在编译时,对参数类型进行检查. 5.函数接口只有一个抽象方法的接口,用作lamdba表达式的类型. 6.对核心类库的改进-Stream实现机制 整个过程:一系列惰性求值方法+最后一个及早求

Java8函数式编程-包教包会系列(一)

Oracle 公司于 2014 年 3 月 18 日发布 Java 8 ,距离现在已经有很长一段时间了,Java10也在2018年 3月 21日正式发布,并且Oracle宣布Java 语言将每隔 6 个月提供一次更新.Java语言不断更新迭代,然而很多Java程序员缺没有跟上技术更新的步伐!所以写下这篇系列文章,希望可以帮助大家入门Java8!话不多说,开始发车! 前言 宝刀未老的Java 1995年Sun公司推出的Java语言,从第一个版本诞生到现在已经有二十多年的了.时间若白驹过隙,转瞬即逝

Java8函数式编程(一):Lambda表达式类型与常用函数接口

[TOC] 1 前言 最近在看一些开源项目的源码,函数式编程风格的代码无处不在,所以得要好好学一下了. 2 Lambda表达式类型 无参数: Runnable noArguments = () -> System.out.println("Hello World!"); noArguments.run(); 一个参数: UnaryOperator<Boolean> oneArgument = x -> !x; System.out.println(oneArgu

Java8函数式编程(二):类比Spark RDD算子的Stream流操作

1 Stream流 对集合进行迭代时,可调用其iterator方法,返回一个iterator对象,之后便可以通过该iterator对象遍历集合中的元素,这被称为外部迭代(for循环本身正是封装了其的语法糖),其示意图如下: 除此之外,还有内部迭代方法,这正是这里要说明的集合的stream()方法返回的Stream对象的一系列操作,比如,要统计一个数字列表的偶数元素个数,当使用Stream对象的操作时,如下: List<Integer> list = new ArrayList<Integ

[三]java8 函数式编程Stream 概念深入理解 Stream 运行原理 Stream设计思路

Stream的概念定义   官方文档是永远的圣经~ 表格内容来自https://docs.oracle.com/javase/8/docs/api/   Package java.util.stream  一节部分原文内容的翻译 int sum = widgets.stream() .filter(b -> b.getColor() == RED) .mapToInt(b -> b.getWeight()) .sum(); 流操作被划分为中间和终端操作,并组合成流管道. 一条Stream管道由

java8 函数式编程入门官方文档中文版 java.util.stream 中文版 流处理的相关概念

前言 本文为java.util.stream 包文档的译文 极其个别部分可能为了更好理解,陈述略有改动,与原文几乎一致 原文可参考在线API文档 https://docs.oracle.com/javase/8/docs/api/ Package java.util.stream Description 一些用于支持流上函数式操作的类 ,例如在集合上的map-reduce转换.例如 int sum = widgets.stream() .filter(b -> b.getColor() == R

Java8函数式编程

在Java8的 java.util.function中包含以下几个接口 1.Function,先上源码 /* * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.util.function; import java.util.