老鸟必修代码精简技能：Lambda表达式

最新推荐文章于 2024-07-15 22:27:12 发布
最新推荐文章于 2024-07-15 22:27:12 发布
阅读量487 收藏
点赞数
文章标签： java 前端 开发语言
原文链接：https://mp.weixin.qq.com/s?__biz=MzU2NjkyNjIyOA==&mid=2247486546&idx=1&sn=0493eedbd159093f8632d5f872ac24c7&chksm=fca442a9cbd3cbbfaee574c46e0ac2a5a139d61f06a823e5547d8356d9ffd2ed084dea1c754c&scene=126&&sessionid=0
版权

点击上方“猿芯”，选择“设为星标”

后台回复"1024"，有份惊喜送给面试的你

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

1.1 语法组成

  1. 操作符为" -> " ，被称为 Lambda 操作符或箭头操作符;

  2. 将 Lambda 分为两个部分：

    1. 左侧:指定了 Lambda 表达式需要的参数列表；

    2. 右侧:指定了 Lambda 体，是抽象方法的实现逻辑，也即Lambda 表达式要执行的功能。

1.2 基本用法

1.2.1 未使用和使用Lambda表达式的区别
@Slf4j
public class TestLambda {
    
    //未使用和使用lambda表达式，对比
    static void testRunLambdaContrast(){
        // 不使用lambda表达式，创建一个线程
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                log.info("------ 不使用lambda表达式，创建一个线程 ------");
            }
        };
        // 启动线程
        new Thread(runnable1).start();

        // 使用lambda表达式，创建一个线程
        Runnable runnable2 = () -> log.info("------ 使用lambda表达式，创建一个线程 ------");
        // 启动线程2
        new Thread(runnable2).start();
    }
    
    public static void main(String[] args) {
        
        //测试 未使用和使用lambda表达式，对比
        testRunLambdaContrast();
        
    }
    
}

总结：未使用和使用Lambda表达式都可以实现抽象方法，但是使用Lambda方法后会更加简洁；

1.2.2 带一个参数没有返回值
1.2.2.1 带一个参数没有返回值 标准写法
// 借助java8中 消费型函数式接口，讲解基本用法
// 不使用lambda表达式实现
Consumer<String> consumer1 = new Consumer<String>() {
    @Override
    public void accept(String s) {
        log.info("------ 不使用lambda表达式，实现Consumer1接口，消费数据：{} ------",s);
    }
};

// 使用消费型接口1
consumer1.accept("kh96正在学习lambda表达式，标准写法");

// 使用lambda表达式，用法：带 1 个参数，没有返回值，标准写法
Consumer<String> consumer2 = (String s) -> {
    log.info("------ 使用lambda表达式，实现Consumer2接口，消费数据：{} ------",s);
};

// 使用消费型接口2
consumer2.accept("kh96正在学习lambda表达式，标准写法");
1.2.2.2 简化写法：一个参数，可以省略类型声明
//一个参数，可以省略类型声明
Consumer<String> consumer3 = (s) -> {
    log.info("------ 使用lambda表达式，实现Consumer3接口，消费数据：{} ------",s);
};

consumer3.accept("kh96正在学习lambda表达式，一个参数，可以省略类型声明");
1.2.2.3 简化写法：一个参数，可以省略小括号（没有参数，多个参数不能省略）
//一个参数，可以省略小括号（没有参数，多个参数不能省略）
Consumer<String> consumer4 = s -> {
    log.info("------ 使用lambda表达式，实现Consumer4接口，消费数据：{} ------",s);
};

consumer4.accept("kh96正在学习lambda表达式，一个参数，可以省略小括号");
1.2.2.4 简化写法：实现只有一条语句，可以省略大括号（有多条语句，不可以省略）
//实现只有一条语句，可以省略大括号（有多条语句，不可以省略）
Consumer<String> consumer5 = s -> log.info("------ 使用lambda表达式，实现Consumer3接口，消费数据：{} ------",s);

consumer5.accept("kh96正在学习lambda表达式，实现只有一条语句，可以省略大括号");
1.2.2.5 简化写法：实现有多条语句，不可以省略大括号
//实现有多条语句，不可以省略大括号
Consumer<String> consumer6 = s -> {
    log.info("------ 使用lambda表达式，实现Consumer3接口，消费数据：{} ------",s);
    log.info("------ 使用lambda表达式，实现Consumer3接口，消费数据：{} ------",s);
};

consumer6.accept("kh96正在学习lambda表达式，实现有多条语句，不可以省略大括号");
1.2.3 带多个参数，有返回值
1.2.3.1 未使用 lambda 表达式，用法：带多个参数，有返回值
// 借助Comparator接口，讲解多个参数
Comparator<Integer> comparator1 = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1.compareTo(o2);
    }
};

// 未使用lambda表达式，用法：带多个参数，有返回值
log.info("------ 不使用lambda表达式，实现Comparator接口，比较12,23的大小：{} ------",comparator1.compare(12,23));// 小于 -1,大于 1，等于 0
1.2.3.2 简化写法：省略参数类型，但是不可以省略小括号，一条语句省略大括号，跟返回值无关（不用手动加return）
//省略参数类型，但是不可以省略小括号，一条语句省略大括号，跟返回值无关（不用手动加return）
Comparator<Integer> comparator2 = (o1,o2) -> o1.compareTo(o2);

log.info("------ 使用lambda表达式，实现Comparator接口，比较23,12的大小：{} ------",comparator2.compare(23,12));// 大于 1
1.2.3.3 简化写法：多条语句不可以省略大括号，带返回值（需手动加return）
//多条语句不可以省略大括号，带返回值（需手动加return）
Comparator<Integer> comparator3 = (o1,o2) -> {
    log.info("------ 比较原数值为：{}，{}",o1,o2);
    return o1.compareTo(o2);
};
log.info("------ 使用lambda表达式，实现Comparator接口，比较22,22的大小：{} ------",comparator3.compare(22,22));// 等于 0

1.3 java8中提供的函数式接口

1.3.1 消费型接口 Consumer (方法有一个参数，没有返回值)
1.3.1.1 自定义方法 (使用接口的 void accept(T t) )
//自定义方法，带有一个消费型接口参数，可以实现一个方法，处理不同的业务场景
static void useConsumer(Double salary,Consumer<Double> consumerDate){
    consumerDate.accept(salary);
}
1.3.1.2 方法调用
static void testLambdaConsumer(){
    //场景，同一个接口，有多个实现，以前，必须要创建接口的多个实现类，现在使用lambda，把接口的实现交给调用方法传递

    //实现1：Tom发了5000工资，去买手机,模拟接口的第一个实现
    //以前，必须提供接口的实现类对象
    useConsumer(5000.0,salary -> log.info("Tom,工资：{}，5000买手机",salary));

    //实现1：Tom发了10000工资，去买手机,买平板，模拟接口的第二个实现
    //以前，必须提供接口的 两个 实现类对象
    useConsumer(10000.0,slary -> {
        log.info("JiMe工资：{}，5000买手机",slary);
        log.info("JiMe工资：{}，4000买平板",slary);
    });

}
1.3.1.3 测试结果

c96c026d07aa4ef9b3d58b5c90ce0d90.png

1.3.2 供给型接口 Supplier(方法没有参数，可以返回任意类型的结果)
1.3.2.1 自定义方法 （使用接口的 T get() ）
//带一个供给型参数，可以实现同一个方法，处理实现同一个方法，处理不同的业务场景，给的数据不同，返回的结果不同
static String useSupplier(Double salary, Supplier<Double> supplierData){
    //判断是否高薪的逻辑
    if(salary > supplierData.get()){
        return "高薪";
    }
    return "底薪";
}
1.3.2.2 方法调用
static void testLambdaSupplier(){

    //场景：不同的部门，针对高薪的判断条件不同，比如：学术部高于8000算高薪，教职部门高于5000算高薪
    //以前的写法：根据不同的不同，增加if...else 判断，随着部门的增加，你分的判断会越来越复杂

    log.info("--- 学术部：工资：{}，是否高薪：{} ---",9000.0,useSupplier(9000.0,() -> 8000.0));
    log.info("--- 学术部：工资：{}，是否高薪：{} ---",7000.0,useSupplier(7000.0,() -> 8000.0));
    log.info("--- 教职部：工资：{}，是否高薪：{} ---",7000.0,useSupplier(7000.0,() -> 5000.0));
    log.info("--- 教职部：工资：{}，是否高薪：{} ---",4000.0,useSupplier(7000.0,() -> 5000.0));

}
1.3.2.3 测试结果

94f62fbff20fa3f80e74234e557ac08a.png

1.3.3 断言型接口 Predicate（方法有一个参数，有返回值-布尔类型）
1.3.3.1 自定义方法 (使用接口的 boolean test(T t) )
//将判断条件交给调用方法
static List<String> userPredicate(List<String> nameList, Predicate<String> predicateData){

    //定义要返回的姓名集合
    List<String> returnNameList = new ArrayList();

    //使用断言型接口，根据传过来的实现，返回不同的结果
    nameList.forEach(name ->{
        //调用断言型接口的test方法，进行挑选数据
        if(predicateData.test(name)){
            returnNameList.add(name);
        }
    });

    //返回符合条件的集合数据
    return  returnNameList;

}
1.3.3.2 方法调用
static void testLambdaPredicate(){

    //使用场景
    //已知姓名集合，根据不同的场景，筛选不同的姓名结果
    List<String> nameList = Arrays.asList("Lilei","Hanmeinei","lisi","zhangsan","xiaolong","xiaohu");

    //获取姓名集合中所有包含n的姓名集合,可以定义第一个方法，实现
    //获取集合中包含i 或者a的姓名集合，可以定义第二个方法，实现
    //随着规则的改变，实现的方法越来越多，去简化，所有的方法就是判断规则不同，其他都一样，可以使用断言型接口，优化

    //获取姓名集合中所有包含n的姓名集合
    List<String> nameList_n = userPredicate(nameList,name -> name.contains("n"));
    log.info("姓名集合中所有包含n的姓名集合:{}",nameList_n);

    //获取集合中包含i 或者a的姓名集合
    List<String> nameList_i_a = userPredicate(nameList,name -> name.contains("i") || name.contains("a"));
    log.info("获取集合中包含i 或者a的姓名集合:{}",nameList_i_a);

}
1.3.3.3 测试结果

e2964cf436947b3c560c70411830cbff.png

1.3.4 函数接口 Function,有任意类型参数，有任意类型返回值
1.3.4.1 自定义方法（使用接口的R apply(T t) ） 和 方法调用
static void testLambdaFunction(){

    Function<Integer,Double> function = num -> new Random().nextInt(num)*1.0;

    log.info("--- 使用函数型接口，接收整数：{}，返回随机浮点型结果：{} ---",96,function.apply(96));
    
}
1.3.4.2 测试结果

8ed878bf0921e5f986cbcc38a876724d.png

1.3.5 自定义函数式接口
// 自定义的函数式接口：带一个任意类型参数，返回String类型值
// 定义：凡是一个接口中，只有一个抽象方法，那这个接口就是函数式接口，可以别注解 //@FunctionalInterface修饰
@FunctionalInterface
public interface MyFunctionInterface<T> {

    //函数式接口中的唯一抽象方法
    String helloKh96(T t);

    //可以增加默认方法，允许的
    default void hiKH96(){
     //默认方法
    }

}

2、StreamAPI

2.1 创建流 有限流 和 无限流

2.1.1 有限流
//有限流， 输出1，3，5，7，9 的平方
log.info("\n----- 输出1，3，5，7，9 的平方 -----");
Stream.of(1,3,5,7,9).forEach(num -> System.out.print(num * num + ";"));

测试结果：

f5c6d6db19cb839ce28d20d926455a75.png

2.1.2 无线流
2.1.2.1 iterate
//无限流：输出前18个奇数
log.info("\n ----- 输出前18个奇数 ------");
Stream.iterate(1,n -> n+2).limit(10).forEach(num -> System.out.print(num + ";"));
2.1.2.2 generate
//无限流：输出10个随机数
log.info("\n ----- 输出前18个随机数 ------");
Stream.generate(() -> new Random().nextInt(100)).limit(10).forEach(num -> System.out.print(num+";"));

测试结果：

8bc12d5af14f0d95ca2bc45b2e422aab.png

2.2 创建流 基于数组 和 集合

2.2.1 基于数组
//基于数组
int[] nums = {66,99,44,11,22,55,77,88};

//通过Arrays工具类提供的stream 方法
int min = Arrays.stream(nums).min().getAsInt();
int max = Arrays.stream(nums).max().getAsInt();
log.info("\n ------ 数组最小值为 ：{} --------",min);
log.info("\n ------ 数组最大值为 ：{} --------",max);

测试结果：

752f9c12ece24d355af18a2254fb8892.png

2.2.2 基于集合
//基于集合
List<String> nameList = Arrays.asList("Lilei","Hanmeinei","lisi","zhangsan","xiaolong","xiaohu");

//通过集合对象的stream方法
nameList.stream().map(name -> name.toLowerCase()).forEach(System.out::println);

测试结果：

fc3a54c19eb64737401f812f841864a0.png

2.3 流的中间操作

2.3.1 筛选和切片
2.3.1.0 数据准备
2.3.1.0.1 bean
//小说实体
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Story {

    // 编号
    private Integer id;

    // 书名
    private String name;

    // 作者
    private String author;

    // 价格
    private Double price;

    // 章节
    private Integer sections;

    // 分类
    private String category;

}
2.3.1.0.2 StoryUtil
//小说工具类
public class StoryUtil {
    public static List<Story> stories = new ArrayList<>();
    static {
        stories.add(Story.builder().id(101).name("斗破苍穹").author("zhangsan").price(109.9).sections(1202).category("玄幻").build());
        stories.add(Story.builder().id(201).name("斗罗大陆").author("lisi").price(88.9).sections(999).category("科幻").build());
        stories.add(Story.builder().id(301).name("凡人修仙传").author("wangwu").price(77.9).sections(1303).category("武侠").build());
        stories.add(Story.builder().id(401).name("圣墟").author("zhuliu").price(121.9).sections(1404).category("玄幻").build());
        stories.add(Story.builder().id(501).name("吞噬星空").author("sunqi").price(135.9).sections(996).category("历史").build());
        stories.add(Story.builder().id(601).name("完美世界").author("zhaoba").price(66.9).sections(999).category("玄幻").build());
        stories.add(Story.builder().id(701).name("大王饶命").author("qianjiu").price(135.9).sections(997).category("玄幻").build());
        stories.add(Story.builder().id(801).name("大奉打更人").author("zhoushi").price(133.9).sections(1606).category("军事").build());
    }
}
2.3.1.1 筛选：filter
//筛选： filter,相当于数据库中的where条件
log.info("-------------- 筛选： filter ----------------");
//查看小说集合中，价格大于100块的所有小说
StoryUtil.stories.stream().filter(story -> story.getPrice() > 100).forEach(System.out::println);

//练习：查看小说集合中，所有章节数大于1000且作者中包含n的小说
log.info("\n------- 查看小说集合中，所有章节数大于1000且作者中包含n的小说 ---------");
StoryUtil.stories.stream().filter(story -> story.getSections() > 1000 && story.getAuthor().contains("n") ).forEach(System.out::println);

测试结果1：

4e9ede487ea292468aafde04bbafb8dc.png

测试结果2：

922a5e620154661b692f9b130e9a02c0.png

2.3.1.2 截断：limit
//截断： limit 相当于数据库的limit条数
log.info("\n---------- 截断： limit ---------");
//查询小说集合，所有价格大于100的前三本
StoryUtil.stories.stream().filter(story -> story.getPrice() >100).limit(3).forEach(System.out::println);

测试结果：

bdca3d9cfc41bedc2d2a6af6c8ae4452.png

2.3.1.3 跳过：skip
//跳过：skip,相当于数据库跳过数据条数
log.info("\n------------- 跳过：skip-----------------");
//查询小说集合，所有价格大于100的前三本,后的所有小说
log.info("\n------------- 查询小说集合，所有价格大于100的前三本,后的所有小说-----------------");
StoryUtil.stories.stream().filter(story -> story.getPrice() >100).skip(3).forEach(System.out::println);

测试结果：

285f32672bdacd178c40fe139713b714.png

2.3.1.4 去重：distinct
//去重：distinct,相当于数据库中的去重,了解
log.info("\n------------- 去重：distinct,相当于数据库中的去重 -----------------");
Stream.of(22,33,55,11,66,33,55,11,55).distinct().forEach(System.out::println);

测试结果：

4b83ad3415ed72e5a741dbd287b4fa5a.png

2.3.2 映射和排序
2.3.2.1 映射：map
//已知姓名集合
List<String> nameList = Arrays.asList("Lilei","Hanmeinei","lisi","zhangsan","xiaolong","xiaohu");

//映射：map,可以将流中发的元素进行转换或这提取，会自动指定的规则作用到所有的元素上，并返回一个新的流
log.info("-------------- 映射： map ----------------");

//将姓名集合中，所有包含i的姓名，转换为大写并输出
//nameList.stream().filter(name -> name.contains("i")).map(name -> name.toUpperCase()).forEach(System.out::println);
nameList.stream().filter(name -> name.contains("i")).map(String::toUpperCase).forEach(System.out::println);

测试结果：

906a342041868e7df91cf88835de5d34.png

2.3.2.2 映射：map 输出单个属性
//将小说集合中,章节小于1000的作者转换为大写，输出作者
log.info("\n-------------- 将小说集合中,章节小于1000的作者转换为大写，输出作者 --------------");
//StoryUtil.stories.stream().filter(story -> story.getSections() < 1000).map(story -> story.getAuthor()).map(string -> string.toUpperCase()).forEach(System.out::println);
StoryUtil.stories.stream().filter(story -> story.getSections() < 1000).map(Story::getAuthor).map(string -> string.toUpperCase()).forEach(System.out::println);

测试结果：

8df617dc7e360038b859c89046338244.png

2.3.2.3 映射： mapToInt
//获取所有小说的书名长度
log.info("\n-------------- 获取所有小说的书名长度 --------------");
// StoryUtil.stories.stream().map(story -> story.getName().length()).forEach(System.out::println);
StoryUtil.stories.stream().mapToInt(story -> story.getName().length()).forEach(System.out::println);

测试结果：02ab3b96a1620de96944107d2349be4e.png

2.3.2.4 消费：peek
//消费：peek,  将小说价格增加50元后，价格大于130的
log.info("\n-------------- 消费：peek,  将小说价格增加50元后，价格大于130的 --------------");
StoryUtil.stories.stream().peek(story -> story.setPrice(story.getPrice()+50)).filter(story -> story.getPrice()>130).forEach(System.out::println);

测试结果：

233410132ee02a0357668ea56a78e88b.png

2.3.2.5 排序：sorted
//排序：sorted ,给姓名排序
log.info("\n -------------- 排序：sorted ,给姓名排序 --------------");
nameList.stream().sorted().forEach(System.out::println);

ddc08f9be679c730db261dc2a71cfefa.png

2.3.2.6 自定义排序规则
//自定义排序，先按照价格排序，价格相同，按照章节排序
log.info("\n--------- 自定义排序，先按照价格排序，价格相同，按照章节排序 ---------");
StoryUtil.stories.stream().sorted((s1,s2)->{
    int sortPrice = Double.compare(s1.getPrice(),s2.getPrice());
    if(sortPrice == 0){
        return Double.compare(s1.getSections(),s2.getSections());
    }
    return sortPrice;

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

测试结果：3c5045f164b3fee411639e4f3605b74d.png

a67cc6d01fb003620af0e266779c66bd.jpeg

往期推荐

  1. 肝九千字长文 | MyBatis-Plus 码之重器 lambda 表达式使用指南，开发效率瞬间提升80%

  2. 用 MHA 做 MySQL 读写分离，频繁爆发线上生产事故后，泪奔分享 Druid 连接池参数优化实战

  3. 微服务架构下，解决数据库跨库查询的一些思路

  4. 一文读懂阿里大中台、小前台战略

作者简介：猿芯，一枚简单的北漂程序员。喜欢用简单的文字记录工作与生活中的点点滴滴，愿与你一起分享程序员灵魂深处真正的内心独白。我的微信号：WooolaDunzung，公众号【猿芯】输入 1024 ，有份面试惊喜送给你哦。

< END >

【猿芯】

5d5dda6159a6ea5b6fe8a7310cb96fd9.jpeg

 微信扫描二维码，关注我的公众号。

分享不易，莫要干想，如果觉得有点用的话，动动你的发财之手，一键三连击：分享、点赞、在看，你们的鼓励是我分享优质文章的最强动力 ^_^

分享、点赞、在看，3连3连！0ea7dddbdd429ef2eac55f1c93b2e274.gif

彬禹随笔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Lambda表达式#代码简化
be_a_hacker的博客
04-28 266
Lambda表达式也可以称为闭包，Lambda表达式是在Java8新增的一种重要的新特性。 Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中）。 //格式一般如下 (parameters)->expression;//表达式 //或 (parameters)->{statements;};//语句 //eg:多线程中实现Runnable接口的线程创建。 new Thread(()->System.out.println("这就是Lambda表达式")).start();
Java8学习笔记（一）—— 函数式编程的四个基本接口
云卷云舒的架构师之路
07-13 1474
Java8学习笔记系列： Java8学习笔记（一）—— 函数式编程的四个基本接口 Java8学习笔记（二）—— Lambda表达式 Java8学习笔记（三）—— Optional类的使用 Java8学习笔记（四） —— Stream流式编程 Java8学习笔记（五）—— 方法引用(::双冒号操作符) 一、基本函式数接口 基本的函数式接口主要有四个： ① Supplier<T&...
lamda list 分组_Lambda表达式操作List集合
weixin_35663718的博客
01-12 2673
Lambda表达式是Java8中一个非常重要的新特性，它允许通过表达式代替功能性的接口，几乎所有的for循环都可以用Lambda表达式来改写，让你的代码更加简洁，开发更加迅速。下面提供简单的几个Lambda表达式对List集合处理的案例，希望对大家有帮助。// 以员工表为例@ApiModel(value = "employee", description = "员工信息")public class...
Lambda表达式
weixin_44538151的博客
05-06 532
Lambda表达式 开发工具与关键技术：Visual Studio 2015 作者：姚世添 撰写时间：2019年05月09日 一、 Lambda表达式是一个匿名函数，lambda表达式在C#中主要用于查询中，C#中的Lambda表达式都使用运算符（=>）,该运算符读为goes to,（=>）运算符具有与赋值运算符（...
技能：获取用户所在部门权限（所有上级节点）
weixin_43608796的博客
06-23 316
//userid所在的部门ids Set<Long> userRefOrgIds = sysUserOrganizations.stream() .map(SysUserOrganization::getOrgId).collect(Collectors.toSet()); //获取所有部门 List<SysOrganization> organizationList = sysO
lambda-notes:Lambda 表达式学习笔记
05-14
Java 8 Lambda表达式学习笔记，摘自书籍 ，笔记内只举了实例，没有进行过多的解释与剖析，可以通过IDE进入Java 8 的相关源码进行查看理解，查看主要知识储备包括： 接口定义 Java 8 default关键字 泛型 匿名内部类 ...
java8源码-LambdaExpression:Lambda表达式
06-04
Lambda表达式 Lambda表达式是一个匿名方法,将行为像数据一样进行传递。 Lambda 表达式常见的结构： BinaryOperator add = (x,y) -> x+y; 函数接口指仅具有单个抽象方法的接口，用来表示Lambda表达式的类型。 Lambda...
C++11新特性：Lambda表达式.pdf
10-20
C++11新特性：Lambda表达式 Lambda表达式是C++11新...Lambda表达式是C++11新特性中的一种强大工具，可以让代码变得更加简洁、清晰易读。但是，需要注意lambda表达式的语法和使用场景，以便更好地使用lambda表达式。
JLambdas:Lambda表达式和流
05-21
在Java编程语言中，Lambda表达式和流是Java 8引入的重要特性，极大地提升了代码的简洁性和可读性。这两个概念对于现代Java开发者来说至关重要，它们使得处理集合数据变得更加高效和优雅。 Lambda表达式是一种匿名...
lambda-zone:Lambda 表达式战区
06-21
是一个类似于 TryClojure 和 4Clojure 网站的网站，它为开发人员提供了一个平台来提交自己的代码，在这种情况下是用 Clojure 编写的国际象棋策略。 他们的目标是竞争以获得最高排名。 开发人员只需要实现一个单一...
lamda list 分组_java8lambda表达式对集合分组并且排序（记一次性能优化案例）
weixin_39978350的博客
01-12 1215
最近遇到个需求是这样的：写一个类似于通讯录的简单功能，要求是首先按照部门显示列表，然后点击部门下拉显示部门里面的人员信息，且人员信息按照职位排序。先分析数据结构：最外层是部门，部门里面是员工，且项目是统一返回数据格式。{"code": 0,"data": [{"name": "部门名称","userData": [{"deptName": "部门名称","info": "部门名称+职位","pho...
Java 8 Function 函数接口
未读代码
07-21 1882
在 Java 8 中，Function 接口是一个函数接口，它位于包 java.util.function 下。 Function 接口中定义了一个 R apply(T t) 方法，它可以接受一个泛型 T 对象，返回一个泛型 R 对象，即参数类型和返回类型可以不同。 Function 接口源码： @FunctionalInterface public interface Function<T, R> { R apply(T t); default <V> Func
JAVA8之函数式编程Function接口
Zn昕的博客
07-07 8064
JAVA8之函数式编程Funtion接口        从这章开始,会介绍几个常用的函数式接口工具,首先先来看下这个大家族:                首先从Function接口开始介绍一.    概述        该接口顾名思义,函数的意思,就像是数学,是给定一个参数然后返回结果.该类方法如下:package java.util.function; import java.util.Ob...
Java 8中常用的函数式接口
olive
03-18 223
函数式接口 函数描述符 原始类型特化 Predicate T-&gt;boolean IntPredicate,LongPredicate, DoublePredicate Consumer T-&gt;void IntConsumer,LongConsumer, DoubleConsumer Function&lt;T,R&gt; T-&gt;R IntFunction,...
Java-Lambda表达式和“方法引用”的对比和详解
li_xunhuan的博客
07-31 3546
Lambda表达式 一、Lambda表达式简介 1.1什么是Lamdba表达式?  Lambda表达式是Java 8 添加的一个新特性，可以认为，Lambda是一个匿名函数（相似于匿名内部类）。 1.2为什么使用Lambada表达式？  使用Lambda表达式对比于其他接口实现方式显得非常简洁。（详见3种接口实现的方法代码块CodeBlock-1） 1.3Lambda对接口的要求？  虽然Lamb...
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 790
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 871
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 997
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
最新发布
m0_69266818的博客
07-15 809
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
函数式编程以及lambda表达式Stream流技术分享PPT
01-09
该PPT为本人翻遍大部分帖子、博客、资源等一系列资料自我整合了一套技术分享PPT，以Java为载体，概括了Lambda表达式的使用概念、函数式编程的思想，以及Stream流的各个方法的使用，Stream流的强大功能等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值