Java8中四种基础函数式接口

最新推荐文章于 2024-06-20 14:41:40 发布
最新推荐文章于 2024-06-20 14:41:40 发布
阅读量2.3k 收藏 11
点赞数 6
分类专栏： java 文章标签： lambda stream filter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35461948/article/details/110234767
版权

目录

Java8中四种基础函数式接口

1，函数式接口 Function：apply

接口： Function,>

基础：

apply的使用

2，断言式接口 Predicate：test

基础：

使用

3，消费式接口 Consumer：accept

4，供给式接口 Supplier： get

总结

 

Java8中四种基础函数式接口

 

函数式接口

参数类型

返回类型

用途

举例

Function<T, R>{R apply(T t);} 

T，R

R

给定指定类型T的参数，返回R类型的结果，将函数限定。

对内容进行处理。比如给一张白纸，返回一张好看的画

Predicate{boolean test(T t);} 
 

T

boolean

给定指定类型T的参数，计算出断言式的boolean型结果

对内容进行过滤。比如公司招人，选适合的人

Consumer{void accept(T t);} 
 

T

void

给定类型为T的参数，执行操作

对内容进行输出。比如在超市买东西，打印的小票，这样就可以看到明细了

Supplier{T get();} 
 

void

T

获得给定类型T的结果，不传参数

 提供相似的内容。比如：用的铅笔没了，提供其他铅笔用

 

 

 

  Lambda表达式是函数式接口的基础，可以将 lambda 表达式视为一个对象，将其作为参数传递

 

 

1，函数式接口 Function：apply

 

接口： Function<T, R>


 

public interface Function<T, R> {

 

    R apply(T t);

  

    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {

        Objects.requireNonNull(before);

        return (V v) -> apply(before.apply(v));

    }

   

    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {

        Objects.requireNonNull(after);

        return (T t) -> after.apply(apply(t));

    }

  

    static <T> Function<T, T> identity() {

        return t -> t;

    }

}

 

apply: 应用,这个方法是最常见的

 

compose: 构成之前，在apply之前，先进行XX操作

 

andThen：构成之后，在apply之后，进行YY操作

 

 

identity: 唯一，在Collectors.toMap中使用，保证key对应的值的唯一性；

 

 

 

基础：


 

/**
 * Function是一个函数式接口，其中有四个方法 apply, compose, andThen, testIndetify()
 *   // 先执行输入的Function，其结果作为参数再作为调用者的Function的参数
 *     default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
 *         Objects.requireNonNull(before);
 *         return (V v) -> apply(before.apply(v));
 *     }
 *
 * // 先执行调用者的Function，其结果作为参数再作为输入的Function的参数
 *     default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
 *         Objects.requireNonNull(after);
 *         return (T t) -> after.apply(apply(t));
 *     }
 *
 */


public static void main(String[] args) {

    Function<String, String> applyFunc = s -> s.concat(" function ");
    Function<String, String> composeFunc = s -> s.concat(" compose ");
    Function<String, String> andThenFunc = s -> s.concat(" andThen ");
    System.out.println(applyFunc.apply("yan"));
    System.out.println(applyFunc.compose(composeFunc).apply(" yan "));
    System.out.println(applyFunc.andThen(andThenFunc).apply(" yan "));


    testComposeAndThen();
}

public static void testComposeAndThen(){
    int res1 = compute1(1, e -> e + 1); // 结果：2
    int res2 = compute2(2, e -> e + 3, e -> e * 3); // 结果：9
    int res21 = compute21(2, e -> e + 3, e -> e * 3); // 结果：15
    int res3 = compute3(3, e -> e + 4, e -> e * 3); // 结果：13
    int res31 = compute4(3, e -> e + 4, e -> e * 3); // 结果：14
    System.out.println(res1 + ", " + res2 + ", " + res21 + ", " + res3 + ", " + res31);
}



public static int compute1(int x, Function<Integer, Integer> function) {
    return function.apply(x);
}

public static int compute2(int x, Function<Integer, Integer> after, Function<Integer, Integer> before) {
    // x作为before的参数，其结果再作为after的参数
    return after.compose(before).apply(x);
}

public static int compute21(int x, Function<Integer, Integer> after, Function<Integer, Integer> before) {
    // x作为before的参数，其结果再作为after的参数
    return before.compose(after).apply(x);
}

public static int compute3(int x, Function<Integer, Integer> after, Function<Integer, Integer> before) {
    // x作为after的参数先执行after的计算，其结果再作为before的参数
    return before.andThen(after).apply(x);
}

public static int compute4(int x, Function<Integer, Integer> after, Function<Integer, Integer> before) {
    // x作为after的参数先执行after的计算，其结果再作为before的参数
    return after.andThen(before).apply(x);
}


public static void testIndetify(){
    List<Map<String, Object>> neIdList = new ArrayList<>();
    Map<String, Object> paas = new HashMap<>(8);
    paas.put("FILE_FIELD", "times");
    paas.put("AGG_TYPE", "sum");
    neIdList.add(paas);
    Map<String, Object> paas2 = new HashMap<>(8);
    paas2.put("FILE_FIELD", "times");
    paas2.put("AGG_TYPE", "sum2");
    neIdList.add(paas2);

    Map<String, Map<String, Object>> identifyMap =
            ListUtils.emptyIfNull(neIdList).stream()
                    .collect(Collectors.toMap(e -> MapUtils.getString(e, "FILE_FIELD"), Function.identity(), (x, y) -> x));
    System.out.println(identifyMap.toString());
}

 

 

apply的使用

 

public static void main(String[] args) {



    List<String> strList = Arrays.asList("orderType", "virtualOrderId", "cityCode");

    List<Integer> strSizeList = map(strList, String::length);

    strSizeList.forEach(System.out::println);

    List<Integer> numAddList = map(strSizeList, (Integer s) -> s + 100);

    numAddList.forEach(System.out::println);

    List<String> concatOne = map(strList, (String s) -> s.concat(" one"));

    concatOne.forEach(System.out::println);



}




public static <T, R> List<R> map(List<T> list, Function<T, R> func) {

    return ListUtils.emptyIfNull(list).stream().map(func).collect(Collectors.toList());

}
 

2，断言式接口 Predicate：test

 

Predicate:断言，使基于，我倾向于后者的理解，基于什么去判断

 

基础：

//    Stream<T> filter(Predicate<? super T> predicate);

    public static <T> List<T> filter(List<T> list, Predicate<T> p) {

        List<T> results = new ArrayList<>();

        for (T s : list) {

            if (p.test(s)) { // 判断是否符合条件

                results.add(s);

            }

        }

        return results;

    }





    public static void main(String[] args) {

        testEmpty();

        testFilterSize();

        testFilterValue();

    }



    public static void testEmpty() {

        Predicate<String> nonEmptyStrPre = (String s) -> !s.isEmpty();

        List<String> aa = Arrays.asList("Hello", "", "Predict", "123", "ok");

        List<String> nonEmpty = filter(aa, nonEmptyStrPre);

        nonEmpty.forEach(System.out::println);



        List<String> nonEmpty2 = filter(aa, s -> s.length() > 2);

        nonEmpty2.forEach(System.out::println);

    }



    public static void testFilterSize() {

        List<String> list = Arrays.asList("Hello", "Java8", "Lambda", "www", "ok");

        ListUtils.emptyIfNull(list).stream().filter(s -> s.length() > 3).collect(Collectors.toList());

        List<String> strList = filter(list, (s) -> s.length() > 3);

        strList.forEach(System.out::println);

    }



    public static void testFilterValue() {

        List<Integer> list = Arrays.asList(88, 44, 99, 980, 121212);

        List<Integer> strList = filter(list, (s) -> s > 300);

        strList.forEach(System.out::println);

    }

 

 

 

 

使用

 

// 在接口：Collection<E>

default boolean removeIf(Predicate<? super E> filter) {

        Objects.requireNonNull(filter);

        boolean removed = false;

        final Iterator<E> each = iterator();

        while (each.hasNext()) {

            if (filter.test(each.next())) {

                each.remove();

                removed = true;

            }

        }

        return removed;

}

 

3，消费式接口 Consumer：accept

Consumer 消费：主要是输出内容

public static void main(String[] args) {

    forEach(Arrays.asList(1, 2, 3, 4, 5), (Integer i) -> System.out.println(i));

    forEach(Arrays.asList("yan", "I", "wonder"), (String i) -> System.out.println(i));

}

public static <T> void forEach(List<T> list, Consumer<T> c) {

    for (T s : list) {

        c.accept(s);

    }

}
// 在接口：Iterable<T> 中

default void forEach(Consumer<? super T> action) {

            Objects.requireNonNull(action);

            for (T t : this) {

                action.accept(t);

            }

        }
public static void testConsumer1() {
    Consumer<String> consumer = s ->  LOGGER.info(s.concat(" 是一名拆书家"));
    consumer.accept("天天");
  }

 

4，供给式接口 Supplier： get

Supplier  提供同类型的数据内容，可以是单个或是多个，

 

public static void main(String[] args) {



    Random random = new Random();

    List<Integer> list = supplierSum(10, () -> random.nextInt(10));

    list.forEach(System.out::println);



}



public static List<Integer> supplierSum(int total, Supplier<Integer> sup) {

    List<Integer> list = new ArrayList<>();

    for (int i = 0; i < total; i++) {

        list.add(sup.get());

    }

    return list;

}

 

总结

       四个基础函数式编程接口中，Function 和 Predicate 会用得比较多，在steam中的 方法map （<R> Stream<R> map(Function<? super T, ? extends R> mapper); ） 和 filter方法 （Stream<T> filter(Predicate<? super T> predicate)），用到的频率就很高。

      在函数编程的理解中，主要是理解基础lambda可以作为一个参数进行传递。

 

 

 

 

 

天狼1222
关注
  • 6
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
java apply 例子_Java8常用示例
weixin_26820427的博客
02-27 3865
HashMapputIfAbsentdefault V putIfAbsent(K key,V value)If the specified key is not already associated with a value (or is mapped tonull) associates it with the given value and returnsnull, else retur...
Java8新特性 - 03 - 函数式接口04 - Function 详解
northcastle的博客
02-21 634
1.Function 接口说明 核心方法 R apply(T t) : 有 参数，有返回值 * 说明 ： * 1.接口名称 ： Function * 2.方法 * R apply(T t) : 传入参数t,返回数据R * default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) ： 连续操作 * default <
【Java 8 新特性】Java 8中的Function.apply方法
热门推荐
猫巳的博客
05-18 3万+
Java 8中的Function.apply方法参考文献 java.util.function.Function是一个接口，已经在Java 8中引入。 Function是一个函数接口。 因此它可以用来接受lambda表达式。 函数接受一个参数并返回结果。 函数接口包含一种方法apply()。 这是函数接口方法。 查找apply()方法的声明。 R apply(T t) 其中T是函数参数，R是结果。 要使用它，我们需要定义功能。 假设我们在学生类中有一个方法customShow()，它将接受Function
java中函数式编程apply的用法实例？
最新发布
gb4215287的博客
06-20 307
java中函数式编程apply的用法实例？
【JAVA】java8 function apply() compose() andThen()
weixin_30820077的博客
08-13 523
public static void main(String[] args) { Function<Integer, Integer> plus = i -> i + 1; Function<Integer, Integer> mult = i -> i * i; System.out.println(...
Java8函数式接口
ldk99_的博客
04-07 647
这个包下定义了许多函数式接口（这类接口只定义了唯一的抽象方法，并且这类接口使用了@FunctionalInterface进行注解），大致分为了以下四类： Function: 接收参数，并返回结果，主要方法 R apply(T t) Consumer: 接收参数，无返回结果, 主要方法为 void accept(T t) Supplier: 不接收参数，但返回结构，主要方法为 T get() Predicate: 接收参数，返回boolean值，主要方法为 boolean test(T t) 再细
Java 8 新特性 （#Lambda表达式 #函数式(Functional)接口 #方法引用与构造器引用 #Stream API #Optional类）
m0_58052874的博客
09-20 454
函数式接口中使用泛型}用Lambda表达式实例化自定义函数接口@Test//***********常规写法***************"@Overridereturn s;}}//***********Lambda表达式写法***************"}当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！方法引用，本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例。所以方法引用，也是函数式接口的实例。
java8-函数式接口.pdf
07-08
函数式接口和 Lambda 表达式是 Java 8 引入的重要功能，它们使得代码更加简洁，易于理解和维护，同时也为函数式编程提供了基础。通过熟练掌握这些概念，你可以更好地利用 Java 8 的新特性，提高代码的可读性和效率。
浅析Java8新特性Lambda表达式和函数式接口
08-29
Java 8 新特性 Lambda 表达式和函数式接口 Java 8 中引入的 Lambda 表达式是一种可以传递的代码，旨在简化代码，提高代码的可读性。 Lambda 表达式基于数学中的&lambda;演算得名，直接对应于其中的 lambda 抽象（lambda ...
Java的函数式接口讲解代码（ 函数式接口定义、 函数式接口实战、内置函数式接口...）
06-27
本源码资源提供了Java中的函数式接口相关内容，包括接口定义和使用示例。它涵盖了函数式编程在Java中的基本概念、重要性以及如何使用函数式接口来实现函数式编程的方法。 本源码资源适用于具备一定Java编程基础的...
深入了解java 8的函数式编程
08-25
此外，函数式接口如Runnable、Callable和Consumer等，也为函数式编程提供了基础。 总之，Java 8的函数式编程特性使得Java开发者能够利用更简洁、更具表达力的代码来解决问题，尤其是处理大量数据时。尽管Java的类型...
动力节点_Java基础视频教程167_函数式接口注解
12-03
动力节点的Java课程适合绝对零基础的观看，教程中讲解了Java开发环境搭建、Java的基础...适合非计算机专业，想转行做Java开发的朋友，或者想让Java基础更扎实的小伙伴，配套资料下载：http://www.bjpowernode.com/?csdn
Java8新特性_Lambda 练习
小汤圆
08-27 241
作为参数传递Lambda表达式 作为参数传递 Lambda 表达式：为了将 Lambda 表达式作为参数传递，接收 Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型。 1.调用 Collections.sort() 方法，通过定制排序比较两个 Employee（先按年龄比，年龄相同按姓名比），使用 Lambda 作为参数传递。 2. ① 声明函数式接口，接口中声明抽象方法， public String getvalue(String str)； ② 声明类 Testlam
java8 block_java8的CompletableFuture使用实例
weixin_39940154的博客
02-25 90
thenApply(等待并转化future)@Testpublic void testThen() throws ExecutionException, InterruptedException {CompletableFuture f1 = CompletableFuture.supplyAsync(() -> {return "zero";}, executor);Completable...
JAVA中apply方法的原理_关于学习java函数式接口Function中的apply方法的一些感悟
weixin_33196106的博客
03-02 3583
起因是这样的,学习函数式编程的时候学到了Function接口,对于其中的apply方法感到不解,下面贴上我的不解代码在这里插public class Function接口 {public static void main(String[] args) {String s="1234";method(s,(String a)->{**return Integer.parseInt(a);**}...
JAVA Stream 中 Function＜T, R＞ 中 apply，compose， andThen 方法学习总结
weixin_44131922的博客
06-06 2257
Stream 中的 Function 实际上解决了一个简单的问题，那就是我们在实际书写代码的时候，一个方法一般只能作为代码中的某一行函数，用于处理里面的数值，但是并不能将一个方法作为一个参数，将方法以参数的形式将方法传递到下一个方法中继续使用。compose 看内部实现，这个方法的入参也为 Function 类型，当调用时会先执行 作为入参的 Function 中的apply 方法，再将计算的结果作为原有方法的 apply 入参。apply 的作用为执行当前方法函数，t 为入参，R 为返回值类型。
Java8 函数式接口
weixin_34122604的博客
01-26 206
2019独角兽企业重金招聘Python工程师标准>>> ...
java8中函数特性
libaowenBlog的博客
04-30 1万+
使用注解 @FunctionalInterface 标识，并且只包含一个 抽象方法 的接口是 函数式接口 1.Function 有参有返回型函数、Function 函数的表现形式为接收一个参数，并返回一个值 2.Consumer 消费型函数、Consumer函数的表现形式为接收一个参数，没有返回值 3.Supplier 供给型函数、表现形式为 不接受参数、只返回数据 4.Runnable 无参无返回型函数、表现形式为无参无返回型函数 例子一: /** * 将该函数应用到给.
【Java8】函数式接口
祝我飞黄腾达
05-17 3021
一、前言 早期的程序员在JDK1.5时期，掌握泛型、枚举、反射 基本上就可以了，随着JDK不断迭代升级，到相对于稳定的JDK1.8版本，扩展了大量的知识点，例如：lambda表达式，链式编程，函数式接口，Stream流式计算 这些新知识点的出现大大的简化了编程模型，减少了很多冗余代码，代码简洁，清晰明了，并且在迭代出来的底层架构大量得到了应用，所以，我们必须随着主流进行学习，避免阅读源码时都不知道其意。 二、函数式接口(Functional Interface) 函数式接口：只有一个方法的接口.
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天狼1222

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值