Java SE基础知识详解第[13]期—不可变集合、Stream流、异常

最新推荐文章于 2024-07-24 16:19:28 发布
最新推荐文章于 2024-07-24 16:19:28 发布
阅读量579 收藏
点赞数
分类专栏： Java学习 文章标签： java 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhuafeng222/article/details/124704053
版权
本文详细讲解了Java8中的Stream流概念，包括其概述、获取方法、常用API，以及不可变集合的创建和用途。同时深入探讨了异常处理的各个方面，包括异常体系、常见运行时和编译时异常，以及处理机制和自定义异常。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

写在前面：

        每一个不曾起舞的日子，都是对生命的辜负。

        希望看到这里的每一个人都能努力学习，不负韶华，成就更好的自己。

        以下仅是个人学习过程中的一些想法与感悟，Java知识博大精深，作为初学者，个人能力有限，哪里写的不够清楚、明白，还请各位不吝指正，欢迎交流与讨论。如果有朋友因此了解了一些知识或对Java有了更深层次的理解，从而进行更进一步的学习，那么这篇文章的意义也就达到了。

目录

1.不可变集合

2.Stream流

2.1Stream流的概述

2.2Stream流的获取

2.3Stream流的常用API

2.4Stream流的综合应用

2.5收集Stream流

3.异常处理

3.1异常概述、体系

3.2常见运行时异常

3.3常见编译时异常

3.4异常的默认处理流程

3.5编译时异常的处理机制

3.6自定义异常

不可变集合、Stream流、异常

1.不可变集合

什么是不可变集合？

        不可变集合，就是不可被修改的集合。

        集合的数据项在创建的时候提供，并且在整个生命周期中都不可改变。否则报错。

为什么要创建不可变集合？

        如果某个数据不能被修改，把它防御性地拷贝到不可变集合中是个很好的实践。

        或者当集合对象被不可信的库调用时，不可变形式是安全的。

如何创建不可变集合？

        在List、Set、Map接口中，都存在of方法，可以创建一个不可变的集合。

创建不可变集合的of方法

方法名

说明

static <E> List<E> of(E…elements)

创建一个具有指定元素的List集合对象

static <E> Set<E> of(E…elements)

创建一个具有指定元素的Set集合对象

static <K , V> Map<K，V> of(E…elements)

创建一个具有指定元素的Map集合对象

        注：上述方法是JDK9之后的方法，JDK8不支持。

        不可变集合不允许添加、删除或修改，否则报错。

2.Stream流

2.1Stream流的概述

什么是Stream流？

        在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream流概念。

        目的：用于简化集合和数组操作的API。

Stream流式思想的核心

        先得到集合或者数组的Stream流（就是一根传送带）。

        把元素放上去。

        然后就用这个Stream流简化的API来方便的操作元素。

Stream流的三类方法

获取Stream流

        创建一条流水线，并把数据放到流水线上准备进行操作。

中间方法

        流水线上的操作。一次操作完毕之后，还可以继续进行其他操作（支持链式编程）。

终结方法

        一个Stream流只能有一个终结方法，是流水线上的最后一个操作。

2.2Stream流的获取

获取Stream流

        Stream操作集合或者数组的第一步是先得到Stream流，然后才能使用流的功能，可以使用Collection接口中的默认方法stream()生成流。

集合获取Stream流的方式

方法名

说明

default Stream<E> stream()

获取当前集合对象的Stream流

数组获取Stream流的方式

方法名

说明

public static <T> Stream<T> stream(T[] array)

（Arrays类静态方法）

获取当前数组的Stream流

public static<T> Stream<T> of(T... values)

（Stream类静态方法）

获取当前数组/可变数据的Stream流

        示例代码如下：

public static void main(String[] args) {
        /**
         * 集合获取Stream流
         */
        // Collection集合获取stream流
        Collection<String> list = new ArrayList<>();
        Stream<String> s = list.stream();

        // Map集合获取stream流
        Map<String, Integer> map = new HashMap<>();
        // 获取键流
        Stream<String> keyStream = map.keySet().stream();
        // 获取值流
        Stream<Integer> valueStream = map.values().stream();
        // 键值对流
        Stream<Map.Entry<String, Integer>> keyAndValueStream = map.entrySet().stream();

        /**
         * 数组获取Stream流
         */
        String[] names = {"张三", "李四", "王五"};
        Stream<String> nameStream = Arrays.stream(names);

        Stream<String> nameStream2 = Stream.of(names);
        Stream<String> nameStream3 = Stream.of("张三", "李四", "王五");
    }

2.3Stream流的常用API

中间方法

Stream流的常用API(中间操作方法)

方法名

说明

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

用于对流中的数据进行过滤

Stream<T> limit (long maxSize)

获取前几个元素（不是索引）

Stream<T> skip (long n)

跳过前几个元素（不是索引）

public fina<R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper)

加工方法map

static <T> Stream<T> concat (Stream a, Stream b)

合并a和b两个流为一个流

Stream<T> distinct ()

去除流中重复的元素

依赖hashCode和equals方法

        示例代码如下：

    public static void main(String[] args) {
        // 1.   Stream<T> filter(Predicate<? super T> predicate)	用于对流中的数据进行过滤
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "张三", "李四", "王五", "赵六", "张四", "张张三");
//        list.stream().filter(new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.startsWith("张");
//            }
//        });
        // lambda表达式简化匿名内部类
        list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));
        System.out.println("--------1---------");

        // 2.   public finalong count()	用于对流中的数据进行计数
        long size = list.stream().filter(s -> s.length() == 3).count();
        System.out.println(size); // 1
        System.out.println("--------2---------");

        // 3.   Stream<T> limit (long maxSize)	获取前几个元素
//        list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(s -> System.out.println(s + "\t"));
        // 使用方法引用简化代码
        list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(System.out::println);
        System.out.println("--------3---------");

        // 4.   Stream<T> skip (long n)	跳过前几个元素
        list.stream().filter(s -> s.startsWith("张")).skip(2).forEach(System.out::println); // 张张三
        System.out.println("--------4---------");

        // 5.加工方法map
        /**
         * public fina<R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper)
         * Function()方法的泛型中，第一个参数：原材料参数类型    第二个参数：加工后返回的参数类型
         */
//        list.stream().map(new Function<String, String>() {
//            @Override
//            public String apply(String s) {
//                return "聪明的" + s;
//            }
//        }).forEach(System.out::println);
        list.stream().map(s -> "聪明的" + s).forEach(System.out::println);
        System.out.println("--------5---------");

        // 6.   static <T> Stream<T> concat (Stream a, Stream b)	合并a和b两个流为一个流
        Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
        Stream<String> s2 = Stream.of("Java1", "Java2", "Java3");
        Stream<String> s3 = Stream.concat(s1, s2);
        s3.forEach(System.out::println);
        System.out.println("--------6---------");

        // 7.   Stream<T> distinct ()	去除流中重复的元素，依赖hashCode和equals方法
        Collections.addAll(list, "Java", "Java", "HTML", "Java");
        list.stream().distinct().forEach(System.out::println); // 删除重复的两个"Java"，只剩一个
        System.out.println("--------7---------");
    }

        程序运行结果如下：

张三

张四

张张三

--------1---------

1

--------2---------

张三

张四

--------3---------

张张三

--------4---------

聪明的张三

聪明的李四

聪明的王五

聪明的赵六

聪明的张四

聪明的张张三

--------5---------

张三

张四

张张三

Java1

Java2

Java3

--------6---------

张三

李四

王五

赵六

张四

张张三

Java

HTML

--------7---------

注：

        中间方法也称为非终结方法，调用完成后返回新的Stream流可以继续使用，支持链式编程。

        在Stream流中无法直接修改集合、数组中的数据。

终结方法

常见的Stream流终结方法

方法名

说明

void forEach (Consumer action)

对此流的每个元素执行遍历操作

public finalong count()

用于对流中的数据进行计数

        终结操作方法，调用完成后流就无法继续使用了，原因是不会返回Stream流。

2.4Stream流的综合应用

        需求：某个公司的开发部门，分为开发一部和二部，现在需要进行年中数据结算。

分析：

        ①：员工信息至少包含了(名称、性别、工资、奖金、处罚记录)。

        ②：开发一部有4个员工、开发二部有5名员工。

        ③：分别筛选出2个部门的最高工资的员工信息，封装成优秀员工对象Topperformer。

        ④：分别统计出2个部门的平均月收入，要求去掉最高和最低工资。

        ⑤：统计2个开发部门整体的平均工资，去掉最低和最高工资的平均值。

        示例代码如下：

public class StreamDemo3 {
    static double totalMoney = 0.0; // 部门一月收入总和（去掉最高与最低）
    static double totalMoney2 = 0.0; // 部门一和部门二月收入总和（去掉最高与最低）

    public static void main(String[] args) {
        List<Employee> one = new ArrayList<>();
        one.add(new Employee("孙悟空", '男', 25000, 1000, "顶撞上司"));
        one.add(new Employee("猪八戒", '男', 30000, 25000, null));
        one.add(new Employee("沙僧", '男', 20000, 20000, null));
        one.add(new Employee("小白龙", '男', 20000, 25000, null));

        List<Employee> two = new ArrayList<>();
        two.add(new Employee("武松", '男', 15000, 9000, null));
        two.add(new Employee("李逵", '男', 20000, 10000, null));
        two.add(new Employee("林冲", '男', 50000, 100000, "流放"));
        two.add(new Employee("扈三娘", '女', 3500, 1000, "领盒饭"));
        two.add(new Employee("孙二娘", '女', 20000, 0, "做包子"));

//        Employee e = one.stream().max((o1, o2) -> Double.compare(o1.getSalary() + o1.getBonus(),o2.getSalary() + o2.getBonus())).get();
//        System.out.println(e); // Employee{name='猪八戒', sex=男, salary=30000.0, bonus=25000.0, punish='null'}
        // 筛选出部门最高工资的员工信息，封装成优秀员工对象Topperformer
        TopperFormer t = one.stream().max((o1, o2) -> Double.compare(o1.getSalary() + o1.getBonus(), o2.getSalary() + o2.getBonus()))
                .map(s -> new TopperFormer(s.getName(), s.getSalary() + s.getBonus())).get();
        System.out.println(t); // TopperFormer{name='猪八戒', money=55000.0}

        // 统计出部门的平均月收入，要求去掉最高和最低工资
        one.stream().sorted((o1, o2) -> Double.compare(o1.getSalary() + o1.getBonus(), o2.getSalary() + o2.getBonus()))
                .skip(1).limit(one.size() - 2).forEach(e -> {
            // 求部门月总收入（去掉最高和最低工资）
            totalMoney += (e.getSalary() + e.getBonus());
        });
        System.out.println("部门一月平均工资：" + (totalMoney / (one.size() - 2))); // 月平均工资：42500.0

        // 统计出两个部门的平均月收入，要求去掉最高和最低工资
        // 合并两个集合stream流，再进行统计
        Stream<Employee> s1 = one.stream();
        Stream<Employee> s2 = two.stream();
        Stream<Employee> s3 = Stream.concat(s1, s2);
        s3.sorted((o1, o2) -> Double.compare(o1.getSalary() + o1.getBonus(), o2.getSalary() + o2.getBonus()))
                .skip(1).limit(one.size() + two.size() - 2).forEach(e -> { // 此处不能用s3.count()，会直接关闭stream流，无法执行后续操作！
            // 求部门月总收入（去掉最高和最低工资）
            totalMoney2 += (e.getSalary() + e.getBonus());
        });
        // 解决精度问题   BigDecimal
        BigDecimaa = BigDecimal.valueOf(totalMoney2);
        BigDecimab = BigDecimal.valueOf(one.size() + two.size() - 2);
        System.out.println("两个部门月平均工资：" + a.divide(b, 4, RoundingMode.HALF_UP)); // 两个部门月平均工资：34285.7143
    }
}

        注：在stream流执行中途需要进行计数时不能用s.count()，会直接关闭stream流，无法执行后续操作！

2.5收集Stream流

Stream流的收集操作

        收集Stream流的含义：就是把Stream流操作后的结果数据转回到集合或者数组中去。

        Stream流：方便操作集合/数组的手段。

        集合/数组：才是开发中的目的。

Stream流的收集方法

方法名

说明

R collect (Collector collector)

开始收集Stream流，指定收集器

Collectors工具类提供的具体收集方式

方法名

说明

public static <T> Collector toList ()

把元素收集到List集合中

public static <T> Collector toSet ()

把元素收集到Set集合中

public static Collector toMap (Function keyMapper , Function valueMapper)

把元素收集到Map集合中

        上述两类API需要配合使用。

        示例代码如下：

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Collections.addAll(list, "张三", "李四", "王五", "赵六", "张四", "张张三");
        // 将stream流内容收集到List集合中
        Stream<String> strStream = list.stream().filter(s -> s.startsWith("张"));
        List<String> zhangList = strStream.collect(Collectors.toList());
        System.out.println(zhangList); // [张三, 张四, 张张三]

        // 在将stream流转换为List集合后，直接再次转换为Set集合，会报错
        // 编译不会出问题，但是此时stream流只能使用一次，此时已经关闭，不能再次使用
//        Set<String> zhangSet = strStream.collect(Collectors.toSet());
//        System.out.println(zhangSet);

        // 将stream流内容收集到数组中
        Stream<String> strStream2 = list.stream().filter(s -> s.startsWith("张"));
        Object[] arr = strStream2.toArray();
        System.out.println("Array数组内容：" + Arrays.toString(arr)); // Array数组内容：[张三, 张四, 张张三]
    }

3.异常处理

3.1异常概述、体系

什么是异常？

        异常是程序在“编译”或者“执行”的过程中可能出现的问题，比如:数组索引越界、空指针异常、日期格式化异常等，语法错误不算在异常体系中。

        异常体系如下图所示。

        Error：系统级别问题、JVM退出等，代码无法控制。

        Exception：java.lang包下，称为异常类，它表示程序本身可以处理的问题。

        RuntimeException及其子类：运行时异常，编译阶段不会报错(如空指针异常，数组索引越界异常)。

        除RuntimeException之外所有的异常：编译时异常，编译期必须处理的，否则程序不能通过编译(如日期格式化异常)。

        编译时异常和运行时异常如下图所示。

        简单来说：编译时异常就是在编译的时候出现的异常，运行时异常就是在运行时出现的异常。

3.2常见运行时异常

运行时异常

        直接继承自RuntimeException或者其子类，编译阶段不会报错，运行时可能出现的错误。

运行时异常示例

        数组索引越界异常: ArrayIndexOutOfBoundsException

        空指针异常: NullPointerException，直接输出没有问题，但是调用空指针的变量的功能就会报错。

        类型转换异常：ClassCastException

        数学操作异常：ArithmeticException

        数字转换异常：NumberFormatException

3.3常见编译时异常

        编译时异常是编译阶段就出错的，所以必须处理，否则代码根本无法通过。

        编译时异常如下图所示。

编译时异常的作用？

        在编译阶段提醒程序员不要出错。

3.4异常的默认处理流程

异常的默认处理流程

        ①默认会在出现异常的代码那里自动的创建一个异常对象，如ArithmeticException。

        ②异常会从方法中出现的点这里抛出给调用者，调用者最终抛出给JVM虚拟机。

        ③虚拟机接收到异常对象后，先在控制台直接输出异常栈信息数据。

        ④直接从当前执行的异常点结束当前程序。

        ⑤后续代码没有机会执行了，因为程序已经死亡。

        注：默认的异常处理机制并不好，因为一旦出现异常，程序将立即死亡！

3.5编译时异常的处理机制

        编译时异常是编译阶段就出错的，所以必须处理，否则代码根本无法通过。

编译时异常的处理形式有三种：

        ①出现异常直接抛出去给调用者，调用者也继续抛出去。

        ②出现异常自己捕获处理。

        ③前两者结合，出现异常直接抛出去给调用者，调用者捕获处理。

异常处理方式1—throws

        throws：用在方法上，可以将方法内部出现的异常抛出去给本方法的调用者处理。

        这种方式并不好，发生异常的方法自己不处理异常，如果异常最终抛出去给虚拟机将引起程序死亡。

        throws抛出异常格式如下图所示。

        注：Exception代表可以抛出一切异常，与罗列抛出多个异常具有相同的效果，具体在执行过程中仍然会抛出某个具体的异常。

异常处理方式2—try…catch…

        监视捕获异常，用在方法内部，可以将方法内部出现的异常直接捕获处理。

        发生异常的方法自己独立完成异常的处理，程序不会被结束，可以继续向下执行。

        try...catch...处理异常格式如下图所示。

        示例代码如下：

public class ExceptionDemo1 {
    public static void main(String[] args) {
        System.out.println("程序开始...");
        parseTime("2011-11-11 11:11:11");
        // 利用try...catch，程序不会被结束，可以继续向下执行，能够打印出"程序结束..."
        System.out.println("程序结束");
    }

    public static void parseTime(String date) {
        /*try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
            Date d = sdf.parse(date); // 执行到这发生异常，直接跳转到相应catch代码，不会执行下方剩余的try代码，即每次执行最多只能catch一个异常
            System.out.println(d);
            InputStream is = new FileInputStream("E:/54DAS5D4");
        } catch (ParseException e) {
            e.printStackTrace(); // 打印异常栈信息
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }*/
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
            Date d = sdf.parse(date); // 执行到这发生异常，直接跳转到相应catch代码，不会执行下方剩余的try代码，即每次执行最多只能catch一个异常
            System.out.println(d);
            InputStream is = new FileInputStream("E:/54DAS5D4");
        } catch (Exception e) {
            e.printStackTrace(); // 打印异常栈信息
        }
    }
}

        程序运行结果如下：

程序开始...

java.text.ParseException: Unparseable date: "2011-11-11 11:11:11"

at java.text.DateFormat.parse(DateFormat.java:366)

at com.itheima.d4_exception_handle.ExceptionDemo1.parseTime(ExceptionDemo1.java:36)

at com.itheima.d4_exception_handle.ExceptionDemo1.main(ExceptionDemo1.java:18)

程序结束

        注：Exception代表可以catch一切异常，与罗列catch多个异常具有相同的效果，具体在执行过程中仍然会catch并打印出某个具体的异常信息。

异常处理方式3—前两者结合

        方法直接将异常通过throws抛出给调用者。

        调用者收到异常后直接捕获处理。

3.6自定义异常

自定义异常的分类

（1）自定义编译时异常

        ①定义一个异常类继承Exception

        ②重写构造器。

        ③在出现异常的地方用throw new 自定义对象抛出。

        作用：编译时异常是编译阶段就报错，提醒更加强烈，一定需要处理。

        示例代码如下：

AgeIllegalException类

public class AgeIllegalException extends Exception {
    // 1.继承Exception
    // 2.重写构造器

    public AgeIllegalException() {
    }

    // 创建异常对象时的原因
    public AgeIllegalException(String message) {
        super(message);
    }
}

测试类

public class ExceptionDemo {
    // 需求：0-200岁年龄合法
    public static void main(String[] args) {
        System.out.println("程序开始...");
        try {
            checkAge(-20);
        } catch (AgeIllegalException e) {
            e.printStackTrace();
        }
        System.out.println("程序结束...");

    }

    public static void checkAge(int age) throws AgeIllegalException {
        if (age < 0 || age > 200) {
            // 3.抛出异常对象
            // throw 在方法内部直接创建异常对象，并在此处将异常抛出给该方法
            // throws 用在方法声明上，抛出方法内部的异常
            throw new AgeIllegalException(age + "年龄非法！");
        } else {
            System.out.println("年龄合法");
        }

        程序运行结果如下：

程序开始...

程序结束...

com.itheima.d4_exception_custom.AgeIllegalException: -20年龄非法！

at com.itheima.d4_exception_custom.ExceptionDemo.checkAge(ExceptionDemo.java:26)

at com.itheima.d4_exception_custom.ExceptionDemo.main(ExceptionDemo.java:13)

throw与throws的区别

        throw在方法内部直接创建异常对象，并在此处将异常抛出给该方法。

        throws用在方法声明上，抛出方法内部的异常给该方法的调用者。

（2）自定义运行时异常

        定义一个异常类继承RuntimeException.

        重写构造器。

        在出现异常的地方用throw new 自定义对象抛出。

        作用：提醒不强烈，编译阶段不报错，方法声明时无需声明抛出异常，若有错误运行时直接抛出（建议用try...catch捕获）。

        示例代码如下：

public class AgeIllegalRuntimeException extends RuntimeException {
    // 1.继承Exception
    // 2.重写构造器

    public AgeIllegalRuntimeException() {
    }

    // 创建异常对象时的原因
    public AgeIllegalRuntimeException(String message) {
        super(message);
    }
}

测试类

public class ExceptionDemo2 {
    // 需求：0-200岁年龄合法
    public static void main(String[] args) {
        System.out.println("程序开始...");
        try {
            checkAge(-20);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("程序结束...");

    }

    public static void checkAge(int age) {
        if (age < 0 || age > 200) {
            // 3.抛出异常对象
            // throw 在方法内部直接创建异常对象，并在此处将异常抛出给该方法
            // throws 用在方法声明上，抛出方法内部的异常给该方法的调用者
            throw new AgeIllegalRuntimeException(age + "年龄非法！");
        } else {
            System.out.println("年龄合法");
        }
    }
}

        程序运行结果如下：

程序开始...

程序结束...

com.itheima.d4_exception_custom.AgeIllegalRuntimeException: -20年龄非法！

at com.itheima.d4_exception_custom.ExceptionDemo2.checkAge(ExceptionDemo2.java:26)

at com.itheima.d4_exception_custom.ExceptionDemo2.main(ExceptionDemo2.java:13)

写在最后：

        感谢读完！

        纵然缓慢，驰而不息！加油！

【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 16万+
优快云最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java集合框架基础知识详解 Java Collections Framework Basics
AI天才研究院
08-01 2114
Java集合框架（Collection Framework）是Java中用于存放、管理和访问数据的一个重要组成部分。在许多开发场景下都需要用到集合框架，比如数据库处理、业务逻辑处理、GUI编程等。本教程将带领读者了解Java集合框架的一些基础知识以及如何正确地使用它。在学习完本文后，读者将对Java集合框架有更深刻的理解并掌握其应用技巧。
不可变集合 Stream 异常
qq_41370619的博客
02-23 143
不可变集合 Stream 异常
不可变集合 Stream流体系 异常概述，分类，和认识，异常的处理机制，异常的强大演示，自定义异常
m0_53302947的博客
07-15 300
不可变集合 Stream流体系 异常概述，分类，和认识，异常的处理机制，异常的强大演示，自定义异常
不可变集合、Stream流、异常处理
weixin_43584531的博客
03-13 1001
不可变集合的特点？ 定义完成后不可以修改，或者添加、删除 如何创建不可变集合？ List、Set、Map接口中，都存在of方法可以创建不可变集合。 Stream流 在Java 8中，得益于Lambda所带来的函数式编程， 引入了一个全新的Stream流概念。 目的：用于简化集合和数组操作的API。 说说Stream流的思想和使用步骤： 先得到集合或者数组的Stream流（就是一根传送带）。流只能使用一次！ 把元素放上去， 然后就用这个Stream流简化的API来方便的操作元素。 1、集合获取
Java 8 中流 Stream 操作防止空指针异常的简洁写法
06-23 9521
参考链接https://stackoverflow.com/questions/41590134/null-safe-collection-as-stream-in-java-8 在操作集合的时候经常写类似这样的代码来防止出现集合为空的情况: public void streamOp(List sourceList) { if (sourceList == null) { sourceList = new ArrayList(); } // ... } 其实有更简洁的写法: public voi
Optional的应用
obitosbb的博客
10-22 1351
本文的初衷不是为了分享如何使用optional如何使用，而是分享在使用的过程中遇到的一些容易让人忽略的问题，以及我为什么要用optional，当然也会讲解如何使用optional。
【Java基础知识1】Java入门详解
最新发布
阿志的博客
07-24 1142
数组是相同类型数据的有序集合；数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成；其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标(编号、标记)来访问它，下标是从0开始的，例：如果存10个数据，即下标为0 ~ 9。
Java SE 8 集合框架深度剖析：OCA_OCP备考必备知识清单
Java SE 8集合框架在现代软件开发中扮演着基础且重要的角色，提供了丰富的数据结构和算法支持。本文从集合框架的总体概述开始，详细解读了核心集合接口的特点和用法，包括List、Set、Queue和Map接口，及其与Java 8...
Java基础学习笔记及案例代码详解
资源摘要信息: "Java学习资料包含Java SE（Standard Edition）的基础知识点总结与示例代码，旨在帮助学习者掌握Java语言的核心概念和编程技巧。资料内容涵盖了从Java基础语法到面向对象编程，再到数据结构和算法等...
Java8中Stream使用的一个注意事项
08-28
最近在工作中发现了对于集合操作转换的神器，java8新特性 stream，但在使用中遇到了一个非常重要的注意点，所以这篇文章主要给大家介绍了关于Java8中Stream使用过程中的一个注意事项，需要的朋友可以参考借鉴，下面随着小编来一起学习学习吧。
Java Stream 的一些技巧
insisxz的博客
03-27 2237
Java Stream 的一些技巧 调试 在流处打上断点 在 idea 中，即可直接看到流各个的情况，包括抛出异常 异常和非空的判断 1、空集合变成流不管怎么操作返回都是空集合，不会抛异常 2、通过进入源码可发现，filter、map 等方法中一般是对 function 进行非空判断 filter 如果条件为 null 会抛出异常，但并不是因为这里 predicate 为 null，predicate 在这里是函数 getDefault()，而是因为 predicate 接收的是 java
list调用stream().collect方法报错空指针异常
梦想不会灭
06-13 8073
list调用stream方法报空指针原因及解决方案
java8 Stream流Collectors.toMap value为空报错
热门推荐
qq_31086797的博客
06-09 1万+
public class Test { public static void main(String[] args) { List<User> list = new ArrayList<>(); User user = new User(); user.setName("jack"); list.add(user); // 报错 list.stream().collect(Collector
【Stream】在使用 java.util.stream.Collectors 类的 toMap() 方法转为 Map 集合时，一定要注意当 value 为 null 时会抛 NPE 异常。
xiaobei72aaa的博客
06-09 436
所以在使用该方法时不要包含null值。
使用stream转list为map报错java.lang.IllegalStateException: Duplicate key
qq_33967604的博客
01-28 2231
一.背景 在很多场景下，需要将List的数据转化为Map的键值对的场景，方便快速查询数据。例如：需要根据工号查询出对应的人名名称明细场景。有两种实现场景，第一种通过每个工号查询一次数据库循环查询，明显这种方式不合理，因为对DB压力以及连接不利。第二种将工号集合（需要考虑数据量的场景，Oracle支持最大一千条，mysql虽然无上线，但是考虑性能以及内存占用情况需要考虑上限建议1000以下），接下来是以第二种方式进行展开。 二.开发实践 List<User> userList = new A
list调用stream方法报错空指针异常
MieMieFly的专栏
03-26 6928
java.lang.NullPointerException atjava.util.stream.Collectors.lambda$groupingBy$45(Collectors.java:907) atjava.util.stream.ReduceOps$3ReducingSink.accept(ReduceOps.java:169) atjava.util.ArrayList$ArrayListSpliterator.forEachRemain...
stream 流过滤空元素
韩猿外的博客
12-23 4847
Java Stream流式处理
chy-x 的博客
04-15 5639
findFirst()、findAny() 返回 Optional，但选取的元素是null时，这2个方法会直接抛出NPE，后续也就没必要用 Optional 的 orElse()、orElseGet() 来设置为 null 时的默认值。stream 流，是jdk8新增的一种集合处理方式，可以将集合转换为流，进而对集合中的元素进行排序、过滤、聚合等⼀系列的操作。相比于map()，mapToXxx() 还提供了该种类型的流的特有方法，比如数值型求和、平均数、最值。将流中的元素映射为对应的流（列表）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值