Java 21中SequencedCollection的10大应用场景(资深架构师亲授)

第一章:Java 21中SequencedCollection的核心概念解析

Java 21引入了`SequencedCollection`接口,作为集合框架的一次重要演进,旨在统一有序集合的行为定义。该接口扩展自`Collection`,为具有确定元素顺序的集合类型(如`List`、`LinkedHashSet`等)提供了标准化的操作方式。

核心设计目标

  • 提供一致的API来访问集合的首尾元素
  • 支持逆序视图操作,无需额外工具类
  • 增强集合的函数式编程能力

关键方法说明

方法名功能描述
getFirst()返回集合中的第一个元素
getLast()返回集合中的最后一个元素
reversed()返回当前集合的逆序视图

代码示例

// 创建一个支持SequencedCollection的列表
SequencedCollection<String> collection = new LinkedHashSet<>();
collection.add("Apple");
collection.add("Banana");
collection.add("Cherry");

// 获取首尾元素
String first = collection.getFirst(); // Apple
String last = collection.getLast();   // Cherry

// 获取逆序视图(不修改原集合)
SequencedCollection<String> reversed = collection.reversed();
System.out.println(reversed); // [Cherry, Banana, Apple]
上述代码展示了如何通过标准API安全地访问有序集合的边界元素,并获取其逆序视图。`reversed()`方法返回的是原集合的视图,因此不会产生额外的数据复制开销。
graph LR A[SequencedCollection] --> B[getFirst] A --> C[getLast] A --> D[reversed] D --> E[返回逆序视图]

第二章:SequencedCollection的接口设计与实现机制

2.1 理解SequencedCollection的继承体系与契约规范

在Swift标准库中,SequencedCollection是构建有序数据访问的核心协议之一。它继承自Collection,并强化了元素顺序访问的语义契约:首个元素可通过first获取,末尾元素通过last访问,且保证遍历时顺序稳定。
核心方法与语义约束
该协议要求实现者确保序列的首尾可预测性。例如:
protocol SequencedCollection: Collection {
    var first: Element? { get }
    var last: Element? { get }
}
上述定义意味着所有遵循该协议的类型(如Array、LinkedList)必须提供first和last的高效实现,通常时间复杂度为O(1)。
典型实现对比
  • Array:基于连续内存存储,天然支持快速首尾访问;
  • Deque(双端队列):通过环形缓冲区维护顺序,同样满足契约;
  • Set:不遵循SequencedCollection,因其无固定遍历顺序。

2.2 前后元素访问:first()与last()方法的语义精析

在集合操作中,`first()` 与 `last()` 方法用于获取序列中的首尾元素,具有明确的语义指向。它们不仅提升代码可读性,还封装了边界判断逻辑。
方法行为定义
  • first():返回集合第一个匹配元素,若为空则抛出异常;
  • last():返回最后一个匹配元素,无匹配时同样报错。
典型代码示例
values := []int{10, 20, 30}
first := values[0]       // 等价于 first()
last := values[len(values)-1] // 等价于 last()
上述代码展示了底层实现逻辑:通过索引 0 和 len-1 访问首尾元素,但手动操作易引发越界错误。
安全访问对比
方法空集合行为时间复杂度
first()panic 或 optional 返回O(1)
last()panic 或 optional 返回O(1)

2.3 序列反转操作reversed()的底层实现原理

Python 内置函数 `reversed()` 并不直接创建反转后的列表,而是返回一个反向迭代器对象,延迟计算以提升性能。
核心机制:反向迭代器
该函数要求传入对象实现 `__reversed__()` 方法或支持序列协议(即定义 `__len__()` 和 `__getitem__()`)。若未实现 `__reversed__()`,解释器会自动生成从末尾到开头的索引遍历。
class CustomSeq:
    def __init__(self, data):
        self.data = data
    def __len__(self):
        return len(self.data)
    def __getitem__(self, index):
        return self.data[index]

seq = CustomSeq([1, 2, 3])
rev = reversed(seq)  # 返回 
print(list(rev))     # 输出: [3, 2, 1]
上述代码中,`CustomSeq` 未定义 `__reversed__()`,系统退而使用索引从 `len-1` 递减至 `0` 实现反转。
性能优势
  • 避免复制整个序列,节省内存
  • 惰性求值,仅在迭代时计算下一个元素

2.4 支持序列化访问的集合类型兼容性分析

在并发编程中,确保集合类型的线程安全与序列化兼容性至关重要。某些集合类型虽支持同步访问,但在序列化过程中可能因状态不一致引发异常。
典型并发集合的序列化行为
  • ConcurrentHashMap:支持序列化,且保证遍历期间的弱一致性视图;
  • CopyOnWriteArrayList:写操作复制底层数组,读操作无锁,天然适合不可变快照序列化;
  • Vector 和 Hashtable:虽已过时,但因其同步方法仍可安全序列化。
private void writeObject(ObjectOutputStream out) throws IOException {
    synchronized (this) { // 确保序列化期间对象状态一致
        out.defaultWriteObject();
    }
}
上述代码展示了如何在自定义集合类中通过同步块保护序列化过程,防止并发修改导致的数据损坏。
兼容性对比表
集合类型线程安全支持序列化注意事项
ArrayList否是需外部同步
ConcurrentHashMap是是序列化性能较低
CopyOnWriteArrayList是是频繁写入开销大

2.5 实战:构建可逆序遍历的业务数据管道

在复杂业务场景中,数据处理常需支持正向执行与逆向回滚。构建可逆序遍历的数据管道,关键在于每个处理节点保留足够的上下文信息,以便反向操作时恢复状态。
双向链式结构设计
采用双向链表组织数据处理节点,每个节点包含前驱和后继指针,支持 O(1) 时间复杂度的逆序跳转。

type Node struct {
    Data     interface{}
    Next     *Node
    Prev     *Node
    Rollback func() error // 回滚函数
}
上述结构中,Rollback 函数封装了该节点操作的逆向逻辑,如数据库写入对应删除或补偿事务。
操作序列管理
维护一个执行轨迹栈,记录已成功执行的节点,逆序遍历时从栈顶逐个调用 Rollback 方法。
  • 正向执行:依次推进节点,并压入执行栈
  • 逆向遍历:弹出栈顶节点,触发其回滚逻辑
  • 异常处理:任一节点失败时自动触发全量回滚

第三章:典型集合类中的SequencedCollection应用

3.1 ArrayList与LinkedHashMap对序列操作的支持对比

数据结构特性分析
ArrayList 基于动态数组实现,支持快速随机访问,但插入和删除效率较低;LinkedHashMap 则基于哈希表加双向链表,维护插入顺序或访问顺序,适合频繁的遍历操作。
典型操作性能对比
操作ArrayListLinkedHashMap
按索引访问O(1)不支持
插入末尾摊销 O(1)O(1)
中间插入O(n)O(1)
遍历(保持顺序)O(n)O(n),有序输出

// 示例:LinkedHashMap 维护插入顺序
LinkedHashMap<Integer, String> map = new LinkedHashMap<>();
map.put(1, "A");
map.put(2, "B");
System.out.println(map.keySet()); // 输出 [1, 2]
上述代码展示了 LinkedHashMap 能够自然维持元素插入顺序,而 ArrayList 虽可通过索引控制顺序,但在键值映射场景下缺乏语义支持。

3.2 使用SequencedSet管理有序唯一权限列表

在权限控制系统中,确保权限项的唯一性和顺序性至关重要。SequencedSet 是一种结合了集合(Set)与序列(List)特性的数据结构,既能防止重复权限的插入,又能维持权限定义的先后顺序。
核心特性与应用场景
  • 自动去重:避免同一权限被多次添加
  • 顺序保持:按添加时间或优先级排序
  • 高效查询:支持按索引或值快速检索
Go语言实现示例
type SequencedSet struct {
    items map[string]int
    order []string
}

func (s *SequencedSet) Add(permission string) {
    if _, exists := s.items[permission]; !exists {
        s.items[permission] = len(s.order)
        s.order = append(s.order, permission)
    }
}
上述代码中,items 用于快速判断权限是否存在,order 保留插入顺序,确保遍历时的确定性。该结构适用于RBAC系统中权限审计与继承场景。

3.3 基于SequencedMap的最近访问缓存策略实现

在高并发场景下,缓存的有效性直接影响系统性能。采用 SequencedMap 可自然维护键值对的插入与访问顺序,适用于实现 LRU(最近最少使用)类缓存策略。
核心数据结构设计
SequencedMap 保证元素按访问顺序排列,每次读取或写入时自动调整位置,无需额外排序逻辑。
  • 插入操作将键值对置于序列末尾
  • 访问命中后重新定位至末尾,标记为“最近使用”
  • 容量超限时从头部驱逐最久未用项
代码实现示例
type LRUCache struct {
    data *sequenced.Map[string, interface{}]
    cap  int
}

func (c *LRUCache) Get(key string) interface{} {
    if val, ok := c.data.Get(key); ok {
        c.data.MoveToBack(key) // 标记为最近访问
        return val
    }
    return nil
}

func (c *LRUCache) Put(key string, value interface{}) {
    if c.data.Len() >= c.cap && !c.data.Has(key) {
        c.data.DeleteFirst() // 驱逐最久未用
    }
    c.data.Set(key, value)
    c.data.MoveToBack(key)
}
上述实现中,MoveToBack 确保访问局部性,DeleteFirst 维护容量约束,整体时间复杂度为 O(1)。

第四章:高阶业务场景下的编程实践

4.1 构建可追溯操作顺序的审计日志队列

在分布式系统中,确保操作的可追溯性是安全与合规的核心需求。通过引入审计日志队列,可将用户操作、系统事件等关键行为有序记录,保障后续审计追踪。
日志结构设计
每条审计日志应包含唯一ID、操作类型、操作主体、目标资源、时间戳及上下文元数据。使用结构化格式(如JSON)便于解析与检索:

{
  "trace_id": "req-5f9d8a7b",
  "action": "user.login",
  "actor": "alice@company.com",
  "resource": "auth-service",
  "timestamp": "2023-10-01T08:23:45Z",
  "metadata": {
    "ip": "192.168.1.100",
    "user_agent": "Mozilla/5.0"
  }
}
该结构确保每项操作具备完整上下文,支持基于 trace_id 的跨服务链路追踪。
异步写入与持久化
为避免阻塞主业务流程,审计日志应通过消息队列异步传输。常用方案包括 Kafka 或 RabbitMQ,结合持久化存储(如 Elasticsearch)实现高效查询与长期归档。

4.2 利用序列特性实现多级审批流程控制器

在复杂业务系统中,多级审批流程的动态控制是核心需求之一。通过引入序列特性,可将审批节点按顺序编码,实现灵活的状态流转与权限校验。
审批序列设计
采用递增序列表示审批层级,每个节点对应唯一序号,确保流程不可逆且可追溯。例如:10 → 20 → 30 表示三级审批链。
节点ID审批角色序列值
A主管10
B部门经理20
C总监30
状态流转逻辑
// 根据当前序列值判断是否可进入下一节点
func CanProceed(current, next int) bool {
    return next > current && (next-current) == 10 // 固定步长控制
}
上述代码通过比较序列差值控制流转规则,仅当目标节点序列为当前+10时允许推进,保障审批层级不被跳过。

4.3 在事件溯源架构中维护事件顺序一致性

在事件溯源(Event Sourcing)架构中,事件的顺序直接影响系统状态的正确性。确保事件按产生时序持久化和重放,是保障数据一致性的核心。
基于版本号的乐观锁机制
通过为聚合根维护一个递增的版本号,可防止并发写入导致的顺序错乱:
type Event struct {
    AggregateID string
    Version     int
    Payload     interface{}
    Timestamp   time.Time
}
该结构体中,Version字段标识事件在聚合根中的顺序。存储时,数据库通过检查版本连续性与唯一性,拒绝非法插入,从而保证全局顺序。
事件存储的有序写入策略
  • 使用单一分区日志(如Kafka分区)确保物理写入有序
  • 结合分布式锁或聚合根级串行化处理,避免并发修改
  • 引入时间戳与逻辑时钟(如Lamport Timestamp)辅助排序

4.4 结合模式匹配优化序列集合的数据提取逻辑

在处理复杂数据结构时,传统的遍历与条件判断方式往往导致代码冗余且难以维护。通过引入模式匹配机制,可显著提升数据提取的清晰度与执行效率。
模式匹配在序列提取中的应用
利用模式匹配,开发者能够以声明式语法精准定位目标数据结构。例如,在 Go 中模拟模式匹配逻辑:

switch v := data.(type) {
case []int:
    fmt.Println("整型切片:", v)
case map[string]string:
    fmt.Println("字符串映射:", v)
default:
    fmt.Println("未知类型")
}
该代码通过类型断言实现分支匹配,v := data.(type) 提取变量并判断其动态类型,从而分流处理不同集合结构,避免深层嵌套判断。
优化策略对比
  • 传统方式依赖多重 if-else,可读性差;
  • 模式匹配将提取逻辑集中化,降低耦合;
  • 结合递归解构,可高效处理嵌套序列。

第五章:未来演进方向与生态影响评估

服务网格与无服务器架构的融合趋势
现代云原生系统正加速向无服务器(Serverless)与服务网格(Service Mesh)深度融合的方向发展。以 Istio 为例,通过将 Envoy 代理嵌入函数运行时环境,可实现细粒度流量控制与安全策略统一管理。
  • OpenFaaS 结合 Linkerd 实现轻量级函数调用追踪
  • AWS Lambda 利用 App Mesh 进行跨区域流量镜像测试
  • Google Cloud Run 集成 Anthos Service Mesh 支持 mTLS 全链路加密
可观测性标准的统一化实践
随着 OpenTelemetry 成为 CNCF 毕业项目,其在分布式追踪中的应用日益广泛。以下代码展示了 Go 函数如何注入上下文并上报指标:

package main

import (
    "context"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/metric"
)

func handleRequest(ctx context.Context) {
    meter := otel.Meter("example-meter")
    requests, _ := meter.Int64Counter("http.requests")
    
    requests.Add(ctx, 1, metric.WithAttributes(
        attribute.String("path", "/api/v1/data"),
    ))
}
边缘计算场景下的协议优化
在 IoT 边缘节点中,传统 HTTP/JSON 开销过大。采用 Protocol Buffers + gRPC-Web 可降低传输延迟达 60%。某智能工厂案例中,5000 个传感器通过压缩编码将日均带宽消耗从 1.2TB 降至 480GB。
协议方案平均延迟 (ms)带宽占用 (GB/天)设备CPU峰值
HTTP/JSON142120078%
gRPC+Protobuf5648043%
37、OpenMP:并行编程的强大工具 本文详细介绍了 OpenMP 的核心功能和使用方法,包括执行环境例程、线程同步与协调机制,如关键区域、屏障、原子操作、归约子句、刷新构造和锁机制。此外,还提供了多个实践练习,涵盖矩阵乘法的并行实现、任务池与流水线模式的应用、读写锁的扩展与移植,以及客户端-服务器模式的实现与优化。通过这些内容,读者可以全面掌握 OpenMP 在并行编程中的实际应用与性能优化技巧。 阅读详情

相关推荐

Qwen-Image LoRA训练实战:从数据准备到异常修复的全流程解析

本文详细解析了Qwen-Image LoRA训练的全流程,从数据准备到参数优化再到异常修复。通过实战案例展示了如何利用LoRA技术微调Qwen-Image模型,提升中文场景下的图像生成质量,特别针对手脚生成异常等问题提供了有效解决方案。文章还分享了中文提示词优化技巧和高级训练方法,帮助开发者高效训练出高质量的LoRA模型。

lemon的博客 970

揭秘Java 21序列集合:5分钟掌握SequencedCollection核心用法

掌握Java 21序列集合(SequencedCollection)核心用法,快速解决有序集合操作难题。介绍首个元素、最后一个元素、反向视图等新方法,提升代码可读性与效率。适用于队列、列表等场景,值得收藏。

VarChat的博客 879

开关电源EMI滤波设计:如何通过Cx和Cy电容精准抑制共模与差模干扰?

本文深入解析了开关电源EMI滤波设计中Cx和Cy电容的核心作用。Cx电容并联于火线与零线之间,专用于抑制差模干扰;Cy电容连接于火线/零线与地之间,则负责泄放共模干扰。文章详细阐述了二者选型、安规要求及PCB布局要点,并提供了基于测试频谱的实战调优策略,是解决电源传导噪声问题的实用指南。

7z8x2c4v6b9的博客 468

SequencedCollection实战指南:3个案例教你轻松驾驭Java 21新集合

掌握Java 21序列集合(SequencedCollection)核心技巧,解决有序集合操作难题。涵盖首尾元素访问、逆序遍历等场景,详解getFirst、getLast、reversed等关键方法,提升代码可读性与性能,SequencedCollection实战指南值得收藏。

CompiShoal的博客 903

通讯软件013——分分钟学会Kepware OPC AE Server仿真配置

本文介绍如何使用Kepware软件仿真OPC AE Server配置。

zhouwl72的博客 2231

如何用Megatron-LM搭建多卡集群?手把手教你配置分布式训练环境

本文提供了一份详细的Megatron-LM多卡集群搭建实战指南。从硬件兼容性检查、软件栈版本对齐,到分布式并行策略(数据并行、张量并行、流水线并行)的配置与多节点启动脚本编写,手把手教你配置稳定高效的分布式训练环境,并分享了关键的排错与性能调优经验。

yellow的专栏 416

【Java 21新特性深度解析】:SequencedCollection如何重塑集合操作?

掌握Java 21序列集合(SequencedCollection)新特性,提升集合操作效率。新增getFirst、getLast、reversed等方法,简化有序集合处理,适用于栈、队列等场景,代码更简洁安全,值得收藏。

CodeWhim的博客 775

Linux C/C++ or 嵌入式面试之《C/C++笔面试系列》(10) C++ 前置后置增减运算符重载形式与比较

C语言的++、–运算符在此不讨论。 文章目录1、前置后置增减运算符重载的形式2、前置和后置运算符的性能比较 1、前置后置增减运算符重载的形式 自增运算符“++”和自减运算符“–”分别包含两个版本。即运算符前置形式(如 ++x)和运算符后置形式(如 x++),这两者进行的操作是不一样的。因此,当我们在对这两个运算符进行重载时,就必须区分前置和后置形式。C++根据参数的个数来区分前置和后置形式。如果按照通常的方法来重载 ++ 运算符(即作为成员函数重载时不带参数,或者作为非成员函数重载时带有一个参数),那么重载

二进制君 5834

Java 21 SequencedCollection全解析(底层原理+性能对比)

掌握Java 21序列集合(SequencedCollection)核心特性与底层实现,解决集合操作顺序难题。涵盖first、last等关键方法,提升有序集合处理效率,适用于队列、缓存等场景,性能优于传统结构,值得收藏。

VarLens的博客 810

把 SM30 用顺:从表设计到权限与传输,全面掌握 SAP Table Maintenance Generator

摘要 SAP的Table Maintenance Generator(TMG)是为配置表维护需求设计的经典工具,能够生成标准化的维护对话框(SM30)。它支持单表、维护视图(多表关联)和视图簇(导航式维护)三种维护对象类型。使用TMG前需注意三个关键设置:1)表维护权限选项;2)交付类(决定数据传输行为);3)客户端字段配置。通过SE54/SE11生成维护对话框时,需选择维护类型(一步/两步)和记录例程(控制传输)。TMG生成的对象包含函数组、屏幕和处理模块,但部分标准框架不可修改。实际应用中,可通过参数事

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 177

YOLOv8人工智能与深度学习——强化学习

本文介绍了将YOLOv8目标检测模型与强化学习结合的方法。主要应用包括自适应目标检测(动态调整检测参数)、主动学习(智能选择标注样本)和多目标跟踪优化。实现方案采用深度Q网络策略,通过定义状态表示、动作空间和奖励函数,使检测系统能根据环境反馈优化性能。该方法具有自适应优化、资源高效、持续改进等优势,能构建更智能的计算机视觉系统。文章详细说明了强化学习环境的构建、策略网络的实现以及训练过程,并提供了代码示例。

u010117029的博客 260

深入解析 TanStack Vue Table 的 FlexRenderHeader 接口与 FlexRender 渲染机制

本指南围绕 Vue Table 参考文档中的 `FlexRenderHeader` 接口展开,讲解 TanStack Table 生态(vue-table)中自定义表头/单元格/表尾渲染的核心机制。文中将结合 [FlexRender.ts](https://link.gitcode.com/i/e26a30715e921ace4d4f9ade0c88f243) 源码、[flexRender.tes

gitblog_00998的博客 455

【项目】多模态RAG—本地部署MinerU实现多类文档解析

【摘要】开源工具MinerU由OpenDataLab团队开发,支持本地部署实现多类文档(PDF/Word/Excel/图片等)解析,可保留原始格式并转换为Markdown/JSON。该工具具备OCR识别、表格/公式转换、多语言支持等功能,适用于RAG、文档数字化等场景。项目通过API服务实现政策文件解析需求,将附件转为Markdown后再生成HTML展示,解决了政务问答系统中格式丢失问题。安装部署包含模型下载和Python服务端搭建,提供RESTful接口供其他系统调用。

一个内容严谨、方向前沿、极具实践价值的AI大模型技术分享站 2786

Java21下的 Java 集合框架

本文深入解析Java集合框架的核心概念、体系结构与常用方法,涵盖Collection接口的通用操作、迭代器遍历及Java21新增的SequencedCollection接口,通过代码示例演示集合的增删改查、反转与遍历技巧,助你掌握高效数据管理与操作。

m0_73941339的博客 1678

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

Java集合框架重大升级:SequencedCollection带来的5项革命性变化

Java 21 序列集合(SequencedCollection)统一了有序集合的操作方式,新增first、last、reversed等核心方法,提升代码可读性与开发效率。适用于队列、列表等场景,简化逆序访问与元素操作。一次掌握新特性,值得收藏。

IterStream的博客 839

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

为什么顶尖大厂都在迁移到SequencedCollection?真相令人震惊

掌握Java 21序列集合(SequencedCollection)轻松解决集合操作繁琐问题,适用于有序数据处理场景,提供getFirst、getLast等核心方法,提升代码可读性与性能。大厂实践验证,值得收藏。

LearnPlex的博客 797

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

【Java 21 新特性】顺序集合(Sequenced Collections)

引入新的接口表示具有定义的遇到顺序的集合。每个这样的集合都有一个明确定义的第一个元素、第二个元素,依此类推,直到最后一个元素。提供统一的API来访问它的第一个和最后一个元素,并以相反的顺序处理它的元素。"生活只能向后理解;但必须向前生活。"—基尔克高德。

JavaEdge全是干货的技术号 1743

Java入门到精通-21 集合框架新特性与实战——Java 9-21集合增强

本文介绍了Java 9-21版本中集合框架的重要新特性,主要包括: 不可变集合工厂方法(Java 9+) 通过List.of()、Set.of()、Map.of()等简洁方式创建不可变集合 不可变集合天然线程安全,避免副作用,不允许null值 提供了内存优化和序列化支持 SequencedCollection接口(Java 21) 统一了有序集合的操作方式 提供addFirst()、getLast()等标准方法 支持reversed()方法获取反转视图 集合增强方法 结合Stream API进行函数式操作

weixin_56693899的博客 315

Java 21 新特性的实践,确实很丝滑!

一旦虚拟线程遇到阻塞操作,虚拟线程就会从载体线程中移除(“卸载”),并且载体线程可以执行另一个虚拟线程(新的或之前被阻塞的虚拟线程)。顺序集合为我们提供了defined encounter order(是一种所见即所得的顺序,含义是从队列中取出元素的顺序既是你存放该元素时候的顺序),用于访问第一个和最后一个元素并以相反的顺序迭代。它还提供了一种反转元素的方法。StringBuffer 是线程安全的,而 StringBuilder 是在 Java 5 中添加的,性能更高,但不是线程安全的替代方案。

好技术,多分享 731

JDK21新特性探秘

🌈🌈🌈🌈🌈🌈🌈🌈 欢迎关注公众号(通过文章导读关注:【11来了】),及时收到 AI 前沿项目工具及新技术 的推送 发送 资料 可领取 深入理解 Redis 系列文章结合电商场景讲解 Redis 使用场景、中间件系列笔记和编程高频电子书! 文章导读地址:点击查看文章导读! 🍁🍁🍁🍁🍁🍁🍁🍁

qq_45260619的博客 1233

【Java 21 新特性 】顺序集合(Sequenced Collections)

Java 21 中增加了一种新的集合类型:顺序集合(Sequenced Collections)。要介绍顺序集合,就首先要说明一下出现顺序(encounter order)。出现顺序指的是在遍历一个集合时,集合中元素的出现顺序。有些集合类型,有确定的出现顺序,比如List。不管遍历多少次这样的集合,其中元素的出现顺序始终是固定。有些集合类型,并没有确定的出现顺序,比如HashSet。如果多次遍...

成富的专栏 5359

Java 21 中的 SequencedCollection 接口使用指南

SequencedCollection 接口是 Java 21 中新增的一个集合接口,它扩展了 Collection 接口,旨在为集合提供顺序相关的操作。通过引入这个接口,Java 集合框架能够更清晰地表达元素的顺序性,并提供了统一的访问顺序元素的方法。SequencedCollection 接口的主要用途在于处理那些需要维护元素插入顺序的集合类型。与 List 接口不同,SequencedCollection 更专注于顺序操作,而不涉及索引访问等特性。这使得它在某些场景下更加灵活和适用。

43

Java的java.util.SequencedCollection序列集合与双向迭代的新增接口

Java 21引入的java.util.SequencedCollection接口为集合框架带来了革命性升级,它重新定义了有序集合的操作范式,同时通过双向迭代能力填补了Java集合API长期存在的功能空白。这一变化不仅简化了开发者的日常编码,更为处理序列化数据提供了标准化方案,标志着Java集合框架向更现代化、更符合函数式编程理念的方向迈出关键一步。例如,原先需要调用不同方法实现的队列和栈操作,现在可以通过同一套API完成,显著提升了代码的可读性和可维护性。与流式API的深度集成。不可变集合的增强支持。

tayium_552的博客 213

【java21】java21新特性之顺序集合

Sequenced Collections是一种新的集合类型,它提供了一个统一的接口来表示具有定义好的出现顺序的集合。每个Sequenced Collection都有一个明确定义的第一个元素、第二个元素,依此类推,直到最后一个元素。它还提供了一套统一的API来访问集合的第一个和最后一个元素,并以相同的顺序处理集合中的元素。有序性:每个Sequenced Collection都保持元素插入的顺序。

morris 5万+

Java 21即将发布,探索Java 21新特性和改进

Java 21将在 2023 年 9 月 19 日发布。Java 21是 Java 17之后的下一个 LTS版本。虚拟线程在 Java 21中将成为正式功能。Java 21 有望将会成为继 java8 之后又一个流行的 Java 版本。

weixin_40381772的博客 5947
上一篇: MyBatis接口绑定怎么选?:深度剖析注解和XML的5大核心差异
下一篇: C++开发者常犯的vector错误(reserve vs resize深度剖析)
ProceChat
博客等级 码龄1年 155粉丝 1997原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值