Stream流（工厂的流水线）

最新推荐文章于 2024-08-23 15:54:50 发布
最新推荐文章于 2024-08-23 15:54:50 发布
阅读量246 收藏 1
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51617439/article/details/127340959
版权

文章目录

一、Stream流（工厂的流水线）

1、Stream流的介绍

Stream是 Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。

Stream是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，流讲的是计算!”

注意:
    1.Stream自己不会存储元素。
    2.Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream。
    3.Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

2、Stream步骤：

  1. 创建Stream 通过数据源（集合、数组）创建Stream流
  2. 调用Stream的中间方法，处理数据
  3. 调用Stream的终结方法，接收处理后的数据

二、创建Stream流

第一种方式：通过Collection系列集合提供的Stream() 或 parallelStream()

public class StreamAPI01 {
    @Test
    public void test(){
        //1.通过Collection系列集合提供的Stream() 或 parallelStream()
        List<String> list = new ArrayList<>();
        Stream<String> stream01 = list.stream();
    }
}

第二种方式：通过Arrays 中的静态方法 stream() 获取数组流

public class StreamAPI01 {
    @Test
    public void test(){
        //2.通过Arrays 中的静态方法 stream() 获取数组流
        Employee[] emps = new Employee[10];
        Stream<Employee> stream02 = Arrays.stream(emps);
    }
}

第三种方式：通过Stream类中的静态方法 of()

public class StreamAPI01 {
    @Test
    public void test(){
        //3.通过Stream类中的静态方法 of()
        Stream<String> stream03 = Stream.of("aa", "bb", "cc");
    }
}

第四种方式：创建无限流

public class StreamAPI01 {
    @Test
    public void test(){
        //4.创建无限流
        //迭代
        Stream<Integer> stream04 = Stream.iterate(0,(x)->x+2);
        stream04.limit(10).forEach(System.out::println);

        //生成
        Stream.generate(()-> Math.random()).limit(5).forEach(System.out::println);
    }
}

三、中间操作

0、准备操作-创建 Employee类

public class Employee {
    private String name;
    private Integer age;
    private Double salary;

    public Employee() {
    }
    public Employee(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return Objects.equals(name, employee.name) && Objects.equals(age, employee.age) && Objects.equals(salary, employee.salary);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age, salary);
    }
    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

1、筛选与切片

filter 接收Lambda ,从流中排除某些元素。
limit 截断流,使其元素不超过给定数量。
skip(n) 跳过元素，返回一个扔掉了前n 个元素的流。若流中元素不足n 个，则返回一个空流。与limit(n)互补
distinct 筛选，通过流所生成元素的hashCode()和equals()去除重复元素

filter 接收Lambda ,从流中排除某些元素。

public class StreamAPI02 {
    List<Employee> employees = Arrays.asList(
            new Employee("张三", 18, 9999.99),
            new Employee("李四", 58, 5555.55),
            new Employee("王五", 26, 3333.33),
            new Employee("赵六", 36, 6666.66),
            new Employee("田七", 12, 8888.88),
            new Employee("田七", 12, 8888.88)
    );

    /**
     * filter 接收Lambda ,从流中排除某些元素。
     */
    @Test
    public void test01() {
        //中间操作：过滤出年龄大于32的员工
        Stream<Employee> stream = employees.stream()
                .filter((e) -> {
                    return e.getAge() > 32;
                });

        //终止操作：一次执行全部内容，即"惰性求值"
        List<Employee> collect = stream.collect(Collectors.toList()); //接收过滤后的最终结果
        collect.forEach(System.out::println);
    }
}
limit 截断流,使其元素不超过给定数量。(短路操作)
public class StreamAPI02 {
    List<Employee> employees = Arrays.asList(
            new Employee("张三", 18, 9999.99),
            new Employee("李四", 58, 5555.55),
            new Employee("王五", 26, 3333.33),
            new Employee("赵六", 36, 6666.66),
            new Employee("田七", 12, 8888.88),
            new Employee("田七", 12, 8888.88)
    );
    @Test
    public void test02() {
        //中间操作：获取工资大于5000的前三位员工
        Stream<Employee> stream = employees.stream().filter((e) -> {
            return e.getSalary() > 5000;
        }).limit(3);

        //终止操作
        List<Employee> collect = stream.collect(Collectors.toList());
        collect.forEach(System.out::println);
    }
}

skip(n) 跳过元素，返回一个扔掉了前n 个元素的流。若流中元素不足n 个，则返回一个空流。

public class StreamAPI02 {
    List<Employee> employees = Arrays.asList(
            new Employee("张三", 18, 9999.99),
            new Employee("李四", 58, 5555.55),
            new Employee("王五", 26, 3333.33),
            new Employee("赵六", 36, 6666.66),
            new Employee("田七", 12, 8888.88),
            new Employee("田七", 12, 8888.88)
    );
    @Test
    public void test03() {
        //中间操作：跳过前两个符合条件的数据
        Stream<Employee> stream = employees.stream().filter((e) -> {
            return e.getSalary() > 5000;
        }).skip(2);

        //终止操作
        List<Employee> collect = stream.collect(Collectors.toList());
        collect.forEach(System.out::println);
    }
}

distinct 筛选，通过流所生成元素的hashCode()和equals()去除重复元素

public class StreamAPI02 {
    List<Employee> employees = Arrays.asList(
            new Employee("张三", 18, 9999.99),
            new Employee("李四", 58, 5555.55),
            new Employee("王五", 26, 3333.33),
            new Employee("赵六", 36, 6666.66),
            new Employee("田七", 12, 8888.88),
            new Employee("田七", 12, 8888.88)
    );
    @Test
    public void test04() {
        //中间操作：跳过前两个符合条件的数据
        Stream<Employee> stream = employees.stream().filter((e) -> {
            return e.getSalary() > 5000;
        }).distinct();

        //终止操作
        List<Employee> collect = stream.collect(Collectors.toList());
        collect.forEach(System.out::println);
    }
}

2、映射

map 接收Lambda ，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被分发到每个元素上，并将其映射成一个新的元素。
flatMap 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
map 接收Lambda ，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被分发到每个元素上，并将其映射成一个新的元素。
public class StreamAPI02 {
    List<Employee> employees = Arrays.asList(
            new Employee("张三", 18, 9999.99),
            new Employee("李四", 58, 5555.55),
            new Employee("王五", 26, 3333.33),
            new Employee("赵六", 36, 6666.66),
            new Employee("田七", 12, 8888.88),
            new Employee("田七", 12, 8888.88)
    );
    @Test
    public void test1(){
        Stream<String> str = employees.stream().map((e) -> e.getName());
        System.out.println("-------------------------------------------");

        //map() 将函数应用到每一个元素上
        //将每一个字符串变成大写字符串
        List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
        Stream<String> stream = strList.stream().map(String::toUpperCase);
        stream.forEach(System.out::println);

        //将每一个字符串元素，拆成字符输出
        Stream<Stream<Character>> stream2 = strList.stream().map(StreamAPI03::filterCharacter);
        stream2.forEach((sm) -> {
            sm.forEach(System.out::println);
        });
    }
    //接收一个字符串，将其转成字符，并添加到list集合中，最后转成流返回
    public static Stream<Character> filterCharacter(String str){
        List<Character> list = new ArrayList<>();

        for (Character ch : str.toCharArray()) {
            list.add(ch);
        }

        return list.stream();
    }
}
flatMap 接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流
public class StreamAPI02 {
    List<Employee> employees = Arrays.asList(
            new Employee("张三", 18, 9999.99),
            new Employee("李四", 58, 5555.55),
            new Employee("王五", 26, 3333.33),
            new Employee("赵六", 36, 6666.66),
            new Employee("田七", 12, 8888.88),
            new Employee("田七", 12, 8888.88)
    );
    @Test
    public void test2(){
        //flatMap 合并流
        List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
        Stream<Character> stream3 = strList.stream().flatMap(StreamAPI03::filterCharacter);
        stream3.forEach(System.out::println);
    }
    //接收一个字符串，将其转成字符，并添加到list集合中，最后转成流返回
    public static Stream<Character> filterCharacter(String str){
        List<Character> list = new ArrayList<>();

        for (Character ch : str.toCharArray()) {
            list.add(ch);
        }

        return list.stream();
    }

}

3、排序

sorted() 自然排序
sorted(Comparator com) 定制排序

sorted() 自然排序

public class StreamAPI02 {
    List<Employee> employees = Arrays.asList(
            new Employee("张三", 18, 9999.99),
            new Employee("李四", 58, 5555.55),
            new Employee("王五", 26, 3333.33),
            new Employee("赵六", 36, 6666.66),
            new Employee("田七", 12, 8888.88),
            new Employee("田七", 12, 8888.88)
    );
    @Test
    public void test1(){
        List<String> list = Arrays.asList("dd", "ss", "aa","ab","bb","cd");

        //排序
        list.stream().sorted().forEach(System.out::println);
    }
}
sorted(Comparator com) 定制排序
public class StreamAPI02 {
    List<Employee> employees = Arrays.asList(
            new Employee("张三", 18, 9999.99),
            new Employee("李四", 58, 5555.55),
            new Employee("王五", 26, 3333.33),
            new Employee("赵六", 36, 6666.66),
            new Employee("田七", 12, 8888.88),
            new Employee("田七", 12, 8888.88)
    );
    @Test
    public void test2(){
        //升序，先按年龄排序，年龄相等按名字排序
        employees.stream().sorted((e1,e2)->{
            if (e1.getAge().equals(e2.getAge())){
                return e1.getName().compareTo(e2.getName());
            }else{
                return -e1.getAge().compareTo(e2.getAge());
            }
        }).forEach(System.out::println);
    }
}

4、查找与匹配

allMatch——检查是否匹配所有元素
anyMatch——检查是否至少匹配一个元素
noneMatch——检查是否没有匹配的元素
findFirst——返回第一个元素
findAny——返回当前流中的任意元素
count——返回流中元素的总个数
max——返回流中最大值
min——返回流中最小值

创建新的员工类

public class Employee02 {
    private int id;
    private String name;
    private int age;
    private double salary;
    private Status status;

    public Employee02() {
    }
    public Employee02(int id, String name, int age, double salary, Status status) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.status = status;
    }

    public Status getStatus() {
        return status;
    }
    public void setStatus(Status status) {
        this.status = status;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String show() {
        return "测试方法引用！";
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee02 that = (Employee02) o;
        return id == that.id && age == that.age && Double.compare(that.salary, salary) == 0 && Objects.equals(name, that.name) && status == that.status;
    }
    @Override
    public int hashCode() {
        return Objects.hash(id, name, age, salary, status);
    }
    @Override
    public String toString() {
        return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status
                + "]";
    }
    public enum Status {
        FREE, BUSY, VOCATION;
    }
}

allMatch——检查是否匹配所有元素
anyMatch——检查是否至少匹配一个元素
noneMatch——检查是否没有匹配的元素

public class StreamAPI05 {
    List<Employee02> emps = Arrays.asList(
            new Employee02(102, "李四", 59, 6666.66, Status.BUSY),
            new Employee02(101, "张三", 18, 9999.99, Status.FREE),
            new Employee02(103, "王五", 28, 3333.33, Status.VOCATION),
            new Employee02(104, "赵六", 8, 7777.77, Status.BUSY),
            new Employee02(104, "赵六", 8, 7777.77, Status.FREE),
            new Employee02(104, "赵六", 8, 7777.77, Status.FREE),
            new Employee02(105, "田七", 38, 5555.55, Status.BUSY)
    );
    @Test
    public void test1(){
        //Status.BUSY 是否匹配全部元素
        boolean bl = emps.stream().allMatch((e) -> e.getStatus().equals(Status.BUSY));
        System.out.println(bl);

        //anyMatch() 是否匹配任意一个元素
        boolean bl1 = emps.stream().anyMatch((e) -> e.getStatus().equals(Status.BUSY));
        System.out.println(bl1);

        //anyMatch 检查有没有匹配的元素
        boolean bl2 = emps.stream().noneMatch((e) -> e.getStatus().equals(Status.BUSY));
        System.out.println(bl2);
    }
}

findFirst——返回第一个元素
findAny——返回当前流中的任意元素

public class StreamAPI05 {
    List<Employee02> emps = Arrays.asList(
            new Employee02(102, "李四", 59, 6666.66, Status.BUSY),
            new Employee02(101, "张三", 18, 9999.99, Status.FREE),
            new Employee02(103, "王五", 28, 3333.33, Status.VOCATION),
            new Employee02(104, "赵六", 8, 7777.77, Status.BUSY),
            new Employee02(104, "赵六", 8, 7777.77, Status.FREE),
            new Employee02(104, "赵六", 8, 7777.77, Status.FREE),
            new Employee02(105, "田七", 38, 5555.55, Status.BUSY)
    );
    @Test
    public void test2(){
        //返回排序后的第一个元素
        Optional<Employee02> op = emps.stream().sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())).findFirst();
        System.out.println(op.get());
        System.out.println("--------------------------------");
        
        //返回当前流中 等于Status.FREE 的任意元素
        Optional<Employee02> op2 = emps.parallelStream()
                .filter((e) -> e.getStatus().equals(Status.FREE))
                .findAny();

        System.out.println(op2.get());
    }
}

count——返回流中元素的总个数
max——返回流中最大值
min——返回流中最小值

public class StreamAPI05 {
    List<Employee02> emps = Arrays.asList(
            new Employee02(102, "李四", 59, 6666.66, Status.BUSY),
            new Employee02(101, "张三", 18, 9999.99, Status.FREE),
            new Employee02(103, "王五", 28, 3333.33, Status.VOCATION),
            new Employee02(104, "赵六", 8, 7777.77, Status.BUSY),
            new Employee02(104, "赵六", 8, 7777.77, Status.FREE),
            new Employee02(104, "赵六", 8, 7777.77, Status.FREE),
            new Employee02(105, "田七", 38, 5555.55, Status.BUSY)
    );
    @Test
    public void test3(){
        //返回元素等于Status.FREE，的总个数
        long count = emps.stream().filter((e) -> e.getStatus().equals(Status.FREE)).count();
        System.out.println(count);

        //返回当前流的最大值
        Optional<Double> op = emps.stream()
                .map(Employee02::getSalary)
                .max(Double::compare);
        System.out.println(op.get());

        //返回当前流的最小值
        Optional<Employee02> op2 = emps.stream()
                .min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(op2.get());
    }
}

5、归约与收集

reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。
collect——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。

public class StreamAPI05 {
    List<Employee02> emps = Arrays.asList(
            new Employee02(102, "李四", 59, 6666.66, Status.BUSY),
            new Employee02(101, "张三", 18, 9999.99, Status.FREE),
            new Employee02(103, "王五", 28, 3333.33, Status.VOCATION),
            new Employee02(104, "赵六", 8, 7777.77, Status.BUSY),
            new Employee02(104, "赵六", 8, 7777.77, Status.FREE),
            new Employee02(104, "赵六", 8, 7777.77, Status.FREE),
            new Employee02(105, "田七", 38, 5555.55, Status.BUSY)
    );
    public void test1(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

        //计算集合的元素的总和
        Integer sum = list.stream().reduce(0, (x, y) -> x + y);
        System.out.println(sum);
        System.out.println("----------------------------------------");

        //计算工资的总和
        Optional<Double> op = emps.stream().map(Employee02::getSalary).reduce(Double::sum);
        System.out.println(op.get());
    }
}

collect——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法

public class StreamAPI05 {
    List<Employee02> emps = Arrays.asList(
            new Employee02(102, "李四", 59, 6666.66, Status.BUSY),
            new Employee02(101, "张三", 18, 9999.99, Status.FREE),
            new Employee02(103, "王五", 28, 3333.33, Status.VOCATION),
            new Employee02(104, "赵六", 8, 7777.77, Status.BUSY),
            new Employee02(104, "赵六", 8, 7777.77, Status.FREE),
            new Employee02(104, "赵六", 8, 7777.77, Status.FREE),
            new Employee02(105, "田七", 38, 5555.55, Status.BUSY)
    );
    @Test
    public void test2(){
        //获取emps集合中的全部名字，并存到List中
        List<String> list = emps.stream().map(Employee02::getName).collect(Collectors.toList());
        list.forEach(System.out::println);
        System.out.println("----------------------------------");

        //获取emps集合中的全部名字，并存到Set中
        Set<String> set = emps.stream().map(Employee02::getName).collect(Collectors.toSet());
        set.forEach(System.out::println);
        System.out.println("----------------------------------");

        //获取emps集合中的全部名字，并存到HashSet中
        HashSet<String> hs = emps.stream().map(Employee02::getName).collect(Collectors.toCollection(HashSet::new));
        hs.forEach(System.out::println);
    }
}

一介书生.
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java Stream流（详解）
m0_60489526的博客
08-29 7万+
一、Stream流引入 Lambda表达式，基于Lambda所带来的函数式编程，又引入了一个全新的Stream概念，用于解决集合类库既有的鼻端。（Lambda表达式详解在上篇博客内容） 现有一个需求： 将list集合中姓张的元素过滤到一个新的集合中 然后将过滤出来的姓张的元素中，再过滤出来长度为3的元素，存储到一个新的集合中 1.用常规方法解决需求 /...
Java8——Stream流详解
weixin_44863459的博客
08-27 2129
Stream
大厂必备Stream流、方法引用的使用
weixin_45565886的博客
01-04 496
大厂必备Stream流、方法引用的使用
java8 list切片_Java8中你可能不知道的一些地方之Stream实战
weixin_39790510的博客
01-14 158
说起流，我们会想起手机 ，电脑组装流水线，物流仓库商品包装流水线等等。如果把手机 ,电脑,包裹看做最终结果的话,那么加工商品前的各种零部件就可以看做数据源，而中间一系列的加工作业操作，就可以看做流的处理。流的概念Java Se中对于流的操作有输入输出IO流,而Java8中引入的Stream 属于Java API中的一个新成员，它允许你以声明性方式处理数据集合，Stream 使用一种类似 SQL 语...
深入理解Java Stream流水线
weixin_30423977的博客
03-28 2321
前面我们已经学会如何使用Stream API，用起来真的很爽，但简洁的方法下面似乎隐藏着无尽的秘密，如此强大的API是如何实现的呢？Pipeline是怎么执行的，每次方法调用都会导致一次迭代吗？自动并行又是怎么做到的，线程个数是多少？本节我们学习Stream流水线的原理，这是Stream实现的关键所在。 首先回顾一下容器执行Lambda表达式的方式，以ArrayList.forEach()方法为例...
Stream流
m0_57463864的博客
07-28 809
Stream也称Stream流，可以用于的。优势：Stream流大量的结合了Lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操作集合或者数组中的数据，代码更简洁，可读性更好。
Stream流简介
donjor的博客
09-14 698
Stream流简介 说到Stream便容易想到I/O 流，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。 集合的弊端: ​ 每一次筛选都需要定义一个新的集合来存储结果 ​ 每一次操作集合中所有的元素都需要通过循环来遍历 1.s流式思想概念 Stream流主要用于解决已有集合类库...
java中的流stream_java中的Stream流
weixin_31859675的博客
02-23 258
java中的Stream流说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带 来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。一、引言传统集合的多步遍历代码几乎所有的集合(如 Collection 接口或 Map 接口等)都支持直接或间接的遍历操作。而当我们需要对集合中的元 素进行操...
【Java】Stream流、方法引用
专注于Java领域开发 关注我 带你玩转Java
08-20 737
Stream流、方法引用
Java Stream 流实现合并操作示例
08-19
Java Stream 流实现合并操作示例 Java Stream 流实现合并操作示例是 Java Stream Api 的一个重要应用场景。在实际开发中，我们经常需要将多个 Stream 流合并成一个流，以便进行后续的数据处理。今天，我们将详细...
详解JAVA Stream流
08-18
Java Stream流详解 Java Stream流是Java 8中引入的一种新的数据处理方式，它提供了一种高效、灵活的数据处理方式，能够帮助开发者更方便地处理大量数据。 Stream流不是一种数据结构，它也不是集合元素，而是一种...
Stream流的思维导图
08-20
Stream流的思维导图
Java Stream流知识总结
08-19
"Java Stream流知识总结" Java Stream流是Java 8中引入的一种新的编程模型，用于解决传统集合类库的弊端。 Stream流可以看作是一个集合元素的函数模型，它并不是集合，也不是数据结构，其本身并不存储任何元素或其...
Java Stream 流的使用过程解析
08-25
Java Stream 流的使用过程解析 Java Stream 流是 Java 8 中引入的一种新的数据处理方式，旨在提供一种高效、灵活的数据处理方法。Stream 流提供了丰富的数据处理功能，可以对数据进行筛选、映射、聚合、分组等操作...
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 550
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
Yolov8：模型部署到安卓端
m0_70694811的博客
08-21 791
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。
笔记redis
风止的博客
08-22 1060
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 761
@Transactional中使用线程锁导致了锁失效与解决方案
stream 流方式
04-25
stream流是Java中用于处理输入输出的一种方式。它提供了一种便捷的方式来读取和写入数据，可以用于处理文件、网络连接等各种输入输出操作。 stream流可以分为输入流和输出流两种类型。输入流用于从外部读取数据，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值