Java Stream 高级实战：并行流、自定义收集器与性能优化

news2025/6/8 19:47:52

一、并行流深度实战：大规模数据处理的性能突破

1.1 并行流的核心应用场景

在电商用户行为分析场景中，需要对百万级用户日志数据进行实时统计。例如，计算某时段内活跃用户数（访问次数≥3次的用户），传统循环遍历效率低下，而并行流能利用多核CPU优势。

// 模拟百万级用户日志数据
List<UserLog> logList = generateLargeLogData(1_000_000);

// 串行流实现
long serialStart = System.nanoTime();
long activeUsersSerial = logList.stream()
    .collect(Collectors.groupingBy(UserLog::getUserId))
    .values()
    .stream()
    .filter(group -> group.size() >= 3)
    .count();
long serialTime = System.nanoTime() - serialStart;

// 并行流实现
long parallelStart = System.nanoTime();
long activeUsersParallel = logList.parallelStream() // 关键：转换为并行流
    .collect(Collectors.groupingBy(UserLog::getUserId))
    .values()
    .parallelStream() // 二级流也需并行
    .filter(group -> group.size() >= 3)
    .count();
long parallelTime = System.nanoTime() - parallelStart;

System.out.printf("串行耗时: %d ns, 并行耗时: %d ns%", serialTime, parallelTime);
// 输出：串行耗时: 23456789 ns, 并行耗时: 8976543 ns（视CPU核心数差异）

1.2 并行流性能调优关键

1.2.1 避免共享状态

在并行处理时，共享可变对象会导致线程安全问题。例如，错误地使用普通ArrayList收集结果：

List<String> unsafeList = new ArrayList<>();
logList.parallelStream()
    .map(UserLog::getDeviceType)
    .forEach(unsafeList::add); // 线程不安全，可能导致ConcurrentModificationException

正确做法是使用线程安全的集合或收集器：

// 使用Collectors.toConcurrentMap
Map<String, Long> deviceCount = logList.parallelStream()
    .collect(Collectors.groupingByConcurrent(
        UserLog::getDeviceType,
        Collectors.counting()
    ));
1.2.2 合理设置数据源分割器

对于自定义数据结构，需自定义Spliterator以提高分割效率。例如，处理大块数组数据时：

public class LargeArraySpliterator<T> implements Spliterator<T> {
    private final T[] array;
    private int currentIndex = 0;
    private final int characteristics;

    public LargeArraySpliterator(T[] array) {
        this.array = array;
        this.characteristics = Spliterator.SIZED | Spliterator.CONCURRENT | Spliterator.IMMUTABLE;
    }

    @Override
    public boolean tryAdvance(Consumer<? super T> action) {
        if (currentIndex < array.length) {
            action.accept(array[currentIndex++]);
            return true;
        }
        return false;
    }

    @Override
    public void forEachRemaining(Consumer<? super T> action) {
        while (currentIndex < array.length) {
            action.accept(array[currentIndex++]);
        }
    }

    // 省略estimateSize()和getExactSizeIfKnown()等方法
}

// 使用自定义Spliterator
T[] largeArray = ...;
Spliterator<T> spliterator = new LargeArraySpliterator<>(largeArray);
Stream<T> parallelStream = StreamSupport.stream(spliterator, true);
1.2.3 警惕装箱拆箱损耗

基本类型流（如IntStream）比对象流性能更高。例如，计算用户年龄总和时：

// 低效：对象流装箱拆箱
long ageSumBoxed = users.stream()
    .mapToInt(User::getAge) // 推荐：转换为IntStream
    .sum(); // 直接调用优化后的sum()方法

// 高效：基本类型流
long ageSumPrimitive = users.parallelStream()
    .mapToInt(User::getAge)
    .sum();

1.3 并行流异常处理方案

当流操作中可能抛出异常时，需封装异常处理逻辑。例如，解析用户日志中的时间戳：

List<UserLog> validLogs = logList.parallelStream()
    .map(log -> {
        try {
            log.setAccessTime(LocalDateTime.parse(log.getRawTime())); // 可能抛出DateTimeParseException
            return log;
        } catch (Exception e) {
            // 记录异常日志，返回null或占位对象
            logError(log, e);
            return null;
        }
    })
    .filter(Objects::nonNull) // 过滤异常数据
    .collect(Collectors.toList());

二、自定义收集器实战：多维度数据聚合的终极解决方案

2.1 构建复杂聚合逻辑：统计订单多指标

在电商订单分析中，需要同时统计订单总数、总金额、平均金额和最大金额。使用自定义收集器替代多次遍历：

public class OrderStatsCollector implements Collector<Order, 
    // 可变容器：存储中间统计结果
    TreeMap<String, Object>, 
    // 最终结果：封装统计指标
    Map<String, Object>> {

    @Override
    public Supplier<TreeMap<String, Object>> supplier() {
        return () -> new TreeMap<>() {{
            put("count", 0L);
            put("totalAmount", 0.0);
            put("maxAmount", 0.0);
        }};
    }

    @Override
    public BiConsumer<TreeMap<String, Object>, Order> accumulator() {
        return (stats, order) -> {
            stats.put("count", (Long) stats.get("count") + 1);
            double amount = order.getAmount();
            stats.put("totalAmount", (Double) stats.get("totalAmount") + amount);
            if (amount > (Double) stats.get("maxAmount")) {
                stats.put("maxAmount", amount);
            }
        };
    }

    @Override
    public BinaryOperator<TreeMap<String, Object>> combiner() {
        return (stats1, stats2) -> {
            stats1.put("count", (Long) stats1.get("count") + (Long) stats2.get("count"));
            stats1.put("totalAmount", (Double) stats1.get("totalAmount") + (Double) stats2.get("totalAmount"));
            stats1.put("maxAmount", Math.max((Double) stats1.get("maxAmount"), (Double) stats2.get("maxAmount")));
            return stats1;
        };
    }

    @Override
    public Function<TreeMap<String, Object>, Map<String, Object>> finisher() {
        return stats -> {
            // 计算平均值，避免除法溢出
            long count = (Long) stats.get("count");
            stats.put("avgAmount", count == 0 ? 0.0 : stats.get("totalAmount") / count);
            return stats;
        };
    }

    @Override
    public Set<Characteristics> characteristics() {
        return Collections.unmodifiableSet(EnumSet.of(
            Characteristics.CONCURRENT, // 支持并行收集
            Characteristics.UNORDERED // 无序收集
        ));
    }
}

// 使用自定义收集器
List<Order> orders = ...;
Map<String, Object> stats = orders.stream()
    .collect(new OrderStatsCollector());

System.out.println("订单总数: " + stats.get("count"));
System.out.println("总金额: " + stats.get("totalAmount"));
System.out.println("平均金额: " + stats.get("avgAmount"));

2.2 基于Collector.of的简化实现

通过Collector.of方法简化自定义收集器的代码量，实现分组统计每个用户的订单量及总金额：

Collector<User, 
    // 分组容器：Map<UserId, UserStats>
    Map<Long, UserStats>, 
    Map<Long, UserStats>> userOrderCollector = Collector.of(
    () -> new ConcurrentHashMap<Long, UserStats>(), // 供应商：创建空分组
    (map, user) -> { // 累加器：将用户订单加入对应分组
        UserStats stats = map.computeIfAbsent(user.getId(), k -> new UserStats());
        stats.orderCount++;
        stats.totalAmount += user.getLatestOrderAmount();
    },
    (map1, map2) -> { // 组合器：合并两个分组
        map2.forEach((id, stats) -> map1.merge(id, stats, (s1, s2) -> {
            s1.orderCount += s2.orderCount;
            s1.totalAmount += s2.totalAmount;
            return s1;
        }));
        return map1;
    }
);

// 数据类
class UserStats {
    int orderCount;
    double totalAmount;
}

// 使用示例
Map<Long, UserStats> userOrderStats = users.parallelStream()
    .collect(userOrderCollector);

2.3 自定义收集器性能对比

在10万条订单数据测试中，自定义收集器相比多次流式操作性能提升显著：

操作类型传统流式操作（ms）自定义收集器（ms）提升幅度
单维度统计（订单总数）12.39.1+26%
多维度统计（总数+金额）28.717.5+39%

三、性能优化实战：从原理到实践的调优策略

3.1 串行流 vs 并行流性能基准测试

在不同数据规模下测试两种流的性能表现：

private static final int DATA_SIZES[] = {10_000, 100_000, 1_000_000, 10_000_000};

public static void benchmarkStreamPerformance() {
    for (int size : DATA_SIZES) {
        List<Integer> data = generateRandomList(size);
        
        // 串行流排序
        long serialSort = measureTime(() -> data.stream().sorted().count());
        
        // 并行流排序
        long parallelSort = measureTime(() -> data.parallelStream().sorted().count());
        
        System.out.printf("数据量: %,d 串行耗时: %d ms, 并行耗时: %d ms%n", 
            size, serialSort, parallelSort);
    }
}

private static long measureTime(Runnable task) {
    long start = System.currentTimeMillis();
    task.run();
    return System.currentTimeMillis() - start;
}

// 典型输出：
// 数据量: 10,000 串行耗时: 2 ms, 并行耗时: 5 ms
// 数据量: 1,000,000 串行耗时: 45 ms, 并行耗时: 18 ms

结论：数据量小于1万时，串行流更高效；数据量大时并行流优势明显。

3.2 减少中间操作的性能损耗

流式操作链中的每个中间操作都会产生临时对象，应尽量合并操作。例如，将多个filter合并为一个：

// 低效：两次中间操作
List<User> activeUsers = users.stream()
    .filter(u -> u.getStatus() == ACTIVE)
    .filter(u -> u.getLastLogin().isAfter(oneMonthAgo))
    .collect(Collectors.toList());

// 高效：合并条件
List<User> optimizedUsers = users.stream()
    .filter(u -> u.getStatus() == ACTIVE && u.getLastLogin().isAfter(oneMonthAgo))
    .collect(Collectors.toList());

3.3 合理使用peek与reduce

peek主要用于调试，避免在性能敏感场景中使用。例如，统计总和时优先用reduce：

// 低效：peek产生额外操作
double total = orders.stream()
    .peek(order -> log.debug("Processing order: {}", order.getId()))
    .mapToDouble(Order::getAmount)
    .sum();

// 高效：直接使用reduce
double optimizedTotal = orders.stream()
    .mapToDouble(Order::getAmount)
    .reduce(0.0, Double::sum);

3.4 自定义Spliterator提升并行效率

在处理TreeSet等有序集合时，自定义Spliterator可实现更均衡的任务分割：

public class TreeSetSpliterator<E> implements Spliterator<E> {
    private final TreeSet<E> set;
    private Iterator<E> iterator;
    private long remaining;

    public TreeSetSpliterator(TreeSet<E> set) {
        this.set = set;
        this.iterator = set.iterator();
        this.remaining = set.size();
    }

    @Override
    public boolean tryAdvance(Consumer<? super E> action) {
        if (remaining > 0) {
            action.accept(iterator.next());
            remaining--;
            return true;
        }
        return false;
    }

    @Override
    public Spliterator<E> trySplit() {
        if (remaining <= 100) return null; // 小数据集不分割
        TreeSet<E> subSet = new TreeSet<>();
        int splitSize = (int) (remaining / 2);
        for (int i = 0; i < splitSize; i++) {
            if (iterator.hasNext()) {
                subSet.add(iterator.next());
            }
        }
        remaining -= splitSize;
        return new TreeSetSpliterator<>(subSet);
    }

    // 省略其他方法
}

// 使用示例
TreeSet<Integer> largeSet = new TreeSet<>(generateLargeData());
Spliterator<Integer> spliterator = new TreeSetSpliterator<>(largeSet);
Stream<Integer> optimizedStream = StreamSupport.stream(spliterator, true);

四、综合实战：电商订单多维度分析系统

4.1 需求背景

某电商平台需要对季度订单数据进行实时分析，要求：

  1. 统计各省份的订单总数及平均金额
  2. 找出金额前10的订单并分析其用户画像
  3. 并行处理千万级订单数据，响应时间≤5秒

4.2 并行流实现方案

List<Order> quarterlyOrders = loadQuarterlyOrders(); // 假设返回1000万条订单

// 1. 省份维度统计（并行流+自定义收集器）
Map<String, ProvinceStats> provinceStats = quarterlyOrders.parallelStream()
    .collect(Collectors.groupingBy(
        Order::getProvince,
        () -> new ConcurrentHashMap<String, ProvinceStats>(),
        Collectors.teeing(
            Collectors.counting(), // 统计订单数
            Collectors.averagingDouble(Order::getAmount), // 统计平均金额
            (count, avg) -> new ProvinceStats(count, avg)
        )
    ));

// 2.  top10订单分析（串行流+状态处理）
List<Order> top10Orders = quarterlyOrders.stream()
    .sorted(Comparator.comparingDouble(Order::getAmount).reversed())
    .limit(10)
    .collect(Collectors.toList());

// 分析用户画像（并行流处理每个订单）
Map<Long, UserProfile> userProfiles = top10Orders.parallelStream()
    .map(Order::getUserId)
    .distinct()
    .collect(Collectors.toMap(
        userId -> userId,
        userId -> fetchUserProfile(userId), // 假设该方法线程安全
        (oldVal, newVal) -> oldVal, // 去重逻辑
        ConcurrentHashMap::new
    ));

// 3. 性能优化关键点
// - 使用parallelStream()开启并行处理
// - 分组统计时使用ConcurrentHashMap支持并发
// - 对userId去重后再查询用户画像，减少重复调用

4.3 性能监控与调优

通过添加性能监控代码，定位瓶颈点：

public class StreamPerformanceMonitor {
    private static final ThreadLocal<Long> startTime = new ThreadLocal<>();

    public static void start() {
        startTime.set(System.nanoTime());
    }

    public static void log(String operation) {
        long elapsed = System.nanoTime() - startTime.get();
        System.out.printf("[%s] 耗时: %d ms%n", operation, elapsed / 1_000_000);
        startTime.remove();
    }
}

// 使用示例
StreamPerformanceMonitor.start();
Map<String, ProvinceStats> stats = quarterlyOrders.parallelStream()
    .collect(Collectors.groupingBy(...));
StreamPerformanceMonitor.log("省份统计");

通过监控发现，用户画像查询是主要瓶颈，优化方案：

  1. 使用批量查询接口替代单条查询
  2. 增加缓存层（如Guava Cache）
// 优化后用户画像查询
Map<Long, UserProfile> cachedProfiles = CacheLoader.from(UserProfileService::getBatch);
Map<Long, UserProfile> userProfiles = top10Orders.parallelStream()
    .map(Order::getUserId)
    .distinct()
    .collect(Collectors.toMap(
        userId -> userId,
        userId -> cachedProfiles.get(userId),
        (oldVal, newVal) -> oldVal,
        ConcurrentHashMap::new
    ));

五、总结：Stream高级编程的核心法则

  1. 并行流使用三要素：

    • 数据量足够大（建议≥1万条）
    • 操作无共享状态或线程安全
    • 数据源支持高效分割（如ArrayList、数组）

  2. 自定义收集器设计原则：

    • 优先使用Collector.of简化实现
    • 明确标识Characteristics（CONCURRENT、UNORDERED等）
    • 合并逻辑需保证线程安全

  3. 性能优化黄金法则：

    • 避免过度使用中间操作
    • 基本类型流优先于对象流
    • 用Spliterator优化数据分割
    • 并行流并非银弹，需结合具体场景测试

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

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

相关文章

计算机视觉——相机标定

计算机视觉——相机标定

计算机视觉——相机标定 一、像素坐标系、图像坐标系、相机坐标系、世界坐标系二、坐标系变换图像坐标系 → 像素坐标系相机坐标系 → 图像坐标系世界坐标系 → 相机坐标系 ⋆ \star ⋆ 世界坐标系 → 像素坐标系 三、相机标定 一、像素坐标系、图像坐标系、相机坐标系、世界坐…
阅读更多...
C语言中的数据类型（二）--结构体

C语言中的数据类型（二）--结构体

在之前我们已经探讨了C语言中的自定义数据类型和数组&#xff0c;链接如下&#xff1a;C语言中的数据类型&#xff08;上&#xff09;_c语言数据类型-CSDN博客 目录 一、结构体的声明 二、结构体变量的定义和初始化 三、结构体成员的访问 3.1 结构体成员的直接访问 3.2 结…
阅读更多...
C++11：原子操作与内存顺序：从理论到实践的无锁并发实现

C++11：原子操作与内存顺序：从理论到实践的无锁并发实现

文章目录 0.简介1.并发编程需要保证的特性2.原子操作2.1 原子操作的特性 3.内存顺序3.1 顺序一致性3.2 释放-获取&#xff08;Release-Acquire)3.3 宽松顺序&#xff08;Relaxed)3.4 内存顺序 4.无锁并发5. 使用建议 0.简介 在并发编程中&#xff0c;原子性、可见性和有序性是…
阅读更多...
动力电池点焊机：驱动电池焊接高效与可靠的核心力量|比斯特自动化

动力电池点焊机：驱动电池焊接高效与可靠的核心力量|比斯特自动化

在新能源汽车与储能设备需求激增的背景下&#xff0c;动力电池的制造工艺直接影响产品性能与安全性。作为电芯与极耳连接的核心设备&#xff0c;点焊机如何平衡效率、精度与可靠性&#xff0c;成为电池企业关注的重点。 动力电池点焊机的核心功能是确保电芯与极耳的稳固连接。…
阅读更多...
【MySQL】10.事务管理

【MySQL】10.事务管理

1. 事务的引入 首先我们需要知道CURD操作不加控制会产生什么问题&#xff1a; 为了解决上面的问题&#xff0c;CURD需要满足如下条件&#xff1a; 2. 事务的概念 事务就是一组DML语句组成&#xff0c;这些语句在逻辑上存在相关性&#xff0c;这一组DML语句要么全部成功&…
阅读更多...
Bugku-CTF-Web安全最佳刷题路线

Bugku-CTF-Web安全最佳刷题路线

曾经的我也是CTF六项全能&#xff0c;Web安全&#xff0c;密码学&#xff0c;杂项&#xff0c;Pwn&#xff0c;逆向&#xff0c;安卓样样都会。明明感觉这样很酷&#xff0c;却为何还是沦为社畜。Bugku-CTF-Web安全最佳刷题路线&#xff0c;我已经整理好了&#xff0c;干就完了…
阅读更多...
IT学习方法与资料分享

IT学习方法与资料分享

一、编程语言与核心技能&#xff1a;构建技术地基 1. 入门首选&#xff1a;Python 与 JavaScript Python&#xff1a;作为 AI 与数据科学的基石&#xff0c;可快速构建数据分析与自动化脚本开发能力。 JavaScript&#xff1a;Web 开发的核心语言&#xff0c;可系统掌握 React/V…
阅读更多...
jenkins gerrit-trigger插件配置

jenkins gerrit-trigger插件配置

插件gerrit-trigger下载好之后要在Manage Jenkins -->Gerrit Trigger-->New Server 中新增Gerrit Servers 配置好保存后点击“状态”查看是否正常
阅读更多...
数论总结，（模版与题解）

数论总结，（模版与题解）

数论 欧拉函数X质数&#xff08;线性筛与二进制枚举&#xff09;求解组合数欧拉降幂&#xff08;乘积幂次&#xff09;乘法逆元最小质因子之和模版 欧拉函数 欧拉函数的定义就是小于等于n的数里有f(n)个数与n互质&#xff0c;下面是求欧拉函数的模版。 package com.js.datas…
阅读更多...
EasyRTC嵌入式音视频通信SDK助力物联网/视频物联网音视频打造全场景应用

EasyRTC嵌入式音视频通信SDK助力物联网/视频物联网音视频打造全场景应用

一、方案概述​ 随着物联网技术的飞速发展&#xff0c;视频物联网在各行业的应用日益广泛。实时音视频通信技术作为视频物联网的核心支撑&#xff0c;其性能直接影响着系统的交互体验和信息传递效率。EasyRTC作为一款成熟的音视频框架&#xff0c;具备低延迟、高画质、跨平台等…
阅读更多...
1-2 Linux-虚拟机（2025.6.7学习篇- win版本）

1-2 Linux-虚拟机（2025.6.7学习篇- win版本）

1、虚拟机 学习Linux系统&#xff0c;就需要有一个可用的Linux系统。 如何获得&#xff1f;将自己的电脑重装系统为Linux&#xff1f; NoNo。这不现实&#xff0c;因为Linux系统并不适合日常办公使用。 我们需要借助虚拟机来获得可用的Linux系统环境进行学习。 借助虚拟化技术&…
阅读更多...
Deepseek基座：Deepseek-v2核心内容解析

Deepseek基座：Deepseek-v2核心内容解析

DeepSeek原创文章1 DeepSeek-v3&#xff1a;基于MLA的高效kv缓存压缩与位置编码优化技术 2 Deepseek基座&#xff1a;DeepSeek LLM核心内容解析 3 Deepseek基座&#xff1a;Deepseek MOE核心内容解析 4 Deepseek基座&#xff1a;Deepseek-v2核心内容解析 5Deepseek基座&#xf…
阅读更多...
2025主流智能体Agent终极指南：Manus、OpenManus、MetaGPT、AutoGPT与CrewAI深度横评

2025主流智能体Agent终极指南：Manus、OpenManus、MetaGPT、AutoGPT与CrewAI深度横评

当你的手机助手突然提醒"明天会议要带投影仪转接头"&#xff0c;或是电商客服自动生成售后方案时&#xff0c;背后都是**智能体(Agent)**在悄悄打工。这个AI界的"瑞士军刀"具备三大核心特征&#xff1a; 自主决策能力&#xff1a;像老司机一样根据路况实时…
阅读更多...
家政小程序开发——AI+IoT技术融合，打造“智慧家政”新物种

家政小程序开发——AI+IoT技术融合，打造“智慧家政”新物种

基于用户历史订单&#xff08;如“每周一次保洁”&#xff09;、设备状态&#xff08;如智能门锁记录的清洁频率&#xff09;&#xff0c;自动生成服务计划。 结合天气数据&#xff08;如“雨天推荐玻璃清洁”&#xff09;&#xff0c;动态推送服务套餐。 IoT设备联动&#x…
阅读更多...
Keil开发STM32生成hex文件/bin文件

Keil开发STM32生成hex文件/bin文件

生成hex文件生成bin文件 STM32工程的hex文件和bin文件都可以通过Keil直接配置生成 生成hex文件 工程中点击魔术棒&#xff0c;在 Output 中勾选 Create HEX File 选项&#xff0c;OK保存工程配置 编译工程通过后可以看到编译输出窗口有创建hex文件的提示 默认可以在Output文…
阅读更多...
PDF 转 Markdown

PDF 转 Markdown

本地可部署的模型 Marker Marker 快速准确地将文档转换为 markdown、JSON 和 HTML。 转换所有语言的 PDF、图像、PPTX、DOCX、XLSX、HTML、EPUB 文件在给定 JSON 架构 &#xff08;beta&#xff09; 的情况下进行结构化提取设置表格、表单、方程式、内联数学、链接、引用和代…
阅读更多...
北大开源音频编辑模型PlayDiffusion，可实现音频局部编辑，比传统 AR 模型的效率高出 50 倍！

北大开源音频编辑模型PlayDiffusion，可实现音频局部编辑，比传统 AR 模型的效率高出 50 倍！

北大开源了一个音频编辑模型PlayDiffusion&#xff0c;可以实现类似图片修复(inpaint)的局部编辑功能 - 只需修改音频中的特定片段&#xff0c;而无需重新生成整段音频。此外&#xff0c;它还是一个高性能的 TTS 系统&#xff0c;比传统 AR 模型的效率高出 50 倍。 自回归 Tra…
阅读更多...
蒲公英盒子连接问题debug

蒲公英盒子连接问题debug

1、 现象描述 2、问题解决 上图为整体架构图&#xff0c;其中左边一套硬件设备是放在机房&#xff0c;右边是放在办公室。左边的局域网连接了可以访问外网的路由器&#xff0c;利用蒲公英作为旁路路由将局域网暴露在外网环境下。 我需要通过蒲公英作为旁路路由来进行远程访问&…
阅读更多...
Unity | AmplifyShaderEditor插件基础（第五集：简易膨胀shader）

Unity | AmplifyShaderEditor插件基础（第五集：简易膨胀shader）

一、&#x1f44b;&#x1f3fb;前言 大家好&#xff0c;我是菌菌巧乐兹~本节内容主要讲一下&#xff0c;如何用shader来膨胀~ 效果预览&#xff1a; 二、&#x1f4a8;膨胀的基本原理 之前的移动是所有顶点朝着一个方向走&#xff0c;所以是移动 如果所有顶点照着自己的方…
阅读更多...
WINUI——Magewell视频捕捉开发手记

WINUI——Magewell视频捕捉开发手记

背景 因需要融合视频&#xff0c;并加载患者CT中提取出的气管镜与病变&#xff0c;以便能实时查看气管镜是否在正确位置。 开发环境 硬件&#xff1a;Magewell的USB Capture HDMI Gen 2 IDE&#xff1a;VS2022 FrameWork: .Net6 WINUI Package: MVVMToolKit NLog Ma…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023