Stream API 方法使用总结

news2025/1/19 17:01:16

文章目录

    • 1.1、Stream介绍
    • 1.2、Stream创建对象
      • （1）empty()方法
      • （2）of()方法
      • （3）Arrays.stream()方法
      • （4）list.stream()方法
    • 1.3、Stream中间方法
      • （1）filter()方法
      • （2）map()方法
      • （3）flatMap()方法
      • （4）limit()方法
      • （5）skip()方法
      • （6）sorted()方法
      • （7）distinct()方法
      • （8）peek()方法
    • 1.4、Stream终端方法
      • （1）min()方法
      • （2）max()方法
      • （3）count()方法
      • （4）reduce()方法
      • （5）anyMatch()方法
      • （6）allMatch()方法
      • （7）noneMatch()方法
      • （8）findFirst()方法
      • （9）findAny()方法
      • （10）forEach()方法
      • （11）collect()方法

1.1、Stream介绍

Stream是JDK1.8新增的一个特性，它是一个位于【java.util.stream】包下面的接口，接口中定义了用于操作数据的公共方法，Stream被称作：【流】，它的意图就是可以按照流的方式对数据进行一些加工处理，实际开发里面最常见的就是操作集合数据，通过Stream API可以编写很少的代码就完成某一个功能，相比于传统的集合处理方式，Stream API显示更加的优雅、高效。

Java中可以将Stream API方法大致分为两类，分别是：【中间方法】和【终端方法】。

  • 中间方法：在Stream流被消费之前，对Stream流中的数据进行一些加工处理，然后返回加工处理之后的新的Stream流。
  • 终端方法：Stream流经过中间方法的加工处理之后，最终是需要被消费的，调用终端方法之后，这个Stream流就结束了，之后就不能够在使用这个Stream流对象。

Stream流处理大致流程图：

在这里插入图片描述

下面详细介绍一下Stream API的常见方法。

1.2、Stream创建对象

Java中主要有下面四种方法创建一个Stream对象，分别如下所示：

  • 第一种：使用Stream提供的empty()方法。
  • 第二种：使用Stream提供的of()方法。
  • 第三种：使用Arrays.stream()数组工具类提供的方法。
  • 第四种：使用集合对象的stream()方法（这种方式在实际开发里面最常用）。

（1）empty()方法

Stream接口中提供了一个empty()方法，该方法用于创建一个空的Stream对象，基本上不会用这个方法吧，反正我是没用过-。

public class StreamDemo {
    public static void main(String[] args) {
        // 创建空的 Stream 对象
        Stream<Object> empty = Stream.empty();
    }
}

（2）of()方法

Stream接口中提供了两个of()方法，of()方法可以将传入的数据转换为一个Stream对象返回。

public class StreamDemo {
    public static void main(String[] args) {
        // 创建 Stream 对象
        Stream<String> stream = Stream.of("123");
        // 可变参数
        Stream<Integer> stream1 = Stream.of(1, 2, 3, 4);
    }
}

（3）Arrays.stream()方法

Arrays数组工具类中提供了一个stream()方法，该方法可以将数组转换为Stream流对象。

public class StreamDemo {
    public static void main(String[] args) {
        // 创建 Stream 对象
        int[] arr = new int[] {1, 2, 3, 4, 5};
        IntStream stream = Arrays.stream(arr);
    }
}

（4）list.stream()方法

Java集合类中提供了一个stream()方法，作用也是将Collection集合数据转换为Stream流对象。

public class StreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("111");
        list.add("222");
        list.add("333");
        // 创建 Stream 对象
        Stream<String> stream = list.stream();
    }
}

注意：只要是Collection集合类，它都具有stream()方法。并且这个也是最常用的方法，因为实际开发里面，集合是最常见的操作对象。

1.3、Stream中间方法

Stream中间方法是对Stream流中数据进行一些加工处理的，中间方法的返回值都是一个新的Stream流对象，这个Stream流对象就是加工处理之后的新对象。

（1）filter()方法

filter()方法用于过滤Stream流中的数据，该方法需要传递一个【Predicate】对象（一个函数式接口），可以采用lambada表达式编写过滤条件。

public class StreamDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("111");
        list.add("222");
        list.add("333");
        // 创建 Stream 对象
        Stream<String> stream = list.stream();
        // 过滤方法: 过滤出集合中不等于 222 的数据
        Stream<String> stream1 = stream.filter(item -> !item.equals("222"));
    }
}

（2）map()方法

map()方法主要作用就是将一个Stream流映射成一个新的Stream流，map方法使用最为频繁，比如：从集合中提取某个对象的某个属性，将其组成新的一个集合，下面看下两种实现方式。

  • 没有使用Stream.map()方法的代码。
public static void main(String[] args) {
    List<User> userList = getUserList();
    // 从集合中提取 姓名
    List<String> nameList = new ArrayList<>();
    for (int i = 0; i < userList.size(); i++) {
        nameList.add(userList.get(i).getName());
    }
}
  • 采用Stream.map()方法的代码。
public static void main(String[] args) {
    List<User> userList = getUserList();
    // 从集合中提取 姓名
    List<String> nameList = userList.stream().map(item -> item.getName()).collect(Collectors.toList());
}

对比上面两种方式，可以看到，采用Stream API编写的代码是多么的优雅，并且代码也简化了很多。

（3）flatMap()方法

flatMap()方法和map()方法的作用是类似的，都是用于映射Stream流的，只不过flatMap()方法可以将多个不同的Stream流映射为一个Stream流对象，flat表示【扁平化】的意思，就好比将多行数据合并成一行数据，这个就是扁平化。

public class StreamDemo {
    public static List<List<User>> getUserList() {
        List<List<User>> ans = new ArrayList<>();
        List<User> list = new ArrayList<>();
        list.add(new User(333, "name_003", "pass_003"));
        list.add(new User(111, "name_001", "pass_001"));
        list.add(new User(444, "name_004", "pass_004"));
        ans.add(list);
        List<User> list2 = new ArrayList<>();
        list2.add(new User(222, "name_002", "pass_002"));
        ans.add(list2);
        return ans;
    }
    public static void main(String[] args) {
        List<List<User>> userList = getUserList();
        System.out.println(userList);
        // 将集合中的集合，转换为一个集合
        List<User> ansList = userList.stream().flatMap(item -> item.stream()).collect(Collectors.toList());
        System.out.println(ansList);
    }
}

上面案例中，由于集合里面的元素又是集合，为了将整个集合变成一个集合，通过Stream中的flatMap()方法，将多个Stream流映射成一个Stream对象。

（4）limit()方法

limit()方法作用是限定数据的条数，比如：集合中有100条数据，通过limit()方法可以只获取10条数据。

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("111");
    list.add("222");
    list.add("333");
    list.add("444");
    list.add("555");
    // 限定5条数据
    Stream<String> stream = list.stream().limit(5);
}

（5）skip()方法

skip()方法作用是：跳过多少条数据，然后在开始处理数据。比如：现在有100条数据，前10条数据是不需要的，从第11条数据开始进行处理，这个时候就可以通过skip()方法跳过前10条数据进行处理。

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("111");
    list.add("222");
    list.add("333");
    list.add("444");
    list.add("555");
    // 跳过前 2 条数据
    Stream<String> skip = list.stream().skip(2);
    // 打印结果
    skip.forEach(System.out::println);
}

打印结果如下所示：

在这里插入图片描述

（6）sorted()方法

sorted()方法作用是将数据进行排序，sorted()有两个方法，一个是无参的sorted()方法，另一个是有参数的sorted(Comparator)方法。

  • sorted()无参方法，默认按照自然排序规则，升序排序所有数据，即：数值类按照从小到大排序，字符串按照字典序排序。
public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("333");
    list.add("111");
    list.add("444");
    list.add("222");
    list.add("555");
 
    System.out.println("排序前: ");
    list.forEach(item -> System.out.print(item + " "));
    System.out.println();
 
    // 排序
    Stream<String> sorted = list.stream().sorted();
    System.out.println("排序后: ");
    sorted.forEach(item -> System.out.print(item + " "));
}

运行结果如下所示：

在这里插入图片描述

  • sorted()有参方法，自定义排序比较器，自定义排序规则。
public class StreamDemo {
    public static List<User> getUserList() {
        List<User> list = new ArrayList<>();
        list.add(new User(333, "name_003", "pass_003"));
        list.add(new User(111, "name_001", "pass_001"));
        list.add(new User(444, "name_004", "pass_004"));
        list.add(new User(222, "name_002", "pass_002"));
        return list;
    }
    public static void main(String[] args) {
        List<User> userList = getUserList();
        System.out.println("排序前: ");
        userList.forEach(System.out::println);
 
        // 自定义排序
        Stream<User> sorted = userList.stream().sorted(new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o1.getId() - o2.getId();
            }
        });
 
        System.out.println("排序后: ");
        sorted.forEach(System.out::println);
    }
}

运行结果如下所示：

在这里插入图片描述

（7）distinct()方法

distinct()方法作用是将数据中的重复数据去重操作，只保留一条数据。

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("111");
    list.add("222");
    list.add("333");
    list.add("444");
	// 重复数据
    list.add("555");
    list.add("555");
    // 去重
    Stream<String> distinct = list.stream().distinct();
    // 打印结果
    distinct.forEach(System.out::println);
}

打印结果如下所示：

在这里插入图片描述

（8）peek()方法

peek()方法接收一个Consumer消费者对象，消费者可以对流中的数据进行修改操作或者访问操作。

public class StreamDemo {
    public static List<User> getUserList() {
        List<User> list = new ArrayList<>();
        list.add(new User(333, "name_003", "pass_003"));
        list.add(new User(111, "name_001", "pass_001"));
        list.add(new User(444, "name_004", "pass_004"));
        list.add(new User(222, "name_002", "pass_002"));
        return list;
    }
    public static void main(String[] args) {
        List<User> userList = getUserList();
        // peek 修改数据
        Stream<User> peek = userList.stream().peek(item -> item.setName("demo_peek"));
        peek.forEach(System.out::println);
    }
}

注意：Stream中间方法的执行操作并不会立即生效，只有调用终端方法之后，中间方法的执行效果才会生效。

1.4、Stream终端方法

终端方法是将Stream流消费之后，并且最终会得到一个结果，常见的终端方法下面这些。

（1）min()方法

min()方法主要作用：从数据流中计算出最小值元素。min()方法需要提供一个Comparator比较器对象，通过比较器器对象的比较规则，找出最小值元素。

注意：min()方法不是说找出最小的元素，它是根据你指定的比较器规则找出最小元素。

比如下面这个例子，集合元素是【1，2，3，4，5】，但是比较器规则是后一个元素减去前一个元素。

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Optional<Integer> min = list.stream().min(new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    });
    Integer ans = min.get();
    System.out.println(ans);
}

上面输出结果是：【5】。

（2）max()方法

max()方法作用：从数据流中计算出最小值元素。参数和min()方法是相同的。

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    Optional<Integer> max = list.stream().max(new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    });
    Integer ans = max.get();
    System.out.println(ans);
}

上面输出结果是：【1】。

（3）count()方法

count()方法作用：统计Stream流中数据元素个数，返回值是long类型。

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(2, 1, 5, 4, 3);
    // 计算个数
    long count = list.stream().count();
    System.out.println(count);
}

（4）reduce()方法

reduce()方法作用：将stream流中数据进行规约操作，最终得到一个结果。这里的规约就类似于迭代，比如：要计算stream流中所有数据的和，那就可以使用reduce()方法进行规约计算。

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(2, 1, 5, 4, 3);
    // 规约操作
    Optional<Integer> ans = list.stream().reduce((a, b) -> a + b);
    System.out.println(ans.get());
    // 指定初始值:
    // 这里指定第一个参数值是10，也就是reduce的规约操作的初始值是10
    int ans1 = list.stream().reduce(10, (a, b) -> a + b);
    System.out.println(ans1);
 
    // 这里结果等于：1200
    int ans2 = list.stream().reduce(10, (a, b) -> a * b);
    System.out.println(ans2);
}

运行结果如下所示：

在这里插入图片描述

reduce()规约操作分析：

在这里插入图片描述

（5）anyMatch()方法

anyMatch()方法作用：只要stream数据流中 【存在一个满足匹配】 条件的数据，那么方法就会返回true，否则返回false。

（6）allMatch()方法

allMatch()方法作用：只有当stream数据流中的所有数据，【都满足匹配】 条件的数据，那么方法才会返回true，否则返回false。

（7）noneMatch()方法

allMatch()方法作用：只有当stream数据流中的所有数据，【都不满足匹配】 条件的数据，那么方法才会返回true，否则返回false。

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(2, 1, 5, 4, 3);
    // 满足一个: 集合中有一个元素是大于4的
    boolean match = list.stream().anyMatch(item -> item > 4);
    System.out.println(match);
    // 都满足: 集合中所有元素都小于6
    boolean match1 = list.stream().allMatch(item -> item < 6);
    System.out.println(match1);
    // 都不满足: 集合中不存在大于 6 的元素
    boolean match2 = list.stream().noneMatch(item -> item > 6);
    System.out.println(match2);
}

（8）findFirst()方法

findFirst()方法作用：从stream流中获取第一条数据。

public class StreamDemo {
    public static List<User> getUserList() {
        List<User> list = new ArrayList<>();
        list.add(new User(333, "name_003", "pass_003"));
        list.add(new User(111, "name_001", "pass_001"));
        list.add(new User(444, "name_004", "pass_004"));
        list.add(new User(222, "name_002", "pass_002"));
        return list;
    }
    public static void main(String[] args) {
        List<User> userList = getUserList();
        // 获取第一条数据
        Optional<User> first = userList.stream().findFirst();
        if (first.isPresent()) {
            System.out.println(first.get());
        }
    }
}

（9）findAny()方法

findAny()方法作用：从stream数据流中随机返回一条数据。

（10）forEach()方法

forEach()方法作用：遍历stream流中的数据元素。

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("333");
    list.add("111");
    list.add("444");
    list.add("222");
    list.add("555");
    list.stream().forEach(item -> {
        System.out.println(item);
    });
}

（11）collect()方法

collect()方法作用：用于将中间方法处理的stream流收集为一个结果，常见的如：List、Set、Map等等。

public class StreamDemo {
    public static List<User> getUserList() {
        List<User> list = new ArrayList<>();
        list.add(new User(333, "name_003", "pass_003"));
        list.add(new User(111, "name_001", "pass_001"));
        list.add(new User(444, "name_004", "pass_004"));
        list.add(new User(222, "name_002", "pass_002"));
        return list;
    }
    public static void main(String[] args) {
        List<User> userList = getUserList();
        List<String> ansList = userList.stream().map(User::getName).collect(Collectors.toList());
        System.out.println(ansList);
    }
}

这个collect()方法更多的用法上一篇文章Java8新特性有介绍。

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

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

相关文章

100W用户、8000W流量在线贺卡应用架构如何优化？

100W用户、8000W流量在线贺卡应用架构如何优化？

文章目录 &#x1f50a;博主介绍&#x1f964;本文内容&#x1f4e2;文章总结&#x1f4e5;博主目标 &#x1f50a;博主介绍 &#x1f31f;我是廖志伟&#xff0c;一名Java开发工程师、Java领域优质创作者、CSDN博客专家、51CTO专家博主、阿里云专家博主、清华大学出版社签约作…
阅读更多...
Trie字符串统计（字典树的插入与查找）

Trie字符串统计（字典树的插入与查找）

题目&#xff1a; 插入模拟&#xff1a;假如现在要依次插入cat,car,busy,cate,bus,car 查找&#xff1a; 代码&#xff1a; import java.util.Scanner;public class Main {public static int[][] chnew int[100010][26];public static int[] cntnew int[100010];public static…
阅读更多...
维基百科文章爬虫和聚类：高级聚类和可视化

维基百科文章爬虫和聚类：高级聚类和可视化

一、说明 维基百科是丰富的信息和知识来源。它可以方便地构建为带有类别和其他文章链接的文章&#xff0c;还形成了相关文档的网络。我的 NLP 项目下载、处理和应用维基百科文章上的机器学习算法。 在我的上一篇文章中&#xff0c;KMeans 聚类应用于一组大约 300 篇维基百科文…
阅读更多...
scikit-learn线性回归法进行利润预测

scikit-learn线性回归法进行利润预测

大家好&#xff0c;生成式人工智能无疑是一个改变游戏规则的技术&#xff0c;但对于大多数商业问题来说&#xff0c;回归和分类等传统的机器学习模型仍然是首选。 私募股权或风险投资这样的投资者利用机器学习&#xff0c;首先必须了解关注的数据以及它是如何被使用的。投资公…
阅读更多...
力扣226：翻转二叉树

力扣226：翻转二叉树

力扣226&#xff1a;翻转二叉树 给你一棵二叉树的根节点 root &#xff0c;翻转这棵二叉树&#xff0c;并返回其根节点。 示例 1&#xff1a; 输入&#xff1a;root [4,2,7,1,3,6,9] 输出&#xff1a;[4,7,2,9,6,3,1] 示例 2&#xff1a; 输入&#xff1a;root [2,1,3]…
阅读更多...
matlab科学计算

matlab科学计算

欢迎关注博主 Mindtechnist 或加入【智能科技社区】一起学习和分享Linux、C、C、Python、Matlab&#xff0c;机器人运动控制、多机器人协作&#xff0c;智能优化算法&#xff0c;滤波估计、多传感器信息融合&#xff0c;机器学习&#xff0c;人工智能等相关领域的知识和技术。关…
阅读更多...
yolo.txt格式与voc格式互转,超详细易上手

yolo.txt格式与voc格式互转,超详细易上手

众所周知，yolo训练所需的标签文件类型是.txt的，但我们平时使用标注软件（labelimage等）标注得到的标签文件是.xml类型的，故此xml2txt之间的转换就至关重要了，这点大家不可能想不到，但是网上的文章提供的代码大多数都是冗余，或者难看，难以上手，故此作者打算提供一个相对…
阅读更多...
构建第一个ArkTS应用（纯HarmonyOS应用）

构建第一个ArkTS应用（纯HarmonyOS应用）

1. 安装开发工具 在华为开发者官方上下载HarmonyOS应用专用的开发工具&#xff0c;链接地址&#xff1a;HUAWEI DevEco Studio和SDK下载和升级 | HarmonyOS开发者 要想使用开发工具让项目跑起来&#xff0c;需要10G的磁盘空间。开发工具需要的磁盘空间为2.36G&#xff1b;SDK需…
阅读更多...
【开源存储】minio对象存储部署实践

【开源存储】minio对象存储部署实践

文章目录 一、前言1、介绍说明2、部署方式3、冗余模式4、约束限制4.1、规格参数4.2、API支持a、minio不支持的Amazon S3 Bucket APIb、minio不支持的Amazon S3 Object API 二、部署说明1、软件安装2、minio单机部署3、minio分布式部署3.1、前置条件3.2、开始运行3.3、操作说明 …
阅读更多...
[PyTorch][chapter 2][李宏毅深度学习-Regression]

[PyTorch][chapter 2][李宏毅深度学习-Regression]

前言&#xff1a; Regression 模型主要用于股票预测,自动驾驶,推荐系统等领域. 这个模型的输出是一个scalar。这里主要以下一个线性模型为基础 它是神经网络的基础模块&#xff0c; 目录&#xff1a; 总体流程 常见问题 Numpy 例子 PyTorch 例子 一 总体流程 1 : 建…
阅读更多...
前端页面转pdf

前端页面转pdf

首先&#xff0c;需要安装两个库 html2canvasjspdf 先引入这个公用的html转pdf的方法 /**path:src/utils/htmlToPdf.jsname:导出页面为pdf格式 **/ import html2Canvas from "html2canvas1.4.1"; import JsPDF from "jspdf2.5.1";const htmlToPdf {get…
阅读更多...
[linux进程控制]进程替换

[linux进程控制]进程替换

文章目录 1.进程替换的概念和原理2.如何完成进程替换2.1exec系列函数加载器的底层系统调用接口基于execve的封装--库函数 2.2 int execl(const char *path, const char *arg, ...);1.在当前进程进行替换2.在子进程进行替换 2.3 int execv(const char *path, char *const argv[]…
阅读更多...
业务数据治理体系化实施流程学习总结

业务数据治理体系化实施流程学习总结

目录 一、业务数据治理实施流程 步骤 1&#xff1a;发现问题和制定目标 步骤 2&#xff1a;针对问题进行拆解&#xff0c;设计可衡量的指标 步骤 3&#xff1a;制定解决SOP和检查研发标准规范 步骤 4&#xff1a;推广运营&#xff0c;以拿结果为核心目标 步骤 5&#xff…
阅读更多...
SmartSoftHelp8,代码版权保护

SmartSoftHelp8,代码版权保护

1.Html网页前端添加作者开发信息 2. Html网页添加版权信息 3. Css添加作者开发信息 4. JavaScript添加作者开发信息 5. C井后端代码添加作者开发信息 6. Dll内裤添加作者开发信息 7.应用程序添加开发作者信息&#xff0c;著作权&#xff0c;应用版权信息 下载地址&#…
阅读更多...
使用Java语言实现字母之间的大小写转换

使用Java语言实现字母之间的大小写转换

这个类的作用为实现字母之间的大小写转换&#xff0c;通过加减32来完成。 输入的代码 import java.util.Scanner; public class WordChangeDemo {public static void main(String[] args){try (Scanner in new Scanner(System.in)) {System.out.println("请输入您要进…
阅读更多...
tomcat运行项目时，前端页面中文乱码

tomcat运行项目时，前端页面中文乱码

如图&#xff1a; 解决办法&#xff1a; 在前端页面添加下面代码 <%page language"java" pageEncoding"utf-8"%>再次运行
阅读更多...
C++ Easyx 三子棋

C++ Easyx 三子棋

目录 思路 框架​编辑 读取操作 数据操作 绘制画面 游戏的数据结构 用二维数组来模拟棋盘格 赢的情况 平局情况 Code 代码细节部分 &#xff08;1&#xff09;初始化棋盘格 &#xff08;2&#xff09; 初始化棋子类型​编辑 事件处理部分 落子 框架内代码的完善 数据处…
阅读更多...
如何调用 API | 学习笔记

如何调用 API | 学习笔记

开发者学堂课程【阿里云 API 网关使用教程:如何调用 API】学习笔记&#xff0c;与课程紧密联系&#xff0c;让用户快速学习知识。 课程地址&#xff1a;阿里云登录 - 欢迎登录阿里云&#xff0c;安全稳定的云计算服务平台 如何调用 API 调用 API 的三要素 要调用 API 需要三…
阅读更多...
Nginx 具体应用

Nginx 具体应用

1 Nginx 1.1 介绍 一款轻量级的 Web 服务器/反向代理服务器及电子邮件&#xff08;IMAP/POP3&#xff09;代理服务器。它占有的内存少&#xff0c;并发能力强&#xff0c;中国大陆使用 nginx 的网站有&#xff1a;百度、京东、新浪、网易、腾讯、淘宝等。第一个公开版本发布于…
阅读更多...
1.1卷积的作用

1.1卷积的作用

上图解释了1∗1卷积如何适用于尺寸为H∗W∗D的输入层&#xff0c;滤波器大小为1∗1∗D&#xff0c;输出通道的尺寸为H∗W∗1。如果应用n个这样的滤波器&#xff0c;然后组合在一起&#xff0c;得到的输出层大小为H∗W∗n。 1.1∗1卷积的作用 调节通道数 由于 11 卷积并不会改…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023