如何避免NullPointerException?Kotlin可空类型实战指南

第一章:Kotlin数据类型详解

Kotlin 是一种静态类型语言,其数据类型系统设计旨在提升代码安全性与可读性。所有变量在声明时都会关联一个具体的数据类型,Kotlin 提供了丰富的内置类型来支持各种编程需求。

基本数据类型

Kotlin 不提供原始类型(primitive types),所有变量都以对象形式存在。其基本类型包括数值型、布尔型和字符型。
  • Byte:8位有符号整数
  • Short:16位有符号整数
  • Int:32位有符号整数
  • Long:64位有符号整数
  • Float:32位单精度浮点数
  • Double:64位双精度浮点数
  • Boolean:true 或 false
  • Char:16位 Unicode 字符

数值类型的字面量表示

Kotlin 支持多种字面量格式,增强代码可读性:
// 十进制
val decimal: Int = 1000

// 二进制(以0b开头)
val binary: Int = 0b101010

// 十六进制(以0x开头)
val hex: Int = 0xFF

// 使用下划线分隔数字,提高可读性
val largeNumber: Long = 1_000_000_000
上述代码展示了不同进制的整数表示方式。使用下划线分隔大数字是 Kotlin 特有的语法糖,编译器会自动忽略这些下划线。

类型安全与自动推断

Kotlin 编译器支持类型自动推断,开发者无需显式声明类型(除非必要):
val name = "Kotlin" // 推断为 String
val age = 25          // 推断为 Int
val isActive = true   // 推断为 Boolean
数据类型默认值示例
Int042
Double0.03.14
Booleanfalsetrue

第二章:可空类型基础与语法解析

2.1 可空类型的定义与声明机制

可空类型是一种能够表示其基础类型所有值以及额外 `null` 值的特殊数据类型,广泛应用于数据库操作、API响应处理等场景。
语法结构与声明方式
在C#中,可空类型通过在值类型后添加问号 `?` 来声明:

int? nullableInt = null;
bool? flag = true;
上述代码中,`int?` 是 Nullable<int> 的简写形式,允许变量存储整数值或 `null`。`nullableInt` 初始值为 `null`,表示未分配有效整数。
底层结构解析
可空类型本质上是包含两个字段的泛型结构:Value 和 HasValue。
  • HasValue:布尔属性,指示是否包含非空值;
  • Value:获取实际值,若 HasValue 为 false 则抛出异常。

2.2 非空断言操作符的使用场景与风险

在 TypeScript 中,非空断言操作符(`!`)用于告诉编译器某个值不可能为 `null` 或 `undefined`。这在处理 DOM 元素或异步数据时尤为常见。
典型使用场景
当开发者明确知道元素已存在时,可使用非空断言简化类型检查:
const el = document.getElementById('app')!;
el.innerHTML = 'Hello World';
上述代码中,`!` 避免了对 `el` 的 null 判断,直接断言其存在。若实际未找到元素,运行时将抛出错误。
潜在风险
  • 绕过类型检查可能导致运行时错误
  • 在多人协作项目中降低代码健壮性
  • 难以调试,错误堆栈可能不直观
应优先使用条件判断或默认值替代非空断言,仅在确信上下文安全时谨慎使用。

2.3 安全调用操作符?.在实际开发中的应用

安全调用操作符 `?.` 是现代编程语言中处理可能为 null 或 undefined 对象属性访问的重要工具,能有效避免运行时错误。
常见使用场景
在前端开发中,常遇到异步加载的用户数据,其嵌套结构可能导致访问异常。使用 `?.` 可简化判空逻辑:

const userName = user?.profile?.name;
上述代码等价于层层判断 `user && user.profile && user.profile.name`,但更简洁安全。
与可选链结合的函数调用
当调用可能不存在的方法时,也可使用 `?.()` 形式:

this.logger?.log('Debug message');
若 `logger` 未定义,则语句自动短路,不会抛出异常。
  • 提升代码健壮性
  • 减少冗余的 if 判断
  • 增强可读性与维护性

2.4 Elvis操作符?:处理默认值的优雅方式

在Kotlin中,Elvis操作符 ?: 提供了一种简洁安全的方式来处理空值并指定默认值。当左侧表达式不为null时返回其值,否则执行右侧逻辑。
基础语法与应用场景
val name: String? = null
val result = name ?: "默认用户"
println(result) // 输出:默认用户
上述代码中,若 name 为 null,则使用“默认用户”作为替代值,避免了显式的 if-else 判空结构。
链式调用中的优势
Elvis操作符常用于深层属性访问场景:
val displayName = user?.profile?.nickname ?: "匿名"
该写法确保在任意层级为 null 时立即返回默认值,极大提升了代码可读性与安全性。
  • 简化判空逻辑,减少模板代码
  • 提升空安全处理的表达力
  • 支持嵌套与链式结构的优雅降级

2.5 类型自动推断与可空性检查的协同工作

在现代静态类型语言中,类型自动推断与可空性检查的结合显著提升了代码安全性与编写效率。编译器通过上下文自动推断变量类型的同时,严格追踪其可空状态,避免空引用异常。
类型推断与可空性的交互机制
当变量初始化时,编译器不仅推断其类型,还分析初始值是否为 `null`,从而确定该变量是否可空。
var name = "Alice";     // 推断为 string(非空)
var message = GetMessage(); // 若GetMessage返回*string,则推断为可空string?
上述代码中,`name` 被安全地推断为非空字符串类型,而 `message` 的可空性由函数返回类型决定,编译器据此强制在使用前进行空值检查。
编译期安全保证
  • 自动推断不牺牲类型安全,可空类型需显式解包
  • 赋值兼容性规则防止可空值误赋给非空变量
  • 条件判断后自动窄化类型(如空检查后视为非空)

第三章:安全调用链与作用域函数实践

3.1 安全调用链在嵌套对象访问中的实战

在处理深度嵌套的对象结构时,属性可能在任意层级缺失,直接访问易引发运行时错误。安全调用链技术能有效规避此类风险。
可选链操作符的应用
现代语言如 TypeScript 和 JavaScript 提供了可选链(?.)语法,允许逐层安全访问。

const user = {
  profile: {
    address: { city: 'Beijing' }
  }
};

// 安全读取嵌套属性
const city = user?.profile?.address?.city;
console.log(city); // 输出: Beijing

// 访问不存在的路径返回 undefined
const zipCode = user?.profile?.address?.zipCode;
console.log(zipCode); // 输出: undefined
上述代码中,?. 确保每层对象存在后再继续访问下一级,避免因中间节点为 null 或 undefined 导致程序崩溃。
对比传统判空方式
  • 传统方式需层层 if 判断,代码冗长且可读性差;
  • 使用安全调用链后逻辑简洁,提升开发效率与代码健壮性;
  • 尤其适用于 API 响应解析、配置对象读取等场景。

3.2 let、also等作用域函数结合可空类型的高效用法

在 Kotlin 中,`let`、`also` 等作用域函数与可空类型结合使用,能显著提升代码的安全性与可读性。通过安全调用操作符 `?.` 与作用域函数配合,可避免显式 null 判断。
安全的非空处理
val input: String? = "Hello"
input?.let { value ->
    println("Length: ${value.length}") // 仅当 input 非空时执行
}
`let` 将非空值转换为接收者,适用于需要对非空对象进行计算或转换的场景。
链式调用与上下文保留
user?.also {
    println("Processing user: ${it.name}")
}?.takeIf { it.isActive }?.let {
    service.process(it)
}
`also` 在不改变对象的前提下附加操作,适合日志记录或副作用处理,与 `takeIf` 结合实现条件流转。
  • let:适用于映射或转换非空值
  • also:用于执行副作用,返回原对象
  • 均通过 ?. 触发,确保空安全

3.3 run与with在可空上下文中的安全执行策略

在Kotlin中处理可空对象时,`run`与`with`提供了优雅的安全执行方式。二者均支持在作用域内访问`this`,但在调用方式上存在差异。
run:安全的链式调用
`run`作为扩展函数,可在可空对象上调用,仅当接收者非空时执行:
val result = nullableString?.run {
    uppercase()
    length
}
若`nullableString`为`null`,则`run`不执行并返回`null`,避免空指针异常。
with:需配合判空使用
`with`为顶层函数,必须确保传入对象非空:
val result = if (nullableString != null) {
    with(nullableString) { uppercase().length }
} else {
    0
}
直接传入可空类型会触发编译警告,建议结合`let`或`if`判空使用。
选择策略对比
  • run天然适配可空链式调用,更安全;
  • with需显式判空,适用于已知非空场景。

第四章:模式匹配与异常预防技巧

4.1 使用when表达式进行可空值的分支处理

在 Kotlin 中,`when` 表达式不仅支持常量匹配,还可用于处理可空类型(nullable types)的分支逻辑。通过将可空值直接作为 `when` 的参数,能够清晰地区分 `null` 与非 `null` 情况。
基础用法示例
fun describeValue(value: Int?) = when (value) {
    null -> "输入为空"
    else -> "数值为 $value"
}
上述代码中,`when` 对 `value` 进行判空:若为 `null`,返回提示信息;否则返回具体数值。`else` 分支等价于默认情况,覆盖所有非空情形。
多条件匹配
  • `when` 支持多个具体值匹配,提升可读性
  • 结合智能类型转换,可在非空分支中直接使用变量
该机制显著简化了对可空类型的条件判断流程,避免嵌套的 `if-else` 结构,增强代码可维护性。

4.2 自定义工具函数封装可空逻辑判断

在开发过程中,频繁的空值校验会导致代码冗余。通过封装通用的可空判断工具函数,可显著提升代码健壮性与可读性。
基础判空函数设计
// IsNil 检查接口是否为 nil 或零值
func IsNil(i interface{}) bool {
    if i == nil {
        return true
    }
    v := reflect.ValueOf(i)
    switch v.Kind() {
    case reflect.Ptr, reflect.Map, reflect.Slice, reflect.Chan:
        return v.IsNil()
    }
    return false
}
该函数利用反射识别指针、切片等类型的空状态,统一处理多种可空场景。
常用判断场景对比
类型判空方式适用函数
string== ""IsEmpty
slicelen == 0IsNil 或 IsEmpty
mapIsNilIsNil

4.3 协同后端接口设计避免空值传递陷阱

在前后端协作中,空值处理不当常引发运行时异常或数据逻辑错误。为规避此类问题,需在接口契约层面明确字段的可空性与默认值策略。
使用类型系统约束空值
现代语言如Go或TypeScript支持可空类型标注,能提前暴露潜在问题:
type User struct {
    ID   int      `json:"id"`
    Name string   `json:"name"`        // 必填字段
    Age  *int     `json:"age,omitempty"` // 指针表示可选
}
该结构体中,Age 使用指针类型,明确表示其可为空。序列化时配合 omitempty 可控制输出,防止前端误判缺失字段。
统一空值处理规范
团队应约定以下规则:
  • 所有响应字段需标明是否可能为 null
  • 数组字段禁止返回 null,应返回空数组 []
  • 分页接口的 data 字段即使无数据也应返回 {} 或 []
通过标准化响应结构,前端可减少防御性判断,提升代码健壮性。

4.4 日志记录与调试中识别潜在空指针隐患

在日常开发中,空指针异常是导致服务崩溃的常见原因。通过精细化的日志记录,可以在运行时捕获对象状态,提前暴露未初始化或已释放的引用。
日志辅助排查示例

if (user == null) {
    log.warn("User object is null for userId: {}", userId); // 记录上下文信息
    return Optional.empty();
}
上述代码在访问 user 前进行判空,并输出关键参数 userId,便于追踪源头问题。
推荐的防御性日志策略
  • 在方法入口处记录关键参数是否为 null
  • 调用外部接口返回值后立即验证非空并打点日志
  • 使用 MDC 添加请求上下文,提升日志可追溯性
结合调试断点与条件日志,可有效预防生产环境中的空指针风险。

第五章:总结与展望

技术演进的持续驱动
现代系统架构正加速向云原生和边缘计算融合。以Kubernetes为核心的编排体系已成为微服务部署的事实标准,企业通过声明式配置实现跨环境一致性。例如,某金融平台采用GitOps模式管理500+个微服务实例,部署效率提升60%。
代码即基础设施的实践深化

// 示例:使用Terraform Go SDK动态生成AWS VPC配置
package main

import (
	"github.com/hashicorp/terraform-exec/tfexec"
)

func createNetwork() error {
	// 初始化Terraform工作区
	tf, _ := tfexec.NewTerraform("/path/to/project", "/usr/local/bin/terraform")
	tf.Init()
	
	// 应用网络模块
	vars := map[string]string{"region": "us-west-2"}
	return tf.Apply("-var", fmt.Sprintf("region=%s", vars["region"]))
}
可观测性体系的关键作用
指标类型采集工具典型阈值响应策略
CPU利用率Prometheus Node Exporter>80%自动扩容节点
请求延迟(P99)OpenTelemetry Collector>500ms触发链路追踪分析
未来架构趋势预判
  • Serverless将进一步渗透至数据处理领域,FaaS与流处理引擎深度集成
  • AI驱动的运维决策系统将在异常检测中取代传统规则引擎
  • WebAssembly在边缘运行时的应用将打破语言与平台边界
[客户端] → (API网关) → [认证服务] ↘ [WASM插件引擎] → [后端服务集群]
Kotlin入门-空安全设计 这篇文章我们一起来学习Kotlin空安全的设计 阅读详情

相关推荐

Kotlin中安全处理可空类型的完整指南

Kotlin中可空类型的优雅处理方式 本文系统介绍了Kotlin中处理可空类型的最佳实践。Kotlin通过类型系统明确区分可空和非空类型,有效避免了空指针异常。文章详细讲解了安全调用操作符?.、Elvis操作符?:、智能类型转换等核心语法,以及let、run等作用域函数的应用。同时展示了集合处理、扩展函数创建、密封类等高级用法,并通过实际示例演示了完整的可空类型处理流程。最佳实践包括优先使用安全调用、提供合理默认值、利用编译器智能检查等,帮助开发者编写更安全的Kotlin代码。

dongdeaiziji的专栏 228

【Kotlin空安全终极指南】:彻底告别NullPointerException的5大实战技巧

掌握Kotlin空安全用法,彻底杜绝NullPointerException。涵盖可空类型、非空断言、安全调用等五大实战技巧,适用于Android开发与服务端编程,提升代码稳定性与安全性,值得收藏。

QuickSolve的博客 1126

TI IWR6843AOP雷达+DCA1000EVM数据采集:官方手册里的坑,我帮你踩完了

本文详细解析了TI IWR6843AOP雷达与DCA1000EVM数据采集实战中的12个关键细节,包括硬件连接陷阱、mmWave Studio隐藏设置、数据采集参数优化等,帮助开发者避开官方手册未提及的常见问题,提升数据采集效率和系统稳定性。

weixin_28366475的博客 1103

Kotlin可空类型

Kotlin可空类型 为了避免Null Pointer Exception,java8中,我们可以使用Optional类型来表达可空的类型。 public static void main(String[] args) { System.out.println(strLength(Optional.of("abc"))); System.out.println...

Lud的博客 335

【4. BSP开发指南 - [4.6. 安全启动使用说明]】

【4. BSP开发指南 - [4.6. 安全启动使用说明]】

Sugar_wolf的博客 276

使用R语言获取data.frame中指定列的数据

这里以"df"为例,包含三列数据:“列1”、“列2"和"列3”。通过以上代码,我们成功获取了"列1"和"列3"的数据,并将它们分别存储在了变量"column1"和"column3"中。假设我们有一个名为"df"的data.frame,其中包含了多个列,我们想要提取其中的某一列。符号,我们可以从data.frame中提取出"列2"的数据,并将其赋值给变量"column2"。符号,我们可以轻松提取出data.frame中特定列的数据,并将其存储在变量中供进一步的分析和处理使用。假设我们要获取"列2"的数据。

DevRevolt的博客 2323

Kotlin 空安全完整指南:彻底告别NullPointerException

在日常 Kotlin 开发中,大家或多或少都遇到过 NullPointerException。明明 Kotlin 标榜“空安全”,为什么实际项目里依旧会踩坑?尤其在和 Gson 这类第三方库结合时,经常出现“参数不能为空,却传了 null”的问题。本文将从 Kotlin 的空安全原理讲起,结合真实开发场景,总结常见坑点与最佳实践,帮你彻底告别 NPE。数据类属性尽量定义为可空使用?给默认值: ""避免过度使用!!它会绕过 Kotlin 的保护机制。

wayne214的博客 1156

Docker/Hyper-V/Wsl2等虚拟化组件一键切换工具 (附源码, Docker Desktop开发模式与三角洲游戏模式一键切换工具)

开启 Docker、Hyper-V 或 WSL2 后游戏无法启动?🎮💻 本文教你用一键批处理工具⚡快速切换“开发/游戏模式”,开发娱乐两不误!🔄✨

XiaoqiangClub的博客 703

与Kotlin中的nullpointerexception说再见

As an Android developer, one of the main problems that you must address it is facing with NullPointerException in developing your codes with Java. Although Java has some best practices to encounter to...

weixin_26727575的博客 593

【MERRA-2数据集】M2I1NXASM (5.12.4) 和 M2I1NXINT (5.12.4)概述

M2I1NXASM (5.12.4) 和 M2I1NXINT (5.12.4)概述

WW、forever的博客 686

SAP_SD模块更改销售订单定价简介

方式优点缺点适用场景MASS简单,无需开发不能触发重新定价逻辑修改特定字段BDC (VA02)可模拟人工操作维护复杂,速度慢少量订单批改稳定、安全需ABAP支持推荐用于批量重新定价VBOF标准重算返利仅适返利类条件返利更新通过本文,我们了解了 SAP 的[SAP_SD模块更改销售订单定价]的基本概念和应用方法。希望这些信息能帮助您在实际工作中更好地使用 SAP 系统,提高工作效率和管理水平。更多SAP文章请点击更多SAP文章更新,大家一起学习进步!!!

我小时候很黑的博客 718

《Kotlin入门实战》CH3 | 类型系统与可空类型

类型系统与可空类型 Kotlin属于静态类型编程语言,编程语言中类型系统定义: 如何将数值和表达式归为不同类型 如何操作这些类型 这些类型之间如何相互作用 类型系统 1. 类型系统作用 让编译器检查无意义、无效、类型不匹配的错误代码 代码更好读懂 利于抽象 char[] str = {'a','b','c'}抽象为String str = 'abc'...

落红不是无情物 160

基于SAGE算法的宽带信道参数估计算法的MATLAB仿真

本文将介绍如何使用MATLAB进行SAGE算法的仿真,以便更好地理解和应用该算法。SAGE算法是一种基于最大期望(Expectation-Maximization)方法的迭代估计算法,用于估计未知的参数。在宽带信道参数估计中,SAGE算法通过迭代优化来估计信道的传输函数。总结起来,本文介绍了如何使用MATLAB进行基于SAGE算法的宽带信道参数提取算法的仿真。通过以上步骤,我们可以得到估计的信道响应,并与真实信道响应进行比较。此外,SAGE算法还可以与其他信道估计算法相结合,以提高估计的准确性和性能。

CodeRoarX的博客 1077

【Kotlin学习之旅】Kotlin的null安全

Kotlin的null安全机制通过区分非空类型和可空类型,有效避免了空指针异常。主要特性包括: 使用"?"声明可空类型(如Int?),非空类型不能赋值为null 可空类型需安全调用("?.")或先判空再使用 Elvis运算符(?:)提供简洁的null值处理 结合let函数可实现安全的链式调用 这些机制使Kotlin能在编译期捕获潜在的NPE,提升代码安全性。

字节卷动 5113

YOLOv8改进策略【损失函数篇】| 替换Powerful-IoU(PIoU),增强对中等质量锚框的关注力,引导锚框更直接、高效地回归

现有基于IoU的损失函数存在不合理的惩罚因子,导致锚框在回归过程中出现面积扩大的问题,使得回归效率降低、收敛速度变慢。同时,这些损失函数在反映锚框与目标框之间的差异、考虑目标框大小以及某些情况下的性能表现等方面存在局限性。在目标检测任务中,边界框回归的损失函数对检测性能至关重要。Powerful-IoU(PIoU)及其升级版PIoU v2正是为解决现有损失函数存在的问题而设计的。本文利用PIoU改进YOLOv8的损失函数,提高模型精度。

Limiiiing的博客 676

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Kotlin中变量、常量以及空安全

Kotlin的可空类型 在以往的Java开发中有一个著名的异常NullPointerException,俗称NPE,它由访问为空的属性引发,为此Kotlin中引入了可空类型,旨在有效消除NPE异常的发生。 在定义变量的时候在其类型的后面加上一个?问号表示该变量是可空类型,可以赋予其null值。比如 //定义可空变量,并赋予null值 var a: String? a = null //定...

yumodev 558

深度学习工具包 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")

Kotlin基础学习笔记之第六章——kotlin的类型系统

kotlin学习

liuqinhou的博客 1261

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

Kotlin 可空类型系统的学习

引言 什么是类型?为啥变量拥有类型? “类型就是数据的分类… 决定了该类型可能的值和可以完成的操作。” 那么套用这个定义来分析一下NULL值在类型系统的地位。 比如在java中null是一种数值,但是当一个引用为null的时候,并不可以在这个引用调用该类型的任何方法,这不就意味着java的类型系统在值为NULL的时候不能很好的工作, 甚至当你使用instanceof运算符的时候,它的类型都是N...

Gin.TaMa的博客 276

Kotlin Moshi实战:如何优雅处理后端返回的null值避免NullPointerException

"" // 给null设置默认值) {// 注册适配器.build()优点全局生效,一劳永逸可以针对不同类型定制逻辑缺点需要为每种基础类型创建适配器会覆盖所有String字段的解析行为基于火山引擎豆包大模型,从零搭建一个实时语音通话应用。它不是简单的问答,而是需要你亲手打通 ASR(语音识别)→ LLM(大脑思考)→ TTS(语音合成)的完整 WebSocket 链路。对于想要掌握 AI 原生应用架构的同学来说,这是个绝佳的练手项目。

2600_94960200的博客 372

Kotlin入门系列:第五章 Kotlin的类型系统

文章目录1 可空性1.1 可空类型1.2 安全调用运算符 "?."1.3 Elvis运算符 "?:"1.4 安全转换 "as?"1.5 非空断言 "!!"1.6 let函数 1 可空性 现代编程语言包括Kotlin解决 NullPointerException 问题的方法是把运行时的错误转变为编译期的错误。通过支持作为类型系统的一部分的可空性,编译器就能在编译期发现很多潜在的错误,从而减少运行时抛...

Vincent的博客 1964

Android项目中Kotlin空安全最佳实践(避免崩溃的5个关键步骤)

掌握Kotlin空安全技巧,有效避免Android开发中的崩溃问题。本文结合实际应用场景,详解可空类型、非空断言、安全调用等5个关键实践方法,提升代码稳定性与健壮性。适合Kotlin Android开发人员参考学习,值得收藏。

StepLens的博客 1148

Kotlin中!!用法

在 Kotlin 中,两个!!(也称为 "not-null assertion operator")用于将一个可空类型(nullable type)转换为非空类型(non-null type)。使用!!操作符时,Kotlin 编译器会假定该变量不为 null。如果该变量在运行时为 null,将抛出。

m0_51323460的博客 1403

Kotlin-Null 值安全性

Kotlin 类型系统的设计目标就是希望消除代码中 null 引用带来的危险。 Kotlin 的类型系统致力于从我们的代码中消除 NullPointerException. 只有以下情况可能导致 NPE: 明确调用 throw NullPointerException()使用 !! 操作符, 详情见后文外部的 Java 代码导致这个异常初始化过程中存在某些数据不一致 (在构造器中使

Silk2018的专栏 1945

Kotlin 空安全

许多编程语言(包括 Java)中最常见的陷阱之一,就是访问空引用的成员会导致空引用异常。在 Java 中,这等同于 NullPointerException或简称NPE。

cyclelucky的博客 890

Java开发中避免NullPointerException的全面指南

Java空指针问题防范指南 摘要:Java中的NullPointerException问题源于语言设计缺陷,非基本类型变量允许存储null值且方法可返回null。null值缺乏语义信息,导致开发者需额外判断变量是否可能为null及其具体含义。相比Kotlin等现代语言通过类型系统编码可空性,Java需依赖防御性编程策略:在公共方法入口使用Objects.requireNonNull()验证参数,集合处理遵循"空对象模式"返回空集合而非null,API采用分层验证机制,对特殊类型如Stre

静水深流 225

Jackson Module Kotlin 常见问题解答:从入门到进阶的避坑指南

Jackson Module Kotlin 是一个为 Kotlin 类和数据类提供序列化/反序列化支持的模块,它能帮助开发者轻松处理 JSON 数据与 Kotlin 对象之间的转换。本文将解答使用过程中的常见问题,助你从入门到进阶,避开那些容易踩的坑。 ## 基础配置与依赖相关问题 ### 如何正确引入 Jackson Module Kotlin? 要在项目中使用 Jackson Module

gitblog_00212的博客 672
上一篇: 如何在Swift项目中实现稳定推送?3种场景下的最佳集成方案
下一篇: 别再写冗长的if-else了:用Kotlin密封类实现精准类型控制
SimProceed
博客等级 码龄1年 146粉丝 2011原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值