Java8 Stream 使用详解

news2024/10/7 6:47:34

Java8 Stream 使用详解

  • 一、流的定义
  • 二、流的创建
    • 1. 通过集合创建流：
    • 2. 通过数组创建流：
    • 3. 通过Stream.of()创建流：
    • 4. 通过Stream.generate()创建流：
    • 5. 通过Stream.iterate()创建流：
    • 6. 通过文件、网络、IO流等方式来创建流：
  • 三、常用流
    • 1. 中间操作
      • 1.1. filter(Predicate<T> predicate)：
      • 1.2. map(Function<T, R> mapper)：
      • 1.3. flatMap(Function<T, Stream<R>> mapper)：
      • 1.4. sorted()：
      • 1.5. distinct()：
      • 1.6. limit(long maxSize)：
    • 2. 终端操作
      • 2.1. forEach(Consumer<T> action)：
      • 2.2. collect(Collector<T, A, R> collector)：
      • 2.3. count()：
      • 2.4. anyMatch(Predicate<T> predicate)：
      • 2.5. allMatch(Predicate<T> predicate)：
      • 2.6. noneMatch(Predicate<T> predicate)：
      • 2.7. reduce(BinaryOperator<T> accumulator)：
      • 2.8. min(Comparator<T> comparator)：
      • 2.9. max(Comparator<T> comparator)：

java8

一、流的定义

  1. Java 8引入了Stream流的概念，它是对集合对象（Collection）进行操作的高级抽象。
  2. Stream流的操作分为两种：中间操作和终端操作。
  3. 中间操作是指在流上进行的操作，返回的仍然是一个流，可以进行链式操作，而终端操作是指对流的最终操作，返回的是一个结果或者一个副作用。
  4. Stream流的特点如下：
  • Stream流是对集合对象的一种封装，使得可以用函数式编程的方式对集合进行操作。
  • Stream流的操作是延迟执行的，只有在终端操作时才会触发执行。
  • Stream流可以进行并行操作，提高了程序的性能。

二、流的创建

1. 通过集合创建流：

可以通过集合类的stream()方法或parallelStream()方法来创建一个流。例如：

List<String> list = Arrays.asList(“a”, “b”, “c”);
Stream<String> stream = list.stream();

2. 通过数组创建流：

可以通过Arrays类的stream()方法来创建一个数组流。例如：

String[] array = {“a”, “b”, “c”};
Stream<String> stream = Arrays.stream(array);

3. 通过Stream.of()创建流：

可以使用Stream类的of()方法来创建一个流。例如：

Stream<String> stream = Stream.of(“a”, “b”, “c”);

4. 通过Stream.generate()创建流：

可以使用Stream类的generate()方法来创建一个无限流，需要提供一个Supplier来生成流中的元素。例如：

Stream<String> stream = Stream.generate(() -> “element”);

5. 通过Stream.iterate()创建流：

可以使用Stream类的iterate()方法来创建一个无限流，需要提供一个初始值和一个UnaryOperator来生成流中的元素。例如：

Stream<Integer> stream = Stream.iterate(0, n -> n + 1);

6. 通过文件、网络、IO流等方式来创建流：

例如：

Stream<String> stream = Files.lines(Paths.get(“file.txt”));
Stream<String> stream = BufferedReader.lines();

这些是Java 8中常用的几种创建流Stream的方式，可以根据具体的需求选择适合的方式来创建流。

三、常用流

1. 中间操作

1.1. filter(Predicate predicate)：

根据给定的条件对流进行过滤，只保留满足条件的元素。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class StreamFilterDemo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 使用filter()方法过滤出偶数
        Stream<Integer> evenNumbersStream = numbers.stream()
                .filter(number -> number % 2 == 0);

        // 打印过滤后的结果
        evenNumbersStream.forEach(System.out::println);
    }
}

在上面的示例中，我们首先创建了一个包含整数的列表numbers。然后，我们使用stream()方法将列表转换为流，然后使用filter()方法对流进行过滤，只保留满足条件（即为偶数）的元素。最后，我们使用forEach()方法打印过滤后的结果。

注意：filter()方法返回一个新流，而不会修改原始流。因此，在使用filter()方法后，如果想要继续对流进行其他操作，需要将结果保存到一个新的流中。

1.2. map(Function<T, R> mapper)：

将流中的每个元素通过给定的映射函数进行转换。

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

public class StreamMapDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 将名字转换为大写
        List<String> upperCaseNames = names.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());

        // 打印转换后的结果
        upperCaseNames.forEach(System.out::println);
    }
}

在上面的示例中，我们首先创建了一个包含字符串的列表names。然后，我们使用stream()方法将列表转换为流，然后使用map()方法对流中的每个元素进行转换，将名字转换为大写。最后，我们使用collect()方法将转换后的结果收集到一个新的列表中，并使用forEach()方法打印结果。

在map()方法中，我们传递了一个方法引用String::toUpperCase，它代表了一个从String类型到String类型的映射函数，将字符串转换为大写字母。map()方法会将流中的每个元素都应用这个映射函数，并返回一个新的流，其中包含了转换后的结果。

注意：map()方法返回一个新流，而不会修改原始流。因此，在使用map()方法后，如果想要继续对流进行其他操作，需要将结果保存到一个新的流中。

1.3. flatMap(Function<T, Stream> mapper)：

将流中的每个元素通过给定的映射函数转换为一个新的流，并将所有流合并为一个流。

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

public class StreamFlatMapDemo {
    public static void main(String[] args) {
        List<List<Integer>> numbers = Arrays.asList(
                Arrays.asList(1, 2, 3),
                Arrays.asList(4, 5, 6),
                Arrays.asList(7, 8, 9)
        );

        // 将二维列表转换为一维列表
        List<Integer> flattenedList = numbers.stream()
                .flatMap(List::stream)
                .collect(Collectors.toList());

        // 打印转换后的结果
        flattenedList.forEach(System.out::println);
    }
}

在上面的示例中，我们首先创建了一个包含多个列表的二维列表numbers。然后，我们使用stream()方法将二维列表转换为流，然后使用flatMap()方法对流中的每个元素进行转换，将每个列表转换为一个流，并将所有流合并为一个流。最后，我们使用collect()方法将转换后的结果收集到一个新的列表中，并使用forEach()方法打印结果。

在flatMap()方法中，我们传递了一个方法引用List::stream，它代表了一个从List类型到Stream类型的映射函数，将列表转换为流。flatMap()方法会将流中的每个元素都应用这个映射函数，并返回一个新的流，其中包含了转换后的结果。最后，flatMap()方法会将所有的流合并为一个流。

注意：flatMap()方法返回一个新流，而不会修改原始流。因此，在使用flatMap()方法后，如果想要继续对流进行其他操作，需要将结果保存到一个新的流中。

1.4. sorted()：

对流进行排序，默认按照元素的自然顺序进行排序。

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

public class StreamSortedDemo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(5, 3, 8, 2, 9, 1);

        // 对流进行排序
        List<Integer> sortedList = numbers.stream()
                .sorted()
                .collect(Collectors.toList());

        // 打印排序后的结果
        sortedList.forEach(System.out::println);
    }
}

在上面的示例中，我们首先创建了一个整数列表numbers。然后，我们使用stream()方法将列表转换为流，并使用sorted()方法对流中的元素进行排序。由于没有指定排序规则，所以默认按照元素的自然顺序进行排序。最后，我们使用collect()方法将排序后的结果收集到一个新的列表中，并使用forEach()方法打印结果。

注意：sorted()方法返回一个新流，而不会修改原始流。因此，在使用sorted()方法后，如果想要继续对流进行其他操作，需要将结果保存到一个新的流中。

1.5. distinct()：

去除流中的重复元素。

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

public class StreamDistinctDemo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 4, 3, 5);

        // 去除流中的重复元素
        List<Integer> distinctList = numbers.stream()
                .distinct()
                .collect(Collectors.toList());

        // 打印去重后的结果
        distinctList.forEach(System.out::println);
    }
}

在上面的示例中，我们首先创建了一个整数列表numbers，其中包含一些重复的元素。然后，我们使用stream()方法将列表转换为流，并使用distinct()方法去除流中的重复元素。最后，我们使用collect()方法将去重后的结果收集到一个新的列表中，并使用forEach()方法打印结果。

注意：distinct()方法会根据元素的hashCode()和equals()方法来判断元素是否重复。因此，如果要去除流中的自定义对象的重复元素，需要正确实现该对象的hashCode()和equals()方法。

1.6. limit(long maxSize)：

限制流的大小，只取前N个元素。

import java.util.stream.Stream;

public class StreamLimitDemo {
    public static void main(String[] args) {
        // 创建一个包含整数的无限流
        Stream<Integer> infiniteStream = Stream.iterate(0, i -> i + 1);

        // 限制流的大小，只取前5个元素
        Stream<Integer> limitedStream = infiniteStream.limit(5);

        // 打印限制后的结果
        limitedStream.forEach(System.out::println);
    }
}

在上面的示例中，我们首先创建了一个包含整数的无限流，使用Stream.iterate()方法从0开始生成整数。然后，我们使用limit()方法限制流的大小，只取前5个元素。最后，我们使用forEach()方法打印限制后的结果。

limit()方法接受一个参数maxSize，表示要限制的大小。它会返回一个新的流，其中包含原始流中的前maxSize个元素。如果原始流的大小小于maxSize，则返回原始流的所有元素。

使用limit()方法可以在处理大量数据时，只取需要的部分数据进行操作，提高程序的性能。

2. 终端操作

2.1. forEach(Consumer action)：

对流中的每个元素执行给定的操作。

import java.util.stream.Stream;

public class StreamForEachDemo {
    public static void main(String[] args) {
        // 创建一个包含字符串的流
        Stream<String> stringStream = Stream.of("apple", "banana", "cherry");

        // 对流中的每个元素执行操作
        stringStream.forEach(s -> System.out.println("Fruit: " + s));
    }
}

在上面的示例中，我们首先创建了一个包含字符串的流，使用Stream.of()方法创建一个包含"apple"、"banana"和"cherry"的流。然后，我们使用forEach()方法对流中的每个元素执行操作，即打印出"Fruit: "加上元素的值。

forEach()方法接受一个Consumer接口的实现，用于定义对每个元素的操作。在示例中，我们使用了Lambda表达式来实现Consumer接口，打印出每个水果的名字。

使用forEach()方法可以对流中的每个元素执行任意操作，如打印、计算、过滤等。它是一种简洁、方便的遍历流元素的方式。

2.2. collect(Collector<T, A, R> collector)：

将流中的元素收集到一个集合中，可以是List、Set、Map等。

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamCollectDemo {
    public static void main(String[] args) {
        // 创建一个包含整数的流
        Stream<Integer> numberStream = Stream.of(1, 2, 3, 4, 5);

        // 将流中的元素收集到List集合中
        List<Integer> numberList = numberStream.collect(Collectors.toList());

        // 打印收集到的List集合
        System.out.println(numberList);
    }
}

在上面的示例中，我们首先创建了一个包含整数的流，使用Stream.of()方法创建一个包含1、2、3、4、5的流。然后，我们使用collect()方法将流中的元素收集到List集合中，通过传递Collectors.toList()作为参数，表示将元素收集到一个List集合中。

使用collect()方法可以将流中的元素收集到各种集合中，例如List、Set、Map等。Collectors类提供了许多静态方法，用于创建各种收集器，以满足不同的需求。

你可以根据需要选择适合的收集器，然后将其传递给collect()方法，将流中的元素收集到相应的集合中。

2.3. count()：

返回流中的元素个数。

import java.util.stream.Stream;

public class StreamCountDemo {
    public static void main(String[] args) {
        // 创建一个包含整数的流
        Stream<Integer> numberStream = Stream.of(1, 2, 3, 4, 5);

        // 获取流中的元素个数
        long count = numberStream.count();

        // 打印元素个数
        System.out.println("Number of elements: " + count);
    }
}

在上面的示例中，我们首先创建了一个包含整数的流，使用Stream.of()方法创建一个包含1、2、3、4、5的流。然后，我们使用count()方法获取流中的元素个数，将结果保存在一个long类型的变量中。

最后，我们打印出元素个数。注意，count()方法返回的是一个long类型的值，表示流中的元素个数。

使用count()方法可以方便地获取流中元素的个数，无需遍历整个流。这对于需要统计元素个数的场景非常有用。

2.4. anyMatch(Predicate predicate)：

检查流中是否存在满足给定条件的元素。

import java.util.stream.Stream;

public class StreamAnyMatchDemo {
    public static void main(String[] args) {
        // 创建一个包含字符串的流
        Stream<String> stringStream = Stream.of("apple", "banana", "orange", "grape");

        // 检查流中是否存在长度大于5的元素
        boolean anyMatch = stringStream.anyMatch(s -> s.length() > 5);

        // 打印结果
        if (anyMatch) {
            System.out.println("存在长度大于5的元素");
        } else {
            System.out.println("不存在长度大于5的元素");
        }
    }
}

在上面的示例中，我们首先创建了一个包含字符串的流，使用Stream.of()方法创建一个包含"apple"、“banana”、“orange”、"grape"的流。然后，我们使用anyMatch()方法检查流中是否存在长度大于5的元素，通过Lambda表达式s -> s.length() > 5来定义判断条件。

最后，我们根据anyMatch()方法的返回结果打印出相应的结果。

使用anyMatch()方法可以方便地检查流中是否存在满足给定条件的元素，无需遍历整个流。这对于需要判断某个条件是否成立的场景非常有用。

2.5. allMatch(Predicate predicate)：

检查流中的所有元素是否都满足给定条件。

import java.util.stream.Stream;

public class StreamAllMatchDemo {
    public static void main(String[] args) {
        // 创建一个包含整数的流
        Stream<Integer> numberStream = Stream.of(1, 2, 3, 4, 5);

        // 检查流中是否所有元素都大于0
        boolean allMatch = numberStream.allMatch(n -> n > 0);

        // 打印结果
        if (allMatch) {
            System.out.println("所有元素都大于0");
        } else {
            System.out.println("不是所有元素都大于0");
        }
    }
}

在上面的示例中，我们首先创建了一个包含整数的流，使用Stream.of()方法创建一个包含1、2、3、4、5的流。然后，我们使用allMatch()方法检查流中是否所有元素都大于0，通过Lambda表达式n -> n > 0来定义判断条件。

最后，我们根据allMatch()方法的返回结果打印出相应的结果。

使用allMatch()方法可以方便地检查流中的所有元素是否都满足给定条件，如果流中的元素个数很大，一旦发现有某个元素不满足条件，就会立即返回false，无需遍历整个流。这对于需要判断所有元素是否满足某个条件的场景非常有用。

2.6. noneMatch(Predicate predicate)：

检查流中的所有元素是否都不满足给定条件。

import java.util.stream.Stream;

public class StreamNoneMatchDemo {
    public static void main(String[] args) {
        // 创建一个包含整数的流
        Stream<Integer> numberStream = Stream.of(1, 2, 3, 4, 5);

        // 检查流中是否所有元素都不等于0
        boolean noneMatch = numberStream.noneMatch(n -> n == 0);

        // 打印结果
        if (noneMatch) {
            System.out.println("所有元素都不等于0");
        } else {
            System.out.println("有元素等于0");
        }
    }
}

在上面的示例中，我们首先创建了一个包含整数的流，使用Stream.of()方法创建一个包含1、2、3、4、5的流。然后，我们使用noneMatch()方法检查流中是否所有元素都不等于0，通过Lambda表达式n -> n == 0来定义判断条件。

最后，我们根据noneMatch()方法的返回结果打印出相应的结果。

使用noneMatch()方法可以方便地检查流中的所有元素是否都不满足给定条件，如果流中的元素个数很大，一旦发现有某个元素满足条件，就会立即返回false，无需遍历整个流。这对于需要判断所有元素是否都不满足某个条件的场景非常有用。

2.7. reduce(BinaryOperator accumulator)：

将流中的元素进行归约操作，返回一个Optional对象。

import java.util.Optional;
import java.util.stream.Stream;

public class StreamReduceDemo {
    public static void main(String[] args) {
        // 创建一个包含整数的流
        Stream<Integer> numberStream = Stream.of(1, 2, 3, 4, 5);

        // 对流中的元素进行求和
        Optional<Integer> sum = numberStream.reduce((a, b) -> a + b);

        // 打印结果
        sum.ifPresent(result -> System.out.println("求和结果为: " + result));
    }
}

在上面的示例中，我们首先创建了一个包含整数的流，使用Stream.of()方法创建一个包含1、2、3、4、5的流。然后，我们使用reduce()方法将流中的元素进行求和操作，通过Lambda表达式(a, b) -> a + b来定义求和的规则。

reduce()方法返回一个Optional对象，表示归约操作的结果。我们可以使用ifPresent()方法检查Optional对象是否有值，如果有值则打印出结果。

使用reduce()方法可以对流中的元素进行各种归约操作，如求和、求最大值、求最小值等。根据传入的归约规则，可以对元素进行累积操作，得到一个最终的结果。

2.8. min(Comparator comparator)：

返回流中的最小元素。

import java.util.Comparator;
import java.util.Optional;
import java.util.stream.Stream;

public class StreamMinDemo {
    public static void main(String[] args) {
        // 创建一个包含字符串的流
        Stream<String> stringStream = Stream.of("apple", "banana", "orange", "grape");

        // 找到字典序最小的字符串
        Optional<String> minString = stringStream.min(Comparator.naturalOrder());

        // 打印结果
        minString.ifPresent(result -> System.out.println("最小的字符串为: " + result));
    }
}

在上面的示例中，我们首先创建了一个包含字符串的流，使用Stream.of()方法创建一个包含"apple"、“banana”、“orange”、"grape"的流。然后，我们使用min()方法找到字典序最小的字符串，通过Comparator.naturalOrder()方法指定字符串的比较规则。

min()方法返回一个Optional对象，表示流中的最小元素。我们可以使用ifPresent()方法检查Optional对象是否有值，如果有值则打印出结果。

使用min()方法可以根据指定的比较器找到流中的最小元素。根据比较规则，可以比较不同类型的元素，如整数、字符串等。

2.9. max(Comparator comparator)：

返回流中的最大元素。

import java.util.Comparator;
import java.util.Optional;
import java.util.stream.Stream;

public class StreamMaxDemo {
    public static void main(String[] args) {
        // 创建一个包含整数的流
        Stream<Integer> integerStream = Stream.of(5, 2, 8, 1, 10);

        // 找到最大的整数
        Optional<Integer> maxInteger = integerStream.max(Comparator.naturalOrder());

        // 打印结果
        maxInteger.ifPresent(result -> System.out.println("最大的整数为: " + result));
    }
}

在上面的示例中，我们首先创建了一个包含整数的流，使用Stream.of()方法创建一个包含5、2、8、1、10的流。然后，我们使用max()方法找到最大的整数，通过Comparator.naturalOrder()方法指定整数的比较规则。

max()方法返回一个Optional对象，表示流中的最大元素。我们可以使用ifPresent()方法检查Optional对象是否有值，如果有值则打印出结果。

使用max()方法可以根据指定的比较器找到流中的最大元素。根据比较规则，可以比较不同类型的元素，如整数、字符串等。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/743918.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Effective Java 高效编码阅读 笔记

Effective Java 高效编码阅读 笔记

《Effective Java》 有关于 Java 变成编程性能优化的 的书籍&#xff0c;看了不计其数 &#xff0c;但是每当读起来能让我眼前一亮的还得是 Effective Java 像这一类的书籍还有很多例如下面的 的两本&#xff0c;今天呢&#xff0c;来记录下此书的阅读笔记方便日后记忆&#xf…
阅读更多...
【面试题34】什么是MVC，为什么要使用它

【面试题34】什么是MVC，为什么要使用它

文章目录 一、前言二、MVC介绍2.1 模型&#xff08;Model&#xff09;2.2 视图&#xff08;View&#xff09;2.3 控制器&#xff08;Controller&#xff09; 三、MVC模式的优点四、总结 一、前言 本文已收录于PHP全栈系列专栏&#xff1a;PHP面试专区。 计划将全覆盖PHP开发领域…
阅读更多...
深入了解Spring Cloud的服务注册与发现组件Eureka

深入了解Spring Cloud的服务注册与发现组件Eureka

摘要&#xff1a;Spring Cloud是一个基于Spring框架的开发工具包&#xff0c;可以帮助开发人员构建基于微服务架构的分布式系统。其中的核心组件之一是Eureka&#xff0c;它提供了一套强大的服务注册与发现功能。本文将深入介绍Spring Cloud中的Eureka组件&#xff0c;包括其背…
阅读更多...
MIT 6.S081 -- Networking

MIT 6.S081 -- Networking

MIT 6.S081 -- Networking 引言计算机网络概述二层网络 --- Ethernet二/三层地址转换 --- ARP三层网络 --- Internet四层网络 --- UDP网络协议栈&#xff08;Network Stack&#xff09;Ring BufferReceive Livelock如何解决Livelock 引言 本文整理至: MIT 6.S081 2020 操作系统…
阅读更多...
回归预测 | MATLAB实现WOA-CNN-BiLSTM鲸鱼算法优化卷积双向长短期记忆神经网络多输入单输出回归预测

回归预测 | MATLAB实现WOA-CNN-BiLSTM鲸鱼算法优化卷积双向长短期记忆神经网络多输入单输出回归预测

回归预测 | MATLAB实现WOA-CNN-BiLSTM鲸鱼算法优化卷积双向长短期记忆神经网络多输入单输出回归预测 目录 回归预测 | MATLAB实现WOA-CNN-BiLSTM鲸鱼算法优化卷积双向长短期记忆神经网络多输入单输出回归预测预测效果基本介绍模型描述程序设计学习总结参考资料 预测效果 基本介…
阅读更多...
nginx高并发架构

nginx高并发架构

1.前言 对于高并发的流量web架构&#xff0c;单纯的使用nginx是不够用的&#xff0c;nginx做七层代理需要处理数据&#xff0c;在大并发的情况下对主机资源的消耗就非常厉害了&#xff0c;所以此情况下就引入了lvs&#xff0c;使用lvs的四层转发功能&#xff0c;四层转发不需要…
阅读更多...
【MySQL】如何优化SQL查询的总体框架（详细版，关于如何优化数据库服务器从大到小详细说明了步骤）

【MySQL】如何优化SQL查询的总体框架（详细版，关于如何优化数据库服务器从大到小详细说明了步骤）

文章目录 1 数据库服务器的优化步骤2 观察2.1 观察系统总体运行情况2.2 定位执行慢的 SQL&#xff1a;慢查询日志2.3 查看 SQL 执行成本&#xff1a;SHOW PROFILE2.4 分析查询语句&#xff1a;EXPLAIN&#xff08;重点掌握&#xff09;2.4.1 EXPLAIN各列作用2.4.2 EXPLAIN 的 t…
阅读更多...
银行安全用电监管平台可行性研究及解决方案

银行安全用电监管平台可行性研究及解决方案

2017年4月26日&#xff0c;国务院安全生产委员会印发《国务院安全生产委员会关于开展电气火灾综合治理工作的通知》&#xff08;安委〔2017〕4号&#xff09;&#xff0c;强调用三年时间综合治理电气火灾工作&#xff0c;提高社会单位发现和处置消防电气安全隐患能力&#xff0…
阅读更多...
2023国自然会评：上会及分数解析，这几种情况本子容易被拿下？

2023国自然会评：上会及分数解析，这几种情况本子容易被拿下？

国自然基金上会标准 今年的会评已经临近“重头戏”---面青地项目会议评审。 在国自然会评中&#xff0c;通过函评筛选出的科研工作者&#xff0c;经过会评筛选和评审&#xff0c;最终被评选出的项目将获得国自然会的资金支持。 国自然的会评&#xff0c;分为几个部分&#x…
阅读更多...
美国访问学者怎么考驾照？

美国访问学者怎么考驾照？

作为一个美国访问学者&#xff0c;你可能会想知道在美国如何考取驾照。在这篇文章中&#xff0c;知识人网小编将介绍美国的驾照考试流程和一些相关要求。 首先&#xff0c;作为一名访问学者&#xff0c;你需要了解美国各州对驾照的规定可能会有所不同。因此&#xff0c;在考取驾…
阅读更多...
单片机尽力少用位域操作

单片机尽力少用位域操作

1、在51单片机中少用uint32_t类型&#xff0c;查看汇编真的好多条指令&#xff0c;尽力避免少用。 2、在32位单片机中&#xff0c;u8、u16、u32类型操作起来基本没有什么影响&#xff0c;下图是我做的测试&#xff0c;可能测试不全面&#xff0c;按照当前测试&#xff0c;在32…
阅读更多...
CVE-2023-28432-MinIO集群模式信息泄露漏洞流量分析

CVE-2023-28432-MinIO集群模式信息泄露漏洞流量分析

简介 MinIO是一个开源对象存储系统。 在其RELEASE.2023-03-20T20-16-18Z版本&#xff08;不含&#xff09;以前&#xff0c;集群模式部署下存在一处信息泄露漏洞&#xff0c;攻击者可以通过发送一个POST数据包获取进程所有的环境变量&#xff0c;其中就包含账号密码MINIO_SEC…
阅读更多...
ElasticSearch8.7 搭配 SpringDataElasticSearch5.1 的使用

ElasticSearch8.7 搭配 SpringDataElasticSearch5.1 的使用

0. 前言 终于&#xff01;终于&#xff01;自个翻遍了网上的文章&#xff0c;加上对官网的文档和API的翻找&#xff0c;终于明白这玩意到底更新出了个啥出来&#xff01; 本文章会带你了解&#xff0c;使用 SpringDataES5.1 对 ES8.7 的【新增、修改、删除、多条件查询、聚合】…
阅读更多...
MFC 工具栏中的按钮控件下拉式

MFC 工具栏中的按钮控件下拉式

有一个需求 工具栏中的按钮需要有一个下拉按钮&#xff0c;点击下拉按钮可以弹出一个子窗口来选择 显示该 TBSTYLE_EX_DRAWDDARROWS 扩展的样式设置&#xff0c;将箭头下方将显示。 DWORD dwExStyle TBSTYLE_EX_DRAWDDARROWS; m_toolbar.GetToolBarCtrl().SendMessage(TB_SE…
阅读更多...
「深度学习之优化算法」（十一）鲸鱼算法

「深度学习之优化算法」（十一）鲸鱼算法

1. 鲸鱼算法简介 （以下描述，均不是学术用语，仅供大家快乐的阅读） 　　鲸鱼算法（Whale Optimization Algorithm）是根据鲸鱼围捕猎物的行为而提出的算法。鲸鱼是一种群居的哺乳动物，在捕猎时它们也会相互合作对猎物进行驱赶和围捕。鲸鱼算法提出时间并不长，也是一个新兴…
阅读更多...
利用Gradio的UploadButton模块实现文件上传功能

利用Gradio的UploadButton模块实现文件上传功能

❤️觉得内容不错的话&#xff0c;欢迎点赞收藏加关注&#x1f60a;&#x1f60a;&#x1f60a;&#xff0c;后续会继续输入更多优质内容❤️ &#x1f449;有问题欢迎大家加关注私戳或者评论&#xff08;包括但不限于NLP算法相关&#xff0c;linux学习相关&#xff0c;读研读博…
阅读更多...
requestAnimationFrame性能测试

requestAnimationFrame性能测试

requestAnimationFrame&#xff1a;每次重绘最多只调用一次回调函数 测试开启/关闭requestAnimationFrame的监听事件调用次数差异&#xff1a; 先说结论&#xff1a;存在约8倍的调用次数差距&#xff01; requestAnimationFrame使用与否的次数差距 本次测试代码为drag事件 c…
阅读更多...
Pycharm设置Python文件页眉默认信息（作者姓名、创建时间等）

Pycharm设置Python文件页眉默认信息（作者姓名、创建时间等）

次点击File->Settings->Editor->File and Code Templates->然后选择Python script. 后将下列代码复制到右边的框框中&#xff0c;然后选择apply应用&#xff0c;就可以啦 ##!/usr/bin/python3 # -*- coding: utf-8 -*- # Time : ${DATE} ${TIME} # Author : 作者…
阅读更多...
【CSS加载动画特效】28种纯CSS实现的加载loading动态特效（附源码）

【CSS加载动画特效】28种纯CSS实现的加载loading动态特效（附源码）

文章目录 写在前面涉及知识点效果展示1、Loading节点的创建2、部分效果的实现源码1&#xff09;三点加载动画Html代码CSS样式代码 2&#xff09;圆点矩阵加载特效Html代码CSS样式代码 3&#xff09;圆形轨迹加载动画Html代码Css样式代码 4&#xff09;栅栏式加载动画Html代码Cs…
阅读更多...
Qt/C++音视频开发46-音视频同步保存到MP4

Qt/C++音视频开发46-音视频同步保存到MP4

一、前言 用ffmpeg单独做视频保存不难&#xff0c;单独做音频保存也不难&#xff0c;难的是音视频同步保存到MP4中&#xff0c;重点是音视频要同步&#xff0c;其实这也不难&#xff0c;只要播放那边音视频同步后的数据&#xff0c;写入到文件即可。最难的是在播放过程中不断随…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023