[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"$f1b300lqgtfmoj":3,"$f250wz8h39yydc":8,"$f3e13fn86h0z0l":29,"$f1tmzc20p7l0cb":37,"$f2sqzc43ex77ie":72,"toc-175741588-5-5":76},{"description":4,"domain":5,"id":6,"keywords":4,"title":7},"","api.kongjs.com",1,"默认",[9,20,24],{"children":10,"icon":4,"id":11,"linkType":12,"linkUrl":13,"parentId":14,"sort":15,"status":16,"target":17,"title":18,"visible":19},null,"447369447469600768","URL","\u002F","0",0,"1","_self","首页",true,{"children":10,"icon":4,"id":21,"linkType":12,"linkUrl":22,"parentId":14,"sort":15,"status":16,"target":17,"title":23,"visible":19},"447369693859794944","\u002Fnotes","笔记",{"children":10,"icon":4,"id":25,"linkType":26,"linkUrl":27,"parentId":14,"sort":15,"status":16,"target":17,"title":28,"visible":19},"447369977960976384","PAGE","\u002Fabout","关于我",{"category":30,"categoryId":31,"cover":10,"description":4,"fileId":10,"id":34,"publishAt":10,"tags":35,"title":36},{"articleCount":10,"children":10,"cover":10,"description":4,"fileId":10,"icon":4,"id":31,"parentId":14,"slug":32,"sort":15,"title":33},"453164732518506496","back-end","后端","453165633773772800",[],"Java面试核心知识",[38,41,44,48,52,56,60,64,68],{"children":10,"description":4,"id":39,"noteId":34,"parentId":14,"sort":15,"status":16,"title":40},"453165775620939776","Java基础核心全集（数据类型、拆箱装箱、克隆、对象结构、字符串、包装类、序列化）",{"children":10,"description":4,"id":42,"noteId":34,"parentId":14,"sort":6,"status":16,"title":43},"453166088570544128","JVM原理（JDK8~25）内存结构、分代模型、GC算法、垃圾收集器、元空间、双亲委派机制",{"children":10,"description":4,"id":45,"noteId":34,"parentId":14,"sort":46,"status":16,"title":47},"453166295265845248",2,"Java8至25 对象创建全过程及各版本底层演进差异",{"children":10,"description":4,"id":49,"noteId":34,"parentId":14,"sort":50,"status":16,"title":51},"453166545573519360",3,"Java集合全套原理（List+Map底层、扩容机制、线程安全集合对比）",{"children":10,"description":4,"id":53,"noteId":34,"parentId":14,"sort":54,"status":16,"title":55},"453166809651093504",4,"Java线程原理、六大状态流转、线程结束判断、安全中断、核心方法区别",{"children":10,"description":4,"id":57,"noteId":34,"parentId":14,"sort":58,"status":16,"title":59},"453167023724175360",5,"Java线程池原理、使用规范、常用并发异步工具类",{"children":10,"description":4,"id":61,"noteId":34,"parentId":14,"sort":62,"status":16,"title":63},"453167209447956480",6,"Java 虚拟线程与平台线程：原理、区别与实战使用",{"children":10,"description":4,"id":65,"noteId":34,"parentId":14,"sort":66,"status":16,"title":67},"453167452423987200",7,"CAS与AQS 底层原理、核心流程、面试最全详解",{"children":10,"description":4,"id":69,"noteId":34,"parentId":14,"sort":70,"status":16,"title":71},"453168570885480448",8,"线上服务器CPU飙升 Java代码 完整定位排查流程",{"content":73,"contentType":74,"description":4,"title":40,"wordCount":75},"# Java基础核心全集（数据类型、拆箱装箱、克隆、对象结构、字符串、包装类、序列化）\n\n本文汇总Java面试**最核心、最容易被问坑**的基础考点：8大基本数据类型范围、拆箱装箱原理、深浅克隆、Java对象内存结构、String\u002F包装类底层区别、序列化原理与避坑点，全覆盖零基础到进阶面试，可直接背诵。\n\n## 一、Java八大基本数据类型（范围\\+占用字节\\+核心考点）\n\n### 1\\. 基本属性汇总\n\n|数据类型|字节|位数|取值范围|默认值|\n|---|---|---|---|---|\n|byte|1|8|\\-128 \\~ 127|0|\n|short|2|16|\\-32768 \\~ 32767|0|\n|int|4|32|\\-2^31 \\~ 2^31\\-1（\\-2147483648 \\~ 2147483647）|0|\n|long|8|64|\\-2^63 \\~ 2^63\\-1|0L|\n|float|4|32|±3\\.4E38|0\\.0f|\n|double|8|64|±1\\.7E308|0\\.0d|\n|char|2|16|0 \\~ 65535（无符号）|\\\\u0000|\n|boolean|1\u002F4（JVM规范）|\\-|true \u002F false|false|\n\n### 2\\. 核心坑点\n\n- **char是无符号类型**，没有负数范围\n\n- **byte最小值\\-128没有对应的正数**，是补码存储特性导致\n\n- 浮点类型**float\u002Fdouble 存在精度丢失**，禁止用于金额计算，金额必须用BigDecimal\n\n- 基本类型存**栈内存**，速度快、无GC；引用类型存堆内存\n\n---\n\n## 二、拆箱与装箱原理（自动装箱\u002F拆箱）\n\n### 1\\. 定义\n\n- **装箱**：基本类型 → 包装类型（自动封装为对象）\n\n- **拆箱**：包装类型 → 基本类型（取出基础数值）\n\n### 2\\. 底层原理（JDK自动语法糖）\n\n编译期自动替换代码，运行无差别：\n\n- 自动装箱：`Integer a = 10` → 编译为 `Integer a = Integer.valueOf(10)`\n\n- 自动拆箱：`int b = a` → 编译为 `int b = a.intValue()`\n\n### 3\\. 包装类缓存机制（面试超级大坑）\n\nInteger、Short、Byte、Long、Char 存在**常量缓存池**\n\n- Integer 缓存范围：**\\-128 \\~ 127**\n\n- 范围内数值：复用缓存对象，`==` 为true\n\n- 超出范围：新建对象，`==` 为false\n\n### 4\\. 经典面试题\n\n```java\nInteger a1 = 100;\nInteger a2 = 100;\nSystem.out.println(a1 == a2); \u002F\u002F true（缓存复用）\n\nInteger b1 = 200;\nInteger b2 = 200;\nSystem.out.println(b1 == b2); \u002F\u002F false（超出缓存，两个新对象）\n\n```\n\n### 5\\. 避坑点\n\n- 包装类比较数值**必须用equals**，禁止==\n\n- 自动装箱拆箱频繁转换会产生大量临时对象，引发GC\n\n- 包装类可存null，基本类型不行，空指针异常高发\n\n---\n\n## 三、Java克隆机制（浅克隆、深克隆）\n\n### 1\\. 克隆前提\n\n对象实现 **Cloneable 接口**，重写 clone\\(\\) 方法\n\n### 2\\. 浅克隆（默认clone）\n\n**基本类型值拷贝，引用类型只拷贝地址**\n\n- 创建新对象\n\n- 基本字段：值复制\n\n- 引用字段：只复制引用地址，新旧对象共享同一个引用对象\n\n- **弊端**：修改引用属性，新旧对象互相影响\n\n### 3\\. 深克隆\n\n**完全独立拷贝，所有层级对象全部新建**\n\n- 基本类型：值拷贝\n\n- 引用类型：递归克隆\u002F新建对象，不共享内存\n\n- 新旧对象**完全独立，互不影响**\n\n### 4\\. 深克隆两种实现方式\n\n1. **递归重写clone**：逐层手动克隆引用属性\n\n2. **序列化深克隆**：对象实现Serializable，序列化再反序列化得到全新对象（开发最常用）\n\n### 5\\. 总结口诀\n\n**浅克隆拷地址、深克隆拷内容**\n\n---\n\n## 四、Java对象内存结构（JDK1\\.8）\n\n一个Java对象在堆中由三部分组成：**对象头、实例数据、对齐填充**\n\n### 1\\. 对象头（核心）\n\n- **MarkWord（标记字）**：8字节（64位）\n        \n\n    - 哈希码、GC分代年龄、锁状态标志、偏向线程ID\n\n    - 实现synchronized偏向锁、轻量级锁、重量级锁核心\n\n- **Class指针**：4字节（指向元空间Class对象）\n\n### 2\\. 实例数据\n\n对象所有成员变量：基本类型\\+引用类型，按顺序内存排布\n\n### 3\\. 对齐填充\n\nJVM规定：**对象大小必须是8字节的整数倍**，不够则补位填充，提升读取效率\n\n### 4\\. 无对象实例（空对象）大小\n\n空对象：16字节（对象头12 \\+ 填充4）\n\n---\n\n## 五、String、基本类型、包装类 核心区别\n\n### 1\\. 基本类型 vs 包装类\n\n|维度|基本类型|包装类|\n|---|---|---|\n|类型|基本值类型|引用对象类型|\n|存储位置|栈|堆|\n|默认值|0、false、\\\\u0000|null|\n|泛型支持|不支持|支持（List\\\u003CInteger\\>）|\n|空值|无null|可null，易空指针|\n\n### 2\\. String 特殊性\n\n- **String是final不可变类**，字符数组不可修改\n\n- 存在**字符串常量池**，复用字符串对象，节省内存\n\n- String赋值修改本质是**新建字符串**，原对象不变\n\n- JDK1\\.8 底层 char\\[\\] → JDK1\\.9\\+ 改为 byte\\[\\]，节省内存\n\n### 3\\. String、StringBuilder、StringBuffer区别\n\n- **String**：不可变，拼接产生新对象，效率低\n\n- **StringBuffer**：可变、线程安全（sync）、效率低\n\n- **StringBuilder**：可变、非线程安全、**效率最高（生产首选）**\n\n---\n\n## 六、Java序列化原理（Serializable）\n\n### 1\\. 序列化定义\n\n**序列化**：Java对象 → 二进制字节流（网络传输、持久化存储）\n\n**反序列化**：二进制字节流 → 还原Java对象\n\n### 2\\. 使用条件\n\n对象必须实现 **Serializable 标记接口**（无方法，仅做标识）\n\n### 3\\. 核心关键字：transient\n\n**被transient修饰的字段不会被序列化**\n\n- 用于临时字段、敏感数据（密码）、不需要传输的字段\n\n- 静态变量属于类，不属于对象，**也不会被序列化**\n\n### 4\\. serialVersionUID 版本号（重要）\n\n序列化版本一致性校验字段\n\n- 不手动声明：JDK自动生成，类结构修改后版本号变更\n\n- 类结构微调后，反序列化**版本号不匹配，直接报错**\n\n- **生产必须手动固定serialVersionUID**，保证版本兼容\n\n### 5\\. 序列化特点与坑点\n\n- 序列化保存的是**对象状态**，不保存方法\n\n- 父类实现序列化，子类自动序列化；子类序列化父类无实现，父类字段丢失\n\n- 反序列化**不会执行构造方法**，直接生成对象\n\n- 存在**反序列化漏洞**，高危场景禁止使用JDK原生序列化\n\n### 6\\. 常用替代方案（生产）\n\n替代JDK序列化：**JSON、Protobuf、Hessian**，更安全、跨语言、体积更小\n\n---\n\n---\n\n## 七、Java四大引用机制（面试高频核心）\n\nJava根据**垃圾回收优先级、存活规则**，将对象引用分为四种：强引用、软引用、弱引用、虚引用。核心作用是**灵活控制对象GC回收时机**，优化内存使用、解决内存泄漏、实现缓存降级。\n\n### 1\\. 强引用（StrongReference）—— 默认引用\n\n#### 核心定义\n\n日常代码中最普通的对象引用，**只要强引用存在，GC永远不会回收对象**。\n\n#### 核心特性\n\n- 默认引用方式：`Object obj = new Object()`\n\n- GC **宁可OOM也不回收强引用对象**\n\n- 对象常驻内存，直至引用断开（置为null）\n\n#### 内存泄漏坑点\n\n集合、静态变量、全局缓存持有强引用，会导致对象无法被GC回收，造成**内存泄漏**。\n\n#### 回收条件\n\n手动置空 `obj = null`\\&\\& 无任何强引用指向对象，下次GC触发回收。\n\n### 2\\. 软引用（SoftReference）—— 内存敏感缓存\n\n#### 核心定义\n\n**内存充足不回收，内存溢出前必回收**，专为内存缓存设计。\n\n#### 核心特性\n\n- JDK提供 `SoftReference` 实现\n\n- 系统内存充足：对象正常存活，不回收\n\n- 系统内存不足、即将OOM：优先回收所有软引用对象\n\n#### 适用场景\n\n**二级缓存、图片缓存、本地临时缓存**，内存够就用，内存不够自动释放，完美规避缓存导致的OOM。\n\n### 3\\. 弱引用（WeakReference）—— 单次GC即回收\n\n#### 核心定义\n\n**只要触发GC，无论内存是否充足，一律回收**，生命周期最短。\n\n#### 核心特性\n\n- JDK提供 `WeakReference` 实现\n\n- 不阻碍对象GC，只要GC线程运行，弱引用对象直接被清理\n\n- 天生用于解决内存泄漏\n\n#### 经典场景\n\n- **WeakHashMap**：线程本地缓存、临时映射，key无强引用自动淘汰\n\n- Handler 内存泄漏解决方案（Activity使用弱引用持有）\n\n- 缓存无关紧要的临时数据\n\n### 4\\. 虚引用（PhantomReference）—— 回收监控\n\n#### 核心定义\n\n**最弱的引用，形同虚设**，无法通过引用获取对象，仅用于监听对象回收状态。\n\n#### 核心特性\n\n- JDK提供 `PhantomReference`，必须配合 `ReferenceQueue`（引用队列）使用\n\n- 没有get方法，无法获取对象实例\n\n- 对象即将被GC回收时，虚引用会被放入队列，用于后置清理\n\n#### 适用场景\n\n**堆外内存回收、资源释放、GC监控、后置清理**（NIO、Netty堆外内存清理核心原理）。\n\n### 5\\. 四大引用GC规则优先级（必背）\n\n**回收优先级从高到低：虚引用 \\> 弱引用 \\> 软引用 \\> 强引用**\n\n- 虚引用：GC必回收，仅做监控\n\n- 弱引用：一次GC就回收\n\n- 软引用：内存不足才回收\n\n- 强引用：永不回收（除非引用断开）\n\n### 6\\. 面试高频对比总结\n\n- **强引用**：默认规则，常驻内存，易内存泄漏\n\n- **软引用**：内存够留存、不够回收，做缓存\n\n- **弱引用**：遇GC就回收，防泄漏、临时缓存\n\n- **虚引用**：不获取对象，只监听回收、清理资源\n\n## 八、全文面试极简背诵总结\n\n- **数据类型**：8大基本类型，char无符号，浮点精度丢失不用做金额计算\n\n- **拆箱装箱**：语法糖，底层valueOf\u002FxxxValue，Integer缓存\\-128\\~127，比较必须用equals\n\n- **克隆**：浅克隆拷地址、深克隆拷内容，序列化可实现深克隆\n\n- **对象结构**：对象头\\+实例数据\\+对齐填充，MarkWord存储锁与GC信息\n\n- **字符串包装类**：包装类是对象可null，String不可变，常量池复用，拼接优先用StringBuilder\n\n- **序列化**：实现Serializable，transient忽略字段，固定版本号保证兼容，反序列化不调构造方法\n\n- **四大引用**：强引用常驻、软引用内存不足回收、弱引用遇GC即回收、虚引用仅监控回收\n\n- **数据类型**：8大基本类型，char无符号，浮点精度丢失不用做金额计算\n\n- **拆箱装箱**：语法糖，底层valueOf\u002FxxxValue，Integer缓存\\-128\\~127，比较必须用equals\n\n- **克隆**：浅克隆拷地址、深克隆拷内容，序列化可实现深克隆\n\n- **对象结构**：对象头\\+实例数据\\+对齐填充，MarkWord存储锁与GC信息\n\n- **字符串包装类**：包装类是对象可null，String不可变，常量池复用，拼接优先用StringBuilder\n\n- **序列化**：实现Serializable，transient忽略字段，固定版本号保证兼容，反序列化不调构造方法","markdown",5493,{"frontmatter":77,"meta":78,"nodes":241},{},{"title":40,"description":79,"toc":80},"本文汇总Java面试最核心、最容易被问坑的基础考点：8大基本数据类型范围、拆箱装箱原理、深浅克隆、Java对象内存结构、String\u002F包装类底层区别、序列化原理与避坑点，全覆盖零基础到进阶面试，可直接背诵。",{"title":4,"searchDepth":58,"depth":58,"links":81},[82,92,110,129,145,158,180,238],{"id":83,"depth":46,"text":84,"children":85},"java-1","一、Java八大基本数据类型（范围+占用字节+核心考点）",[86,89],{"id":87,"depth":50,"text":88},"java-_1","1. 基本属性汇总",{"id":90,"depth":50,"text":91},"java-_2","2. 核心坑点",{"id":4,"depth":46,"text":93,"children":94},"二、拆箱与装箱原理（自动装箱\u002F拆箱）",[95,98,101,104,107],{"id":96,"depth":50,"text":97},"-_1","1. 定义",{"id":99,"depth":50,"text":100},"-_2-jdk","2. 底层原理（JDK自动语法糖）",{"id":102,"depth":50,"text":103},"-_3","3. 包装类缓存机制（面试超级大坑）",{"id":105,"depth":50,"text":106},"-_4","4. 经典面试题",{"id":108,"depth":50,"text":109},"-_5","5. 避坑点",{"id":111,"depth":46,"text":112,"children":113},"java-2","三、Java克隆机制（浅克隆、深克隆）",[114,117,120,123,126],{"id":115,"depth":50,"text":116},"java-_1-1","1. 克隆前提",{"id":118,"depth":50,"text":119},"java-_2-clone","2. 浅克隆（默认clone）",{"id":121,"depth":50,"text":122},"java-_3","3. 深克隆",{"id":124,"depth":50,"text":125},"java-_4","4. 深克隆两种实现方式",{"id":127,"depth":50,"text":128},"java-_5","5. 总结口诀",{"id":130,"depth":46,"text":131,"children":132},"javajdk18","四、Java对象内存结构（JDK1.8）",[133,136,139,142],{"id":134,"depth":50,"text":135},"javajdk18-_1","1. 对象头（核心）",{"id":137,"depth":50,"text":138},"javajdk18-_2","2. 实例数据",{"id":140,"depth":50,"text":141},"javajdk18-_3","3. 对齐填充",{"id":143,"depth":50,"text":144},"javajdk18-_4","4. 无对象实例（空对象）大小",{"id":146,"depth":46,"text":147,"children":148},"string","五、String、基本类型、包装类 核心区别",[149,152,155],{"id":150,"depth":50,"text":151},"string-_1-vs","1. 基本类型 vs 包装类",{"id":153,"depth":50,"text":154},"string-_2-string","2. String 特殊性",{"id":156,"depth":50,"text":157},"string-_3-stringstringbuilderstringbuffer","3. String、StringBuilder、StringBuffer区别",{"id":159,"depth":46,"text":160,"children":161},"javaserializable","六、Java序列化原理（Serializable）",[162,165,168,171,174,177],{"id":163,"depth":50,"text":164},"javaserializable-_1","1. 序列化定义",{"id":166,"depth":50,"text":167},"javaserializable-_2","2. 使用条件",{"id":169,"depth":50,"text":170},"javaserializable-_3-transient","3. 核心关键字：transient",{"id":172,"depth":50,"text":173},"javaserializable-_4-serialversionuid","4. serialVersionUID 版本号（重要）",{"id":175,"depth":50,"text":176},"javaserializable-_5","5. 序列化特点与坑点",{"id":178,"depth":50,"text":179},"javaserializable-_6","6. 常用替代方案（生产）",{"id":181,"depth":46,"text":182,"children":183},"java-3","七、Java四大引用机制（面试高频核心）",[184,200,211,222,232,235],{"id":185,"depth":50,"text":186,"children":187},"java-_1-strongreference","1. 强引用（StrongReference）—— 默认引用",[188,191,194,197],{"id":189,"depth":54,"text":190},"java-_1-strongreference-","核心定义",{"id":192,"depth":54,"text":193},"java-_1-strongreference--1","核心特性",{"id":195,"depth":54,"text":196},"java-_1-strongreference--2","内存泄漏坑点",{"id":198,"depth":54,"text":199},"java-_1-strongreference--3","回收条件",{"id":201,"depth":50,"text":202,"children":203},"java-_2-softreference","2. 软引用（SoftReference）—— 内存敏感缓存",[204,206,208],{"id":205,"depth":54,"text":190},"java-_2-softreference-",{"id":207,"depth":54,"text":193},"java-_2-softreference--1",{"id":209,"depth":54,"text":210},"java-_2-softreference--2","适用场景",{"id":212,"depth":50,"text":213,"children":214},"java-_3-weakreference-gc","3. 弱引用（WeakReference）—— 单次GC即回收",[215,217,219],{"id":216,"depth":54,"text":190},"java-_3-weakreference-gc-",{"id":218,"depth":54,"text":193},"java-_3-weakreference-gc--1",{"id":220,"depth":54,"text":221},"java-_3-weakreference-gc--2","经典场景",{"id":223,"depth":50,"text":224,"children":225},"java-_4-phantomreference","4. 虚引用（PhantomReference）—— 回收监控",[226,228,230],{"id":227,"depth":54,"text":190},"java-_4-phantomreference-",{"id":229,"depth":54,"text":193},"java-_4-phantomreference--1",{"id":231,"depth":54,"text":210},"java-_4-phantomreference--2",{"id":233,"depth":50,"text":234},"java-_5-gc","5. 四大引用GC规则优先级（必背）",{"id":236,"depth":50,"text":237},"java-_6","6. 面试高频对比总结",{"id":239,"depth":46,"text":240},"-1","八、全文面试极简背诵总结",[242,246,255,258,261,415,417,447,450,452,454,468,470,473,495,497,503,523,525,532,534,549,551,553,555,562,564,569,586,588,593,607,609,624,626,631,633,635,641,643,667,669,672,674,681,683,686,688,690,692,763,765,790,792,815,817,819,821,827,833,835,842,844,849,860,862,865,882,884,908,910,917,919,921,923,934,936,939,946,948,965,967,973,975,982,984,986,992,994,1009,1011,1017,1019,1021,1027,1029,1042,1044,1058,1060,1062,1068,1070,1088,1090,1096,1098,1103,1117,1119,1145,1147],[243,244,40],"h1",{"id":245},"java",[247,248,249,250,254],"p",{},"本文汇总Java面试",[251,252,253],"strong",{},"最核心、最容易被问坑","的基础考点：8大基本数据类型范围、拆箱装箱原理、深浅克隆、Java对象内存结构、String\u002F包装类底层区别、序列化原理与避坑点，全覆盖零基础到进阶面试，可直接背诵。",[256,257,84],"h2",{"id":83},[259,260,88],"h3",{"id":87},[262,263,264,286],"table",{},[265,266,267],"thead",{},[268,269,270,274,277,280,283],"tr",{},[271,272,273],"th",{},"数据类型",[271,275,276],{},"字节",[271,278,279],{},"位数",[271,281,282],{},"取值范围",[271,284,285],{},"默认值",[287,288,289,305,321,337,353,368,383,398],"tbody",{},[268,290,291,295,297,300,303],{},[292,293,294],"td",{},"byte",[292,296,16],{},[292,298,299],{},"8",[292,301,302],{},"-128 ~ 127",[292,304,14],{},[268,306,307,310,313,316,319],{},[292,308,309],{},"short",[292,311,312],{},"2",[292,314,315],{},"16",[292,317,318],{},"-32768 ~ 32767",[292,320,14],{},[268,322,323,326,329,332,335],{},[292,324,325],{},"int",[292,327,328],{},"4",[292,330,331],{},"32",[292,333,334],{},"-2^31 ~ 2^31-1（-2147483648 ~ 2147483647）",[292,336,14],{},[268,338,339,342,344,347,350],{},[292,340,341],{},"long",[292,343,299],{},[292,345,346],{},"64",[292,348,349],{},"-2^63 ~ 2^63-1",[292,351,352],{},"0L",[268,354,355,358,360,362,365],{},[292,356,357],{},"float",[292,359,328],{},[292,361,331],{},[292,363,364],{},"±3.4E38",[292,366,367],{},"0.0f",[268,369,370,373,375,377,380],{},[292,371,372],{},"double",[292,374,299],{},[292,376,346],{},[292,378,379],{},"±1.7E308",[292,381,382],{},"0.0d",[268,384,385,388,390,392,395],{},[292,386,387],{},"char",[292,389,312],{},[292,391,315],{},[292,393,394],{},"0 ~ 65535（无符号）",[292,396,397],{},"\\u0000",[268,399,400,403,406,409,412],{},[292,401,402],{},"boolean",[292,404,405],{},"1\u002F4（JVM规范）",[292,407,408],{},"-",[292,410,411],{},"true \u002F false",[292,413,414],{},"false",[259,416,91],{"id":90},[418,419,420,427,433,440],"ul",{},[421,422,423,426],"li",{},[251,424,425],{},"char是无符号类型","，没有负数范围",[421,428,429,432],{},[251,430,431],{},"byte最小值-128没有对应的正数","，是补码存储特性导致",[421,434,435,436,439],{},"浮点类型",[251,437,438],{},"float\u002Fdouble 存在精度丢失","，禁止用于金额计算，金额必须用BigDecimal",[421,441,442,443,446],{},"基本类型存",[251,444,445],{},"栈内存","，速度快、无GC；引用类型存堆内存",[448,449],"hr",{},[256,451,93],{"id":4},[259,453,97],{"id":96},[418,455,456,462],{},[421,457,458,461],{},[251,459,460],{},"装箱","：基本类型 → 包装类型（自动封装为对象）",[421,463,464,467],{},[251,465,466],{},"拆箱","：包装类型 → 基本类型（取出基础数值）",[259,469,100],{"id":99},[247,471,472],{},"编译期自动替换代码，运行无差别：",[418,474,475,486],{},[421,476,477,478,482,483],{},"自动装箱：",[479,480,481],"code",{},"Integer a = 10"," → 编译为 ",[479,484,485],{},"Integer a = Integer.valueOf(10)",[421,487,488,489,482,492],{},"自动拆箱：",[479,490,491],{},"int b = a",[479,493,494],{},"int b = a.intValue()",[259,496,103],{"id":102},[247,498,499,500],{},"Integer、Short、Byte、Long、Char 存在",[251,501,502],{},"常量缓存池",[418,504,505,510,517],{},[421,506,507,508],{},"Integer 缓存范围：",[251,509,302],{},[421,511,512,513,516],{},"范围内数值：复用缓存对象，",[479,514,515],{},"=="," 为true",[421,518,519,520,522],{},"超出范围：新建对象，",[479,521,515],{}," 为false",[259,524,106],{"id":105},[526,527,528],"pre",{"language":245},[479,529,531],{"class":530},"language-java","Integer a1 = 100;\nInteger a2 = 100;\nSystem.out.println(a1 == a2); \u002F\u002F true（缓存复用）\n\nInteger b1 = 200;\nInteger b2 = 200;\nSystem.out.println(b1 == b2); \u002F\u002F false（超出缓存，两个新对象）\n",[259,533,109],{"id":108},[418,535,536,543,546],{},[421,537,538,539,542],{},"包装类比较数值",[251,540,541],{},"必须用equals","，禁止==",[421,544,545],{},"自动装箱拆箱频繁转换会产生大量临时对象，引发GC",[421,547,548],{},"包装类可存null，基本类型不行，空指针异常高发",[448,550],{},[256,552,112],{"id":111},[259,554,116],{"id":115},[247,556,557,558,561],{},"对象实现 ",[251,559,560],{},"Cloneable 接口","，重写 clone() 方法",[259,563,119],{"id":118},[247,565,566],{},[251,567,568],{},"基本类型值拷贝，引用类型只拷贝地址",[418,570,571,574,577,580],{},[421,572,573],{},"创建新对象",[421,575,576],{},"基本字段：值复制",[421,578,579],{},"引用字段：只复制引用地址，新旧对象共享同一个引用对象",[421,581,582,585],{},[251,583,584],{},"弊端","：修改引用属性，新旧对象互相影响",[259,587,122],{"id":121},[247,589,590],{},[251,591,592],{},"完全独立拷贝，所有层级对象全部新建",[418,594,595,598,601],{},[421,596,597],{},"基本类型：值拷贝",[421,599,600],{},"引用类型：递归克隆\u002F新建对象，不共享内存",[421,602,603,604],{},"新旧对象",[251,605,606],{},"完全独立，互不影响",[259,608,125],{"id":124},[610,611,612,618],"ol",{},[421,613,614,617],{},[251,615,616],{},"递归重写clone","：逐层手动克隆引用属性",[421,619,620,623],{},[251,621,622],{},"序列化深克隆","：对象实现Serializable，序列化再反序列化得到全新对象（开发最常用）",[259,625,128],{"id":127},[247,627,628],{},[251,629,630],{},"浅克隆拷地址、深克隆拷内容",[448,632],{},[256,634,131],{"id":130},[247,636,637,638],{},"一个Java对象在堆中由三部分组成：",[251,639,640],{},"对象头、实例数据、对齐填充",[259,642,135],{"id":134},[418,644,645,661],{},[421,646,647,653],{},[247,648,649,652],{},[251,650,651],{},"MarkWord（标记字）","：8字节（64位）",[418,654,655,658],{},[421,656,657],{},"哈希码、GC分代年龄、锁状态标志、偏向线程ID",[421,659,660],{},"实现synchronized偏向锁、轻量级锁、重量级锁核心",[421,662,663,666],{},[251,664,665],{},"Class指针","：4字节（指向元空间Class对象）",[259,668,138],{"id":137},[247,670,671],{},"对象所有成员变量：基本类型+引用类型，按顺序内存排布",[259,673,141],{"id":140},[247,675,676,677,680],{},"JVM规定：",[251,678,679],{},"对象大小必须是8字节的整数倍","，不够则补位填充，提升读取效率",[259,682,144],{"id":143},[247,684,685],{},"空对象：16字节（对象头12 + 填充4）",[448,687],{},[256,689,147],{"id":146},[259,691,151],{"id":150},[262,693,694,707],{},[265,695,696],{},[268,697,698,701,704],{},[271,699,700],{},"维度",[271,702,703],{},"基本类型",[271,705,706],{},"包装类",[287,708,709,720,731,741,752],{},[268,710,711,714,717],{},[292,712,713],{},"类型",[292,715,716],{},"基本值类型",[292,718,719],{},"引用对象类型",[268,721,722,725,728],{},[292,723,724],{},"存储位置",[292,726,727],{},"栈",[292,729,730],{},"堆",[268,732,733,735,738],{},[292,734,285],{},[292,736,737],{},"0、false、\\u0000",[292,739,740],{},"null",[268,742,743,746,749],{},[292,744,745],{},"泛型支持",[292,747,748],{},"不支持",[292,750,751],{},"支持（List\u003CInteger>）",[268,753,754,757,760],{},[292,755,756],{},"空值",[292,758,759],{},"无null",[292,761,762],{},"可null，易空指针",[259,764,154],{"id":153},[418,766,767,773,780,787],{},[421,768,769,772],{},[251,770,771],{},"String是final不可变类","，字符数组不可修改",[421,774,775,776,779],{},"存在",[251,777,778],{},"字符串常量池","，复用字符串对象，节省内存",[421,781,782,783,786],{},"String赋值修改本质是",[251,784,785],{},"新建字符串","，原对象不变",[421,788,789],{},"JDK1.8 底层 char[] → JDK1.9+ 改为 byte[]，节省内存",[259,791,157],{"id":156},[418,793,794,800,806],{},[421,795,796,799],{},[251,797,798],{},"String","：不可变，拼接产生新对象，效率低",[421,801,802,805],{},[251,803,804],{},"StringBuffer","：可变、线程安全（sync）、效率低",[421,807,808,811,812],{},[251,809,810],{},"StringBuilder","：可变、非线程安全、",[251,813,814],{},"效率最高（生产首选）",[448,816],{},[256,818,160],{"id":159},[259,820,164],{"id":163},[247,822,823,826],{},[251,824,825],{},"序列化","：Java对象 → 二进制字节流（网络传输、持久化存储）",[247,828,829,832],{},[251,830,831],{},"反序列化","：二进制字节流 → 还原Java对象",[259,834,167],{"id":166},[247,836,837,838,841],{},"对象必须实现 ",[251,839,840],{},"Serializable 标记接口","（无方法，仅做标识）",[259,843,170],{"id":169},[247,845,846],{},[251,847,848],{},"被transient修饰的字段不会被序列化",[418,850,851,854],{},[421,852,853],{},"用于临时字段、敏感数据（密码）、不需要传输的字段",[421,855,856,857],{},"静态变量属于类，不属于对象，",[251,858,859],{},"也不会被序列化",[259,861,173],{"id":172},[247,863,864],{},"序列化版本一致性校验字段",[418,866,867,870,876],{},[421,868,869],{},"不手动声明：JDK自动生成，类结构修改后版本号变更",[421,871,872,873],{},"类结构微调后，反序列化",[251,874,875],{},"版本号不匹配，直接报错",[421,877,878,881],{},[251,879,880],{},"生产必须手动固定serialVersionUID","，保证版本兼容",[259,883,176],{"id":175},[418,885,886,893,896,902],{},[421,887,888,889,892],{},"序列化保存的是",[251,890,891],{},"对象状态","，不保存方法",[421,894,895],{},"父类实现序列化，子类自动序列化；子类序列化父类无实现，父类字段丢失",[421,897,831,898,901],{},[251,899,900],{},"不会执行构造方法","，直接生成对象",[421,903,775,904,907],{},[251,905,906],{},"反序列化漏洞","，高危场景禁止使用JDK原生序列化",[259,909,179],{"id":178},[247,911,912,913,916],{},"替代JDK序列化：",[251,914,915],{},"JSON、Protobuf、Hessian","，更安全、跨语言、体积更小",[448,918],{},[448,920],{},[256,922,182],{"id":181},[247,924,925,926,929,930,933],{},"Java根据",[251,927,928],{},"垃圾回收优先级、存活规则","，将对象引用分为四种：强引用、软引用、弱引用、虚引用。核心作用是",[251,931,932],{},"灵活控制对象GC回收时机","，优化内存使用、解决内存泄漏、实现缓存降级。",[259,935,186],{"id":185},[937,938,190],"h4",{"id":189},[247,940,941,942,945],{},"日常代码中最普通的对象引用，",[251,943,944],{},"只要强引用存在，GC永远不会回收对象","。",[937,947,193],{"id":192},[418,949,950,956,962],{},[421,951,952,953],{},"默认引用方式：",[479,954,955],{},"Object obj = new Object()",[421,957,958,959],{},"GC ",[251,960,961],{},"宁可OOM也不回收强引用对象",[421,963,964],{},"对象常驻内存，直至引用断开（置为null）",[937,966,196],{"id":195},[247,968,969,970,945],{},"集合、静态变量、全局缓存持有强引用，会导致对象无法被GC回收，造成",[251,971,972],{},"内存泄漏",[937,974,199],{"id":198},[247,976,977,978,981],{},"手动置空 ",[479,979,980],{},"obj = null","&& 无任何强引用指向对象，下次GC触发回收。",[259,983,202],{"id":201},[937,985,190],{"id":205},[247,987,988,991],{},[251,989,990],{},"内存充足不回收，内存溢出前必回收","，专为内存缓存设计。",[937,993,193],{"id":207},[418,995,996,1003,1006],{},[421,997,998,999,1002],{},"JDK提供 ",[479,1000,1001],{},"SoftReference"," 实现",[421,1004,1005],{},"系统内存充足：对象正常存活，不回收",[421,1007,1008],{},"系统内存不足、即将OOM：优先回收所有软引用对象",[937,1010,210],{"id":209},[247,1012,1013,1016],{},[251,1014,1015],{},"二级缓存、图片缓存、本地临时缓存","，内存够就用，内存不够自动释放，完美规避缓存导致的OOM。",[259,1018,213],{"id":212},[937,1020,190],{"id":216},[247,1022,1023,1026],{},[251,1024,1025],{},"只要触发GC，无论内存是否充足，一律回收","，生命周期最短。",[937,1028,193],{"id":218},[418,1030,1031,1036,1039],{},[421,1032,998,1033,1002],{},[479,1034,1035],{},"WeakReference",[421,1037,1038],{},"不阻碍对象GC，只要GC线程运行，弱引用对象直接被清理",[421,1040,1041],{},"天生用于解决内存泄漏",[937,1043,221],{"id":220},[418,1045,1046,1052,1055],{},[421,1047,1048,1051],{},[251,1049,1050],{},"WeakHashMap","：线程本地缓存、临时映射，key无强引用自动淘汰",[421,1053,1054],{},"Handler 内存泄漏解决方案（Activity使用弱引用持有）",[421,1056,1057],{},"缓存无关紧要的临时数据",[259,1059,224],{"id":223},[937,1061,190],{"id":227},[247,1063,1064,1067],{},[251,1065,1066],{},"最弱的引用，形同虚设","，无法通过引用获取对象，仅用于监听对象回收状态。",[937,1069,193],{"id":229},[418,1071,1072,1082,1085],{},[421,1073,998,1074,1077,1078,1081],{},[479,1075,1076],{},"PhantomReference","，必须配合 ",[479,1079,1080],{},"ReferenceQueue","（引用队列）使用",[421,1083,1084],{},"没有get方法，无法获取对象实例",[421,1086,1087],{},"对象即将被GC回收时，虚引用会被放入队列，用于后置清理",[937,1089,210],{"id":231},[247,1091,1092,1095],{},[251,1093,1094],{},"堆外内存回收、资源释放、GC监控、后置清理","（NIO、Netty堆外内存清理核心原理）。",[259,1097,234],{"id":233},[247,1099,1100],{},[251,1101,1102],{},"回收优先级从高到低：虚引用 > 弱引用 > 软引用 > 强引用",[418,1104,1105,1108,1111,1114],{},[421,1106,1107],{},"虚引用：GC必回收，仅做监控",[421,1109,1110],{},"弱引用：一次GC就回收",[421,1112,1113],{},"软引用：内存不足才回收",[421,1115,1116],{},"强引用：永不回收（除非引用断开）",[259,1118,237],{"id":236},[418,1120,1121,1127,1133,1139],{},[421,1122,1123,1126],{},[251,1124,1125],{},"强引用","：默认规则，常驻内存，易内存泄漏",[421,1128,1129,1132],{},[251,1130,1131],{},"软引用","：内存够留存、不够回收，做缓存",[421,1134,1135,1138],{},[251,1136,1137],{},"弱引用","：遇GC就回收，防泄漏、临时缓存",[421,1140,1141,1144],{},[251,1142,1143],{},"虚引用","：不获取对象，只监听回收、清理资源",[256,1146,240],{"id":239},[418,1148,1149,1154,1160,1166,1172,1178,1183,1189,1193,1197,1201,1205,1209],{},[421,1150,1151,1153],{},[251,1152,273],{},"：8大基本类型，char无符号，浮点精度丢失不用做金额计算",[421,1155,1156,1159],{},[251,1157,1158],{},"拆箱装箱","：语法糖，底层valueOf\u002FxxxValue，Integer缓存-128~127，比较必须用equals",[421,1161,1162,1165],{},[251,1163,1164],{},"克隆","：浅克隆拷地址、深克隆拷内容，序列化可实现深克隆",[421,1167,1168,1171],{},[251,1169,1170],{},"对象结构","：对象头+实例数据+对齐填充，MarkWord存储锁与GC信息",[421,1173,1174,1177],{},[251,1175,1176],{},"字符串包装类","：包装类是对象可null，String不可变，常量池复用，拼接优先用StringBuilder",[421,1179,1180,1182],{},[251,1181,825],{},"：实现Serializable，transient忽略字段，固定版本号保证兼容，反序列化不调构造方法",[421,1184,1185,1188],{},[251,1186,1187],{},"四大引用","：强引用常驻、软引用内存不足回收、弱引用遇GC即回收、虚引用仅监控回收",[421,1190,1191,1153],{},[251,1192,273],{},[421,1194,1195,1159],{},[251,1196,1158],{},[421,1198,1199,1165],{},[251,1200,1164],{},[421,1202,1203,1171],{},[251,1204,1170],{},[421,1206,1207,1177],{},[251,1208,1176],{},[421,1210,1211,1182],{},[251,1212,825],{}]