Lambda--Optional、Collectors高级进阶方法

最新推荐文章于 2023-05-16 09:56:47 发布
最新推荐文章于 2023-05-16 09:56:47 发布
阅读量464 收藏
点赞数
分类专栏： Lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/empire_ing/article/details/119489023
版权

Lambda–Collectors、optional高级使用

偶然看到了同事groupingBy用法，然后百度衍生出了optional，collectors，map等各种用法。突然发现自己之前写的代码又烂又复杂了，后面用optional可以防止空指针，collectors也可以极大简化代码量。

csdn csdn csdn csdn csdn

文章目录

🔥1.Optional

optional里面有防止空指针的语句，但我觉得有些时候报空指针错更方便定位到问题。比如从库里查找出数据，没找到但是你初始化了一个默认值做了后续处理并返回给前端展示了，这其实就算是BUG了，当然有些时候避免空指针报错也是非常不错的选择。

1.1.Optional–基本方法
//of会报空指针，ofNullable不会(可以防止空指针)，而是重新new个optional
Optional.of()
Optional.ofNullable
    
//user不为空即输出 
Optional.ofNullable(user).ifPresent(System.out::println); 

//user为空则重新new一个
Optional.ofNullable(user).orElse(User.builder().build());

//user为空则报空指针错误(虽然ofNullable里面new了optional，但user依然会为空)
Optional.ofNullable(user).orElseThrow(() -> new NullPointerException());    

//user为空则重新new一个
Optional.ofNullable(user).orElseGet(() -> User.builder().build());

//初始化list数组
List<String> list = null;
List<String> newList = Optional.ofNullable(list).orElse(Lists.newArrayList());
1.2.Optional–filter、map

Optional中可以像stream流一样操作数据

/**
 * @program: springboot
 * @description:
 * @author: huyuqiao
 * @create: 2021/08/07 10:57
 */
@Data
@Builder(toBuilder = true)
public class UserInfo {
    private String name;
    private String email;
    private Integer price;
}



@Test
public void optionalTest(){
    // Optional--操作对象：filter
    UserInfo userInfo = UserInfo.builder()
        .name("huyuqiao")
        .email("1842449680@qq.com")
        .price(100)
        .build();
    UserInfo newUserInfo = Optional.ofNullable(userInfo).filter(u -> u.getPrice() < 1000).orElse(UserInfo.builder().build());
    System.out.println(newUserInfo);

    // Optional--操作对象：map
    String name = Optional.ofNullable(userInfo).map(UserInfo::getName).orElse("自定义姓名");
    System.out.println(name);

    // Optional--操作对象：flatmap
    Optional.ofNullable(userInfo).flatMap(u -> Optional.ofNullable(u.getName()));
}
1.2.Optional–flatMap

​ flatMap:扁平化获取层级下的元素并组装成同一层级。

​ 比如现有数组[[1],[2],[3]]，要提取里面所有元素并组装成[1,2,3]，可利用flatMap获取

    @Test
    public void flatMapTest(){
        List<List<Integer>> outer = new ArrayList<>();
        List<Integer> inner1 = new ArrayList<>();
        inner1.add(1);
        inner1.add(9);
        List<Integer> inner2 = new ArrayList<>();
        inner2.add(2);
        List<Integer> inner3 = new ArrayList<>();
        inner3.add(3);
        List<Integer> inner4 = new ArrayList<>();
        inner4.add(4);
        List<Integer> inner5 = new ArrayList<>();
        inner5.add(5);
        outer.add(inner1);
        outer.add(inner2);
        outer.add(inner3);
        outer.add(inner4);
        outer.add(inner5);
        List<Integer> result = outer.stream().flatMap(inner -> inner.stream().map(i -> i + 1)).collect(Collectors.toList());
        System.out.println(result);
    }
//[2, 10, 3, 4, 5, 6]

🔥2.Collectors

会使用了optional基本语句后，后面就可以开始使用Collectors语句了，个人感觉对开发非常实用，可以极大简化代码开发量。先给出基本类，然后就可以使用了

/**
 * @program: springboot
 * @description:
 * @author: huyuqiao
 * @create: 2021/08/06 10:10
 */

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 学生信息
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    /** 姓名 */
    private String name;
    /** 总分 */
    private int totalScore;
    /** 是否本地人 */
    private boolean local;
    /** 年级 */
    private GradeType gradeType;

    /**
     * 年级类型
     */
    public enum GradeType {ONE,TWO,THREE}
}
2.1.averagingDouble–计算平均值

注意： double格式可以表示-253到253范围内的所有连续整数。如果管道有超过253的值，则平均计算中的除数将在253处饱和，从而导致额外的数值误差。（所以计算数多时需要专用BigDecimal进行计算）

 	//统计所有学生的平均总成绩
	@Test
    public void averagingDoubleTest(){
        Double avgScore = menu.stream().collect(Collectors.averagingDouble(Student::getTotalScore));
        Optional.ofNullable(avgScore).ifPresent(System.out::println);
    }
2.2.collectingAndThen–转换类型

collectingAndThen方法：调整Collector收集器以执行其它的结束转换

       @Test
    public void collectingAndThenTest(){
        // unmodifiablelist:不能add,set。arrays.aslist可以set，但是不能add
        List<Student> studentList = menu.stream().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
        System.out.println(studentList);

        //collectingandthen:计算总平均值并转换成自定义字符串返回
        Optional.ofNullable(menu.stream().collect(
                Collectors.collectingAndThen(Collectors.averagingInt(Student::getTotalScore), a -> "the average totalscore is" + a)
        )).ifPresent(System.out::println);

    }
2.3.counting–类似count()

counting方法：统计collectors收集器元素

    @Test
    public void countingTest(){
        Optional.of(menu.stream().collect(Collectors.counting())).ifPresent(System.out::println);
    }
// 7
2.4.groupingBy*、groupingByConcurrent–分组（重点）

groupingBy方法：分组并返回到map中（个人感觉非常好用,对商品进行分组返回给前端，大大简化了代码量）。

groupingByConcurrent：并发分组，无法保证返回数据类型的顺序或线程安全性

    //按对象某一属性进行分组
    @Test
    public void groupByTest(){
        Map<Student.GradeType, List<Student>> collect = menu.stream().collect(Collectors.groupingBy(Student::getGradeType));
        Optional.ofNullable(collect).ifPresent(System.out::println);
        //{THREE=[Student(name=刘一, totalScore=721, local=true, gradeType=THREE), Student(name=陈二, totalScore=637, local=true, gradeType=THREE), Student(name=张三, totalScore=666, local=true, gradeType=THREE), Student(name=王五, totalScore=483, local=false, gradeType=THREE), Student(name=赵六, totalScore=367, local=true, gradeType=THREE)], TWO=[Student(name=李四, totalScore=531, local=true, gradeType=TWO)], ONE=[Student(name=孙七, totalScore=499, local=false, gradeType=ONE)]}

        //分组后统计每组的平均分数值，并对每组key升序排列
        Map<Student.GradeType, Double> map = menu.stream().collect(Collectors.groupingBy(Student::getGradeType, TreeMap::new , Collectors.averagingInt(Student::getTotalScore)));
        Optional.ofNullable(map).ifPresent(System.out::println);
        //{ONE=499.0, TWO=531.0, THREE=574.8}
    }

GroupingBy其他功能：按单个属性、多个属性，条件分组、多级分组、分组后组装成其他集合

package com.empirefree.springboot;

import com.alibaba.fastjson.JSON;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @program: springboot
 * @description:
 * @author: huyuqiao
 * @create: 2021/08/05 09:47
 */
@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class CollectorsTest {
    @Data
    public class Product {
        private final Long id;
        private final Integer num;
        private final BigDecimal price;
        private final String name;
        private final String category;
    }

    @Test
    public void testanything(){
        // 参考文章：https://blog.csdn.net/u014231523/article/details/102535902
        Product prod1 = new Product(1L, 1, new BigDecimal("15.5"), "面包", "零食");
        Product prod1_1 = new Product(11L, 11, new BigDecimal("15.5"), "面包", "零食");
        Product prod2 = new Product(2L, 2, new BigDecimal("20"), "饼干", "零食");
        Product prod3 = new Product(3L, 3, new BigDecimal("30"), "月饼", "零食");
        Product prod4 = new Product(4L, 3, new BigDecimal("10"), "青岛啤酒", "啤酒");
        Product prod5 = new Product(5L, 10, new BigDecimal("15"), "百威啤酒", "啤酒");


        List<Product> prodList = Arrays.asList(prod1, prod1_1, prod2, prod3, prod4, prod5);
        Object object7 = prodList.stream().collect(Collectors.collectingAndThen(Collectors.maxBy(Comparator.comparingInt(Product::getNum)), Optional::get));
        System.out.println(object7);

        // 1、按某个属性分组
        Map<String, List<Product>> productMap = prodList.stream().collect(Collectors.groupingBy(Product::getCategory));
        System.out.println(JSON.toJSONString(productMap));

        // 2、按多个属性分组
        Map<String, List<Product>> productMap2 = prodList.stream().collect(Collectors.groupingBy(item -> item.getCategory() + "_" + item.getName()));
        System.out.println(JSON.toJSONString(productMap2));

        // 3、按条件分组
        Map<String, List<Product>> productMap3 = prodList.stream().collect(Collectors.groupingBy(item ->{
            if (item.getNum() < 3){
                return "3";
            } else {
                return "other";
            }
        }));
        System.out.println(JSON.toJSONString(productMap3));

        // 4、多级分组
        Map<String, Map<String, List<Product>>> productMap4 = prodList.stream().collect(Collectors.groupingBy(Product::getCategory, Collectors.groupingBy(item ->{
            if (item.getNum() < 3){
                return "3";
            } else {
                return "other";
            }
        })));
        System.out.println(JSON.toJSONString(productMap4));

        // 5、分组求总数、求和
        Map<String, Long> productMap5 = prodList.stream().collect(Collectors.groupingBy(Product::getCategory, Collectors.counting()));
        Map<String, Integer> productMap6 = prodList.stream().collect(Collectors.groupingBy(Product::getCategory, Collectors.summingInt(Product::getNum)));
        System.out.println(JSON.toJSONString(productMap5));
        System.out.println(JSON.toJSONString(productMap6));

        // 6、分组后只获取最大值
        Map<String, Product> prodMap7 = prodList.stream().collect(Collectors.groupingBy(Product::getCategory, Collectors.collectingAndThen(Collectors.maxBy(Comparator.comparingInt(Product::getNum)), Optional::get)));
        System.out.println(prodMap7);


        // 7、分组后组装成其他集合
        Map<String, Set<String>> productMap8 = prodList.stream().collect(Collectors.groupingBy(Product::getCategory, Collectors.mapping(Product::getName, Collectors.toSet())));
        System.out.println(JSON.toJSONString(productMap8));
    }
}
2.5.partitioningBy–分区

partitioningBy方法：分区计算。返回map的可序列化和线程安全性无法保证

partitioningBy：返回map的key是Boolean。无法保证线程安全性

groupingBy：返回map的key是分组的值。可以保证线程安全性

    @Test
    public void partitioningByTest(){
        Map<Boolean, Double> collect = menu.stream().collect(Collectors.partitioningBy(Student::isLocal, Collectors.averagingInt(Student::getTotalScore)));
        Optional.ofNullable(collect).ifPresent(System.out::println);
    }
2.6.joining–拼接元素

joining方法：连接colletors的每个元素

    @Test
    public void joiningTest(){
        Optional.ofNullable(menu.stream().map(Student::getName).collect(Collectors.joining(",", "[", "]"))).ifPresent(System.out::println);
        //[刘一,陈二,张三,李四,王五,赵六,孙七]
    }
2.7.mapping–类似map

mapping方法：类似于map()。

    @Test
    public void mappingTest(){
        Optional.ofNullable(menu.stream().collect(Collectors.mapping(Student::getName, Collectors.joining(",", "[", "]")))).ifPresent(System.out::println);
    }
2.8.maxBy、minBy–类型max(),min()

maxBy、minBy方法：获取比较器最大和最小值。返回的是Optional

    @Test
    public void maxOrMinByTest(){
        menu.stream().collect(Collectors.maxBy(Comparator.comparing(Student::getTotalScore))).ifPresent(System.out::println);
        menu.stream().collect(Collectors.minBy(Comparator.comparing(Student::getTotalScore))).ifPresent(System.out::println);
    }
2.9.reducing–类型reduce()

reducing方法：对收集器元素计算

    @Test
    public void reducingTest(){
        Integer result = menu.stream().map(Student::getTotalScore).collect(Collectors.reducing(0, (a, b) -> a + b));
        System.out.println(result);
    }
2.10.summarizingDouble*–汇总max,min,count,sum,avg(妙点)

summarizingDouble方法：汇总list中某属性的所有汇总值(最大、最小、总数，总和,平均值)

    @Test
    public void summarizingInt(){
        DoubleSummaryStatistics result = menu.stream().collect(Collectors.summarizingDouble(Student::getTotalScore));
        Optional.ofNullable(result).ifPresent(System.out::println);
    }
2.11.toCollection–转换成集合

toCollection方法：转换收集器的集合类型

    //转换成LinkedList
	@Test
    public void toCollectionTest(){
        Optional.of(menu.stream().filter(s -> s.getTotalScore() > 600).collect(Collectors.toCollection(LinkedList::new))).ifPresent(s -> {
            System.out.println(s.getClass());
            System.out.println(s);
        });
    }
2.12.toMap–转换成list

toMap方法：可以将list转换成map(但要注意key值重复与value为空情况)

@Test
    public void listToMapTest(){
        // 1 list to map -- obj
        List<User> users = Arrays.asList(
                new User(101, "Jack"),
                new User(102, "Kreas"),
                new User(103, "Marry"),
//                new User(103, "Marry2"),
                new User(104, "Timi"),
                new User(105, "Alice")
//                new User(105, null)
        );

        // key不能有重复
        Map<Long, User> map = users.stream().collect(Collectors.toMap(User::getId, o -> o));
        System.out.println(JSON.toJSONString(map));
        // 1.2 list to map -- 属性
        Map<Long, String> map2 = users.stream().collect(Collectors.toMap(User::getId, User::getName));
        System.out.println(JSON.toJSONString(map2));

        // 3 list to map -- 解决key重复  value为空则报空指针
        Map<Long, String> map3 = users.stream().collect(Collectors.toMap(User::getId, User::getName, (o1, o2) -> o1));
        System.out.println(JSON.toJSONString(map3));
        Map<Long, String> map4 = users.stream().collect(Collectors.toMap(User::getId, User::getName, (o1, o2) -> o2));
        System.out.println(JSON.toJSONString(map4));
        Map<Long, String> map5 = users.stream().collect(Collectors.toMap(User::getId, User::getName, (o1, o2) -> o1 + "," + o2));
        System.out.println(JSON.toJSONString(map5));

        // 4 list to map -- 解决value为空，但不能解决key值重复
        Map<Long, String> map6 = users.stream().collect(Collectors.toMap(User::getId, o -> o.getName() == null ? "" : o.getName()));
        System.out.println(JSON.toJSONString(map6));
    }

注意：当有key重复以及value为null情况时，个人建议还是直接用put/putIfAbsent。

  Map<Long, String> map7 = new HashMap<>();
users.stream().forEach(user -> map7.put(user.getId(), user.getName()));
System.out.println(map7);

🔥3.总结

个人认为：

Optional.ofNullable(对象).orElse(对象.builder().build())：防止空指针非常实用

Collectors里面最重要的当属groupingBy与summarizingDouble。其他的个人觉得知道要能看得懂是干什么用的，毕竟很多都可以直接在stream里面直接处理好，没必要在collect里面处理。

另外：

map中重复值+1操作：computeIfAbsent可以实现

提取List成list<>：flatMap可以实现

List转map：map的put/putifAbsent即可

Collectors参考链接：https://blog.csdn.net/sl1992/article/details/98900343

toMap参考链接：https://zyqok.blog.csdn.net/article/details/108646765?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EsearchFromBaidu%7Edefault-1.pc_relevant_baidujshouduan&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EsearchFromBaidu%7Edefault-1.pc_relevant_baidujshouduan


🔥4.补充
4.1.Map操作–compute计算

Map：判断list值，没有就添加，有就value+1

    @Test
    public void mapTest(){
        /*
        * compute：计算并更新值(但是可能会空指针)
            computeIfAbsent：Value不存在时才计算
            computeIfPresent：Value存在时才计算
        * */
        HashMap<String, Integer> prices = new HashMap<>();

        // 往HashMap中添加映射关系
        prices.put("Shoes", 180);
        prices.put("Bag", 300);
        prices.put(null, 150);
        prices.put(null, 250);
        System.out.println("HashMap: " + prices);
        //有就不put，没有才put
        prices.putIfAbsent("Shoes", 1810);

        //有才put，没有不put
        prices.computeIfPresent("Shoes3", (key, value) -> value + 100);

        //有就不put
        prices.computeIfAbsent("Shoes4", key -> 18120);

        //无论有无都put计算
        prices.compute("Shoes2", (key, value) -> 1810);
        prices.compute("Shoes2", (key, value) -> 1820);
        System.out.println(prices);

        //给map中put值，有就 + 1，没有就添加初始化为0
        Map<String, AtomicInteger> countTagClientMap = new LinkedHashMap<>();
        countTagClientMap.computeIfAbsent("a", value -> new AtomicInteger()).incrementAndGet();     //这个可以实现为空就put，否则 + 1
        countTagClientMap.computeIfAbsent("a", value -> new AtomicInteger());
        System.out.println(countTagClientMap);
        countTagClientMap.computeIfPresent("a", (key, value) -> new AtomicInteger(value.incrementAndGet()));
        countTagClientMap.compute("a", (key, value) -> value == null ? new AtomicInteger(1) : new AtomicInteger(value.incrementAndGet())); //这个可以实现为空就put，否则 + 1
        System.out.println(countTagClientMap);
    }
4.2.TreeMap–排序操作

treeMap：treeMap默认是对key值升序排序

    @Test
    public void treeMap() {
        // 对key值排序
        TreeMap<Integer, Integer> map1 = new TreeMap<Integer, Integer>();  //默认的TreeMap升序排列
        TreeMap<Integer, Integer> map2 = new TreeMap<Integer, Integer>(Comparator.reverseOrder());
        map2.put(1, 2);
        map2.put(2, 4);
        map2.put(7, 1);
        map2.put(5, 2);
        System.out.println("Map2=" + map2);

        map1.put(1, 2);
        map1.put(2, 4);
        map1.put(7, 1);
        map1.put(5, 2);
        System.out.println("map1=" + map1);
    }

书山有路勤为径，学海无涯苦作舟。程序员不仅要懂代码，更要懂生活，关注我，一起进步。

请添加图片描述

福宇乔
关注
专栏目录
《JAVA 进阶： JDK8新特性：Lambda，Stream API，Optional》
yexiangCSDN的专栏
07-29 336
dd
Java高阶进阶之Java函数式编程-Stream流-Lambda表达式
fo_xi的博客
09-14 489
Java高级进阶之Java函数式编程-Stream流-Lambda表达式
Java8，Optional 的高级用法.
最新发布
dear_Alice_moon的专栏
05-16 527
Java8，Optional 的高级用法.
[转]你应该更新的Java知识之Optional高级用法
spiderman888的专栏
08-27 1488
Tag：你应该更新的Java知识 Java Guava Null Optional Maybe_Monad 你应该更新的Java知识之常用程序库（一） 你应该更新的Java知识之常用程序库（二） 你应该更新的Java知识之构建工具 你应该更新的Java知识之Observer 你应该更新的Java知识之集合初始化 你应该更新的Java知识之集合操作 你应该更新的Java知识
关于Java8新特新Collectors工具的使用(高级统计操作)
weixin_44520602的博客
05-13 335
Java8流处理对象集合常用操作代码实例 实例： 操作实体类 package com.usthe.bootshiro; import lombok.Data; /** Created by JingChun on 2020/5/13. */ @Data public class Information { private Integer id; private String name; private String sex; private Integer age; public Infor...
详细介绍JDK8中Optional对象的高级用法
sbcsdn111的博客
04-25 1084
Optional 是 Java 8 引进的一个新特性，我们通常认为 Optional 是用于缓解 Java 臭名昭著的空指针异常问题。Optional 是个容器：它可以保存类型 T 的值，或者仅仅保存 null。如果值存在则 isPresent() 方法会返回 true，调用 get() 方法会返回该对象。Optional 提供很多有用的方法，这样我们就不用显式进行空值检测。
lambda高级用法
闲余知道
09-30 327
lambda的高级使用教程
Stream进阶
weixin_41563161的博客
11-11 422
Stream 1. 流式处理简介 比如我们希望对一个包含整数的集合中筛选出所有的偶数，并将其封装成为一个新的List返回，那么在java8之前，我们需要通过如下代码实现： List<Integer> evens = new ArrayList<>(); for (final Integer num : nums) { if (num % 2 == 0) { evens.add(num); } } 通过java8的流式处理，我们可以将代码简化为： Li
Java开发工程师进阶篇-Java8的Stream流使用技巧
ch98000的博客
09-06 795
流是 Java8 引入的全新概念，它用来处理集合中的数据，暂且可以把它理解为一种高级集合。众所周知，集合操作非常麻烦，若要对集合进行筛选、投影，需要写大量的代码，而流是以声明的形式操作集合，它就像 SQL 语句，我们只需告诉流需要对集合进行什么操作，它就会自动进行操作，并将执行结果交给你，无需我们自己手写代码。因此，流的集合操作对我们来说是透明的，我们只需向流下达命令，它就会自动把我们想要的结果给我们。
java8 Lambda表达式
菜鸟进阶之路
05-02 3210
一、概述 java为了引入函数式编程的特性在java8中引入了一个全新的概念“lambda表达式”，同时为了使“lambda表达式”与现有的类库无缝结合，引入了default关键字，允许在接口中定义default的默认实现方法，同时允许在接口中定义static静态实现方法，这两者在java7中是不允许的。lambda表达式从语法层面看极大的简化了匿名内部类的使用，将匿名内部类声明过程中...
Optional正确使用姿势
qq_42292373的博客
01-04 476
文章目录1.基本API的使用ofifNullableisPrensentgetifPresentorElseorElseGetorElseThrowmapflatMapfilter 1.基本API的使用 of of 为非null的值创建一个optional Optional<String> s = Optional.of("2222"); String ...
Optional方法的简单使用
奋斗的小牛的博客
08-19 1169
Optional是jdk1.8引入的类型,Optional是一个容器对象,将非空检测标准化 举一个例子:根据id查询对象返回一个Optional对象,将查询出的对象放到Optional容器中.使用Optional的isPresent()方法可以判断包含的对象是否为空,若为空,返回false,若不为空返回true.然后通过get()方法可以获取到Optional容器中存放的对象. @Test ...
Optional用法
qq_47125845的博客
12-01 603
关于Optional 前言 本次向大家介绍下java Optional类 源码描述 官方的描述是这样的： A container object which may or may not contain a non-null value. If a value is present, isPresent() will return true and get() will return the value. Additional methods that depend on the presence or ab
OPTIONAL的一些用法
牛牛的博客
01-26 2740
OPTIONAL的一些用法 TEST
optional用法
ShewMi的专栏
04-03 5121
java8的改进中一个非常有用的就是optional，一句话概括，optional允许使用一个不确定是否为null的对象并且在对象为null的时候采取一系列的应对措施而不必抛出nullpointerException。这项改进对于经常面对空指针异常的程序是个福音，因为按照以往的方式，要避免空指针异常，就必需进行null判断，如if(obj==null)，另一种方式就是抛出异常并处理，然而这两种方式...
JDK8 Optional
Stroller
10-27 2875
版权声明：本文为博主原创文章，未经博主允许不得转载。 目录(?)[+] 我们知道 Java 8 增加了一些很有用的 API, 其中一个就是 Optional. 如果对它不稍假探索, 只是轻描淡写的认为它可以优雅的解决 NullPointException 的问题, 于是代码就开始这么写了 Optional user = ...... if (us
Java8中Optional的正确使用姿势
我是guyue，guyue就是我O(∩_∩)O
02-20 1222
单纯的使用Optional并不能很好的解决业务中的NPE问题 - 简书 https://www.jianshu.com/p/f21afe47a3e7 单纯的使用Optional并不能很好的解决业务中的NPE问题 工作中经常会遇到NPE（NullPointException）问题怎么处理，得到最多的回答就是Optional来处理，但是单纯的使用Optional并不能很好的...
js 中转换成list集合_java stream中Collectors的用法
weixin_30362743的博客
12-26 857
简介在java stream中，我们通常需要将处理后的stream转换成集合类，这个时候就需要用到stream.collect方法。collect方法需要传入一个Collector类型，要实现Collector还是很麻烦的，需要实现好几个接口。于是java提供了更简单的Collectors工具类来方便我们构建Collector。下面我们将会具体讲解Collectors的用法。假如我们有这样两个li...
Lambda(Linq)表达式GroupBy()的两种用法
有趣技术
02-20 7179
前言 GroupBy通常用于分组统计，可根据单字段或某些字段区进行合并统计数据 Lambda的思想与SQL语句类型，如以下例子： 统计和B、C、D同组的数量 用法1 List<Order> Orders= samples.GroupBy(p => new { p.B, p.C, p.D}) //D,B,C是samples的属性 .Select(p => new Order {
Lambda-S扩展的向量空间语义与范畴解析
"S与向量空间语义的Lambda-S扩展" Lambda-S是一种一阶&lambda;演算的扩展，特别设计用于量子计算的语义表达。它综合了两种处理量子计算中不可克隆性的方法。一方面，Lambda-S阻止变量的重复，防止量子信息的复制，这类似...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

福宇乔

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

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

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

打赏作者

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

抵扣说明：

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

余额充值