函数式编程-常用的函数式接口

于 2022-11-12 17:15:30 发布
阅读量138 收藏
点赞数
分类专栏： Java工具箱 Java8新特性 文章标签： java jvm 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zs18753479279/article/details/127822705
版权

1 lambda作为参数和返回值

package com.stream.函数式编程.lambda作为参数和返回值;

/**
 * lambda作为参数和返回值
 *
 * @author zhaoshuai11
 * @date 2022/11/12
 */
public class LambdaAsParams {
    public static void main(String[] args) {
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " --> " + "Thread starting ...");
            }
        });

        startThread(() -> System.out.println(Thread.currentThread().getName() + " --> " + "Thread starting ..."));
    }

    /**
     * startThread
     *
     * @param runnable runnable
     */
    public static void startThread(Runnable runnable) {
        new Thread(runnable).start();
    }
}

/*
@FunctionalInterface
interface Runnable {
    public abstract void run();
}
*/


package com.stream.函数式编程.lambda作为参数和返回值;

import java.util.Arrays;
import java.util.Comparator;

public class LambdaAsReturn {
    public static void main(String[] args) {
        String[] strArr = {"aaa", "bbbb", "ddddd", "ss"};
        System.out.println(Arrays.toString(strArr));

        /**
         * public static <T> void sort(T[] a, Comparator<? super T> c)
         */
        Arrays.sort(strArr, getComparator());
        Arrays.sort(strArr, (o1, o2) -> o2.length() - o1.length());
        System.out.println(Arrays.toString(strArr));

    }

    /**
     * 定义一个方法-getComparator，方法的返回值是一个函数式接口Comparator<String>
     *
     * @return {@link Comparator}<{@link String}>
     */
    public static Comparator<String> getComparator() {
//        return new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o2.length() - o1.length();
//            }
//        };
        return (o1, o2) -> o2.length() - o1.length();
    }
}

2 lambda延时运行

package com.stream.函数式编程.lambda延时运行;

/**
 * 存在性能浪费问题: printLogByLevel()-传递的第二个参数是一个拼接后的字符串，先把字符串拼接，然后再调用printLogByLevel()。
 * 若日志级别 != 1，就造成性能的浪费。
 *
 * @author zhaoshuai11
 * @date 2022/11/12
 */
public class DelayRunning {
    public static void main(String[] args) {
        String msg_1 = "... msg 1 ...";
        String msg_2 = "... msg 2 ...";
        printLogByLevel(1, msg_1 + msg_2);
    }

    /**
     * printLogByLevel
     *
     * @param level level
     * @param msg   msg
     */
    public static void printLogByLevel(Integer level, String msg) {
        if (level == 1) {
            System.out.println(msg);
        }
    }
}



package com.stream.函数式编程.lambda延时运行;

/**
 * DelayRunningByLambda
 * lambda-延时运行
 * 优势：lambda作为参数，仅仅是把参数传递到printLogByLevel()。
 * 只有满足条件-才会调用MsgBuilder.buildMsg()；
 * 若不满足条件-不会调用MsgBuilder.buildMsg()；
 * 所以不会存在性能浪费。
 *
 * @author zhaoshuai11
 * @date 2022/11/12
 */
public class DelayRunningByLambda {
    public static void main(String[] args) {
        String msg_1 = "... msg 1 ...";
        String msg_2 = "... msg 2 ...";
        printLogByLevel(1, () -> msg_1 + msg_2);
    }

    /**
     * 打印日志级别
     * printLogByLevel
     *
     * @param level      level
     * @param msgBuilder msgBuilder
     */
    public static void printLogByLevel(Integer level, MsgBuilder msgBuilder) {
        if (level == 1) {
            System.out.println(msgBuilder.buildMsg());
        }
    }
}

/**
 * MsgBuilder
 *
 * @author zhaoshuai11
 * @date 2022/11/12
 */
@FunctionalInterface
interface MsgBuilder {
    String buildMsg();
}

3 ConsumerInterface

package com.stream.函数式编程.常用的函数式接口.ConsumerInterface;

import com.google.common.collect.Lists;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

/**
 * ConsumerTest-消费式函数式接口
 *
 * @author zhaoshuai11
 * @date 2022/11/12
 */
public class ConsumerTest {
    public static void main(String[] args) {
        List<Integer> listNew = Lists.newArrayList();
        /**
         *         Consumer<Integer> processor = new Consumer<Integer>() {
         *             @Override
         *             public void accept(Integer value) {
         *                 putIntegerToList(listNew, value);
         *             }
         *         };
         */
        Consumer<Integer> processor = value -> putIntegerToList(listNew, value);
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        /**
         *         for (Integer integer : list) {
         *             processor.accept(integer);
         *         }
         */
        list.forEach(processor);
        System.out.println(listNew);
    }

    public static void putIntegerToList(List<Integer> list, Integer value) {
        list.add(value);
    }
}


package com.stream.函数式编程.常用的函数式接口.ConsumerInterface;

import cn.hutool.core.util.StrUtil;
import com.google.common.collect.Lists;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerTestAndThen {
    public static void main(String[] args) {
//        andThenTest();
        formatInfo();
    }

    /**
     * formatInfo
     */
    private static void formatInfo() {
        List<String> list = Lists.newArrayList();
        String[] array = {"迪丽热巴,女", "古力娜扎,女", "马儿扎哈,男"};
        Consumer<String> processor = info -> {
            String[] split = info.split(StrUtil.COMMA);
            list.add("姓名:" + split[0] + " " + "性别:" + split[1]);
        };
        Arrays.asList(array).forEach(processor);
        System.out.println(list);
    }

    /**
     * andThenTest
     */
    private static void andThenTest() {
        List<String> list_1 = Lists.newArrayList();
        List<String> list_2 = Lists.newArrayList();
        Consumer<String> processor_1 = e -> list_1.add(e.toLowerCase());
        Consumer<String> processor_2 = e -> list_2.add(e.toUpperCase());
        /**
         *         Consumer<String> action = processor_1.andThen(processor_2);
         *         for (String s : Arrays.asList("hEllo", "World")) {
         *             action.accept(s);
         *         }
         */
        Arrays.asList("hEllo", "World")
                .forEach(processor_1.andThen(processor_2));
        System.out.println(list_1);
        System.out.println(list_2);
    }
}

4 SupplierInterface

package com.stream.函数式编程.常用的函数式接口.SupplierInterface;

import java.util.function.Supplier;

/**
 * @FunctionalInterface 用来获取一个泛型参数指定类型的对象数据类型
 * public interface Supplier<T> {
 * T get();
 * }
 */
public class SupplierTest {
    public static void main(String[] args) {
        String string = getString(() -> "hello supplier");
        System.out.println(string);
    }

    /**
     * 生产型接口-supplier
     *
     * @param supplier 函数式-Supplier<String> supplier
     * @return {@link String}
     */
    public static String getString(Supplier<String> supplier) {
        return supplier.get();
    }
}


package com.stream.函数式编程.常用的函数式接口.SupplierInterface;

import com.google.common.collect.Lists;

import java.util.Collections;
import java.util.function.Supplier;

/**
 * @FunctionalInterface
 * public interface Supplier<T> {
 * T get();
 * }
 */
public class MaxValue {
    public static void main(String[] args) {
        Integer[] arrValue = {1, 2, 100, 0, 99};
        /**
         *         Supplier<Integer> processor = new Supplier<Integer>() {
         *             @Override
         *             public Integer get() {
         *                 return Collections.max(Lists.newArrayList(arrValue));
         *             }
         *         };
         */
        Supplier<Integer> processor = () -> Collections.max(Lists.newArrayList(arrValue));
        System.out.println(processor.get());
    }
}

5 PredicateInterface

package com.stream.函数式编程.常用的函数式接口.predicateInterface;

import cn.hutool.core.util.StrUtil;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * PredicateInterface
 * 对某种数据类型的数据进行判断，结果返回一个Boolean
 *
 * @author zhaoshuai11
 * @FunctionalInterface
 * public interface Predicate<T> {
 * boolean test(T t);
 * }
 * @date 2022/11/12
 */
public class PredicateInterface {
    public static void main(String[] args) {
        predicateInfoTest();
    }

    /**
     * predicateTest
     */
    public static void predicateTest() {
        /**
         *         Predicate<String> processor = new Predicate<String>() {
         *             @Override
         *             public boolean test(String fistName) {
         *                 return fistName.equals("zhaoShuai11");
         *             }
         *         };
         */
        Predicate<String> processor = fistName -> fistName.equals("zhaoShuai11");
        List<String> list = Arrays.asList("zhaoshuai11", "zhaoShuai11");
        list.stream()
                .filter(processor)
                .forEach(System.out::println);
    }

    /**
     * andPredicateTest
     */
    public static void andOrPredicateTest() {
        List<String> list = Arrays.asList("zhao", "zhaoShuai11");
        /**
         * fun1
         *         Predicate<String> processor = new Predicate<String>() {
         *             @Override
         *             public boolean test(String str) {
         *                 return str.length() > 5 && str.contains("a");
         *             }
         *         };
         */
        System.out.println("-------and---------");
        Predicate<String> processor = str -> str.length() > 5 && str.contains("a");
        list.stream()
                .filter(processor)
                .forEach(System.out::println);

        Predicate<String> processor_1 = str -> str.length() > 5;
        Predicate<String> processor_2 = str -> str.contains("a");
        list.stream()
                .filter(processor_1.and(processor_2))
                .forEach(System.out::println);

        System.out.println("-------or---------");
        Predicate<String> processor_or = str -> str.length() > 5 || str.contains("a");
        list.stream()
                .filter(processor_or)
                .forEach(System.out::println);

        Predicate<String> processor_3 = str -> str.length() > 5;
        Predicate<String> processor_4 = str -> str.contains("a");
        list.stream()
                .filter(processor_3.or(processor_4))
                .forEach(System.out::println);

        System.out.println("--------negate--------");
        Predicate<String> processor_negate = str -> str.length() > 5 || str.contains("a");
        list.stream()
                .filter(processor_negate.negate())
                .forEach(System.out::println);
    }

    private static void predicateInfoTest() {
        List<String> list;
        String[] array = {"迪丽热巴,女", "古力娜扎,女", "马儿扎哈,男"};
        Predicate<String> processor = str -> {
            String[] split = str.split(StrUtil.COMMA);
            return split[0].length() == 4 && split[1].equals("女");
        };
        list = Arrays.stream(array)
                .filter(processor)
                .collect(Collectors.toList());
        System.out.println(list);
    }
}

6 FunctionInterface

package com.stream.函数式编程.常用的函数式接口.FunctionInterface;

import com.google.common.collect.Lists;

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;


/**
 * @author zhaoshuai11
 * @FunctionalInterface public interface Function<T, R> {
 * R apply(T t);
 * }
 * 根据一个数据类型的数据得到另一个数据类型的数据，前者T称之为前置条件，后者R称之为后置条件。
 * @date 2022/11/12
 */
public class FunctionTest {
    public static void main(String[] args) {
        functionInfoTest();
    }

    /**
     * string2Integer
     */
    public static void string2Integer() {
        List<Integer> list;
        String[] array = {"111", "234", "355"};
        Function<String, Integer> processor = Integer::parseInt;
        list = Arrays.stream(array)
                .map(processor)
                .collect(Collectors.toList());
        System.out.println(list);
    }

    /**
     * andThenFunction
     * 1、String -> Integer
     * 2、Integer + 10
     * 3、Integer -> String
     */
    public static void andThenFunction() {
        String[] array = {"111", "234", "355"};
        List<String> list = Lists.newArrayList();

        Function<String, String> processor = t -> String.valueOf(Integer.parseInt(t) + 10);
        list = Arrays.stream(array)
                .map(processor)
                .collect(Collectors.toList());
        System.out.println(list);

        Function<String, Integer> processor_1 = e -> Integer.parseInt(e) + 10;
        Function<Integer, String> processor_2 = String::valueOf;
        list = Arrays.stream(array)
                .map(processor_1.andThen(processor_2))
                .collect(Collectors.toList());
        System.out.println(list);
    }

    /**
     * functionInfoTest
     */
    private static void functionInfoTest() {
        String str = "杨幂,20";
        Function<String, Integer> processor = e -> Integer.parseInt(e.split(",")[1]) + 100;
        System.out.println(processor.apply(str));
    }
}
@Autowire
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hutool 基础工具包 v4.0.5
11-07
Hutool是一个Java基础工具类，对文件、流、加密解密、转码、正则、线程、xm<x>l等JDK方法进行封装，组成各种Util工具类，同时提供以下组件： 布隆过滤 缓存 克隆接口 类型转换 日期处理
【Java接口系列】 consumer接口
wang2leee的博客
08-21 340
Consumer是Java 8中的一个函数式接口，它属于包。该接口定义了一个具有单个输入参数并且没有返回值的操作方法accept()。
《Java8实战》读书笔记01：Lambda 和 函数式接口
湖边的小屋圣迹
10-31 373
Java8学习笔记 - 在哪里可以使用Lambda表达式 + 什么是函数式接口定义举例 定义 你可以在函数式接口上使用Lambda表达式。 函数式接口就是只定义了一个抽象方法的接口。 举例 定义一个函数式接口 public interface NameFormat{ String format(String str); } 定义一个方法，它可以接收函数式接口类型的参数 public void showName(String name, NameFormat f){
How to use Java functional Consumer interface example
wxg_wll的博客
06-22 165
Quite often a Java Stream or other component needs an object passed to it in order to perform some type of calculation or process, but when the process is complete, nothing gets returned from the method. This is where Java’s functional Consumer interface c
Hutool不糊涂（一）
jui121314的博客
10-13 7924
目录 ●Hutool是什么？ ●最甜的几块糖（Part 1） ●类型转换  ●日期与时间 ●字段验证器 ●配置工具 ●日志工具 ●Hutool是什么？ 接下来的两篇文章，笔者将给大家安利一个能够明显提升Java开发效率的开源项目Hutool。官方对其描述为：A set of tools to keep java sweet。它其实是一套Java工具包，提供了许多与业务无关的常用方...
0202年了，还没有用上Java函数式编程！！！——Lambda表达式
12-21
——Lambda表达式函数式编程是什么命令式编程(Imperative)声明式编程(Declarative)函数式编程(Functional)总结函数式编程的好处Lambda表达式函数式接口五种形式1.无参数2.有单个参数3.有多个参数4.实现有多行5.带...
java经典面试题目-面经-java-Java语言的进阶概念-常用的库和框架-并发编程-网络编程-Web开发-面经
最新发布
01-20
什么是Java中的函数式接口？列举一些常见的函数式接口。 什么是Java中的Stream API？它的作用和使用场景是什么？ Java中的GC（垃圾回收）是什么？如何手动触发对象的垃圾回收？ 什么是Java中的设计模式？列举一些...
matlab常用函数大全
06-20
3、编程语言结构 3.1 控制语句 3.2 计算运行 3.3 脚本文件、函数及变量 3.4 参数处理 3.5 信息显示 3.6 交互式输入 4、基本矩阵函数和操作 4.1 基本矩阵 4.2 矩阵基本信息 4.3 矩阵操作 4.4 ...
linux网络编程socket框架总结
09-24
要学Internet上的TCP/IP网络编程，必须理解Socket接口 Socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话，就很容易了解Socket了。网络的 Socket数据传输是一种特殊的I/O，...
宋劲彬的嵌入式C语言一站式编程
03-12
2.1. 函数式宏定义 2.2. 内联函数 2.3. #、##运算符和可变参数 2.4. 宏展开的步骤 3. 条件预处理指示 4. 其它预处理特性 22. Makefile基础 1. 基本规则 2. 隐含规则和模式规则 3. 变量 4. 自动处理头文件的依赖关系 ...
Java中StringBuild
yy
09-06 4588
目录 StringBuild StringBuild构造方法 StringBuild的添加和反转方法 StringBuilder和 String相互转换 我们已经知道了String值在创建后不能修改。实际上是能“修改”的，只不过这里是将内存地址替换了而已，所以看起来值还是被修改了。详细可看——>Java 中String构造方法中的String构造方法 如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费内存空间，而这种操作还不可避免。那么有没有一种...
常见的函数式接口介绍
技术积累，技术分享
06-17 1311
了解常见的函数式接口
四种常见函数式接口
Peace_and_love_的博客
08-06 1598
消费型函数式接口 Consumer<T> 常用于遍历 void accpet(T t) 供给型函数式接口 Supplier<T> 用于产生数据 T get() 断言型函数式接口 Predicate<T> 用于判断 boolean test(T t) 函数型函数式接口 Function<T,R> 用于逻辑处理 R apply(T t) @FunctionalInterface 注解用于判断一个接口是不是函数式接口 public class Lamb.
Consumer接口的简介与使用
awake_lqh的博客
02-20 1254
前言： 最近在看公司源码的时候发现了这么个Consumer接口的时候，但是蒙蔽的了一阵。百度后才知其然。然后到现在我还是不知道为啥要多次一举。。。 Consumer接口 Consumer接口是Java一系列函数式接口中的一个。上源码 @FunctionalInterface public interface Consumer<T> { void accept(T t); } accept方法：接收一个对象，然后消费该对象来执行对应的逻辑代码 例子： Stuend类 public cla
Consumer接口
weixin_44230693的博客
02-18 3093
Consumer接口 java.util.function.Consumer 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据， 其数据类型由泛型决定。 1、抽象方法：accept Consumer 接口中包含抽象方法 void accept(T t) ，意为消费一个指定泛型的数据。基本使用如： /* * Consumer接口是一个消费型接口，泛型执行什么类型，就可以使用accept方法消费什么类型的数据 * 至于具体怎么消费(使用)，需要自定义(输出，计算....) * */ p
【java笔记】常用接口（2）：Consumer接口
暮色年华的博客
03-06 3306
Consumer接口是一个消费型接口，泛型指定什么类型，就可以使用accept消费什么类型数据 直接输出： public class Demo { public static void main(String[] args) { method("asd",(name)-> System.out.println(name)); } public static void method(String name, Consumer<String>c.
java函数式编程之Consumer
z345434645的专栏
12-21 1万+
描述：Consumer< T>接口接受一个T类型参数，没有返回值。源码如下：public interface Consumer<T> { /** * Performs this operation on the given argument. * * @param t the input argument */ void accept(T t);
JAVA8 Consumer接口
热门推荐
鸭鸭的博客
06-08 8万+
Consumer的语义是消费的意思，了解一些消息队列的同学，肯定对这个单词，有一定的理解，我们先看接口的定义 @FunctionalInterface public interface Consumer<T> { void accept(T t); default Consumer<T> andThen(Consumer<? supe...
java8中的函数式接口Consumer的用处（@FunctionalInterface）
river66的博客
08-23 1898
先了解下这个单词的意思：Consumer [kənˈsjuːmə(r)] ：消费者 既然是消费者，那么它消费的是什么呢？先说结论：消费的是函数（或是代码段），封装的是逻辑代码。 先看看，如果我们要遍历一个List集合，一般我们会这么写： List<String> list = new ArrayList<>(); list.add("aa"); list.add("bb"); for (String s : list) { System.out.println(s).
java 函数式编程 reduce
10-17
Java中的reduce函数是函数式编程中的一个常用操作，它可以将一个集合中的所有元素通过指定的操作进行累加或者合并。在Java 8中，reduce函数被定义在Stream接口中，其函数签名如下： ``` T reduce(T identity, ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值