JDK源码阅读——java.lang.Boolean

本文深入介绍了 Java 中 Boolean 类的功能及使用方法,包括布尔值包装、转换操作、常量定义及其实现细节。

Boolean

1.概述

public final class Boolean implements Serializable, Comparable<Boolean>
布尔类将基础类型布尔值包装在一个对象中。一个布尔类型的对象包含一个类型为Boolean的单一字段。
此外,这个类提供了许多方法,可以将布尔值转换为一个字符串和一个字符串到一个布尔值,以及处理布尔值时使用的其他常量和方法。

2.类的UML类图

用Intellij IDEA的UML 插件生成的类图:
这里写图片描述

3.源码解析

public final class Boolean implements java.io.Serializable,
                                      Comparable<Boolean>
{
    public static final Boolean TRUE = new Boolean(true);
    public static final Boolean FALSE = new Boolean(false);
    /**
     * 表示基本类型 boolean 的 Class 对象
     * @since   JDK1.1
     */
    @SuppressWarnings("unchecked")
    public static final Class<Boolean> TYPE = (Class<Boolean>) Class.getPrimitiveClass("boolean");

    private final boolean value;

    /** 
    * 是当对象序列化的时候对象的一个标识
    */
    private static final long serialVersionUID = -3665804199014368530L;

    public Boolean(boolean value) {
        this.value = value;
    }

    public Boolean(String s) {
    // = Boolean(parseBoolean(s))
        this(parseBoolean(s));
    }

    /**
     * 将字符串参数解析为 boolean 值。如果 String 参数不是 
     * null 且在忽略大小写时等于 "true",则返回的 boolean 表示 true 值。
     * 示例:Boolean.parseBoolean("True") 返回 true。
     * 示例:Boolean.parseBoolean("yes") 返回 false。 
     */
    public static boolean parseBoolean(String s) {
    // equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较,不考虑大小写。
        return ((s != null) && s.equalsIgnoreCase("true"));
    }

    public boolean booleanValue() {
        return value;
    }

    public static Boolean valueOf(boolean b) {
    // 三元运算符 如果b是true返回第一个值TRUE,否则,返回第二个值
        return (b ? TRUE : FALSE);
    }


    public static Boolean valueOf(String s) {
        return parseBoolean(s) ? TRUE : FALSE;
    }


    public static String toString(boolean b) {
        return b ? "true" : "false";
    }


    public String toString() {
        return value ? "true" : "false";
    }


    @Override
    public int hashCode() {
        return Boolean.hashCode(value);
    }

    /**
     * 返回一个用于boolean值的哈希代码
     */
    public static int hashCode(boolean value) {
        return value ? 1231 : 1237;
    }

    public boolean equals(Object obj) {
    // 判断 obj 是不是 Boolean类型
        if (obj instanceof Boolean) {
       // booleanValue() 将此 Boolean 对象的值作为基本布尔值返回。
            return value == ((Boolean)obj).booleanValue();
        }
        return false;
    }

    /**
     * 当且仅当以参数命名的系统属性存在,且等于 "true" 字符串时,才返回 true。
     * 通过 getProperty 方法可访问系统属性,此方法由 System 类定义,System.setProperty()。
     * 如果没有以指定名称命名的属性或者指定名称为空或 null,则返回 false。
     */
    public static boolean getBoolean(String name) {
        boolean result = false;
        try {
        // System.getProperty(String key)获取由指定key指示的系统属性,以字符串形式返回
            result = parseBoolean(System.getProperty(name));
        } catch (IllegalArgumentException | NullPointerException e) {
        }
        return result;
    }

    /**
    * 将此 Boolean 实例与其他实例进行比较。 
    */
    public int compareTo(Boolean b) {
        return compare(this.value, b.value);
    }
    public static int compare(boolean x, boolean y) {
    // 如果 x == y 为真就返回0,否则返回(x ? 1 : -1)返回的值
        return (x == y) ? 0 : (x ? 1 : -1);
    }
    public static boolean logicalAnd(boolean a, boolean b) {
        return a && b;
    }
    public static boolean logicalOr(boolean a, boolean b) {
        return a || b;
    }
    public static boolean logicalXor(boolean a, boolean b) {
        return a ^ b;
    }
}
<think>我们正在分析java.lang.String类的源码。根据引用[1]和[5],我们知道String类有多个构造方法,并且String是不可变的。 引用[5]详细解释了String不可变的原因:安全、线程安全、HashCode缓存以及性能(字符串常量池)。 引用[2]展示了一个String对象创建的字节码,其中使用了ldc指令从常量池加载字符串,然后调用String的构造方法。 引用[3]和[4]则提醒我们在类型换时可能出现的ClassCastException,但这不是我们当前关注的重点。 因此,我们将从以下几个方面解析String类的源码1. String的不可变性(由final修饰的char数组实现) 2. 重要字段(value, hash等) 3. 构造方法(重点分析几个典型的) 4. 常用方法(substring, concat, replace等)的实现 5. 字符串常量池(intern方法) 注意:由于Java版本不同,String的实现可能有差异(例如,Java9开始使用byte数组代替char数组以节省空间),但基本思想一致。这里我们以Java8为例。 开始解析:</think>### Java `java.lang.String` 源码解析及内部实现机制 `String` 类是 Java 最核心的不可变字符序列,其设计直接影响 JVM 性能和安全。以下是关键实现机制分析: --- #### 一、底层存储结构(不可变性的基石) ```java // JDK 8 及之前版本(char 数组存储) private final char value[]; // JDK 9+(压缩存储优化) private final byte[] value; private final byte coder; // 0-LATIN1, 1-UTF16 ``` 1. **`final` 修饰**:数组引用不可变,但早期版本可通过反射修改数组内容(需 `setAccessible(true)`)[^5] 2. **JDK 9 压缩优化**: - 纯 ASCII 字符串用 `LATIN1`(1 字节/字符)存储 - 含非 ASCII 字符时自动切为 `UTF16`(2 字节/字符) - 节省 30%~50% 堆内存(实测 `"Hello"` 从 48 字节 → 24 字节)[^5] --- #### 二、构造方法解析(引用[1]) | 构造方法签名 | 作用 | 典型场景 | |--------------|------|----------| | `String()` | 创建空字符串 (`""`) | 默认初始化 | | `String(String original)` | 拷贝字符串 | 防御性编程 | | `String(char[] value)` | char 数组字符串 | 动态构建字符串 | | `String(byte[] bytes, Charset charset)` | 字节数组解码 | 网络传输解码 | | `String(StringBuffer buffer)` | 同步拷贝 | 线程安全换 | **关键实现逻辑**: ```java // String(String original) 源码 public String(String original) { this.value = original.value; // 共享底层数组 this.hash = original.hash; // 复用哈希值 } ``` > 此“拷贝”实为**浅拷贝**,新老字符串共享同一 `char[]`(因不可变性而安全)[^5] --- #### 三、不可变性(Immutability)设计 **实现原理**: 1. 所有修改操作(如 `concat()`、`replace()`)**返回新对象** 2. 内部状态无 `setter` 方法 ```java // substring() 典型实现(JDK8) public String substring(int beginIndex) { return new String(value, beginIndex, subLen); } ``` **不可变性的价值**: - **安全**:防止篡改(如数据库密码、网络主机名)[^5] - **线程安全**:无需同步锁 - **哈希缓存**:首次 `hashCode()` 计算后缓存结果(`private int hash;`) - **常量池优化**:`"A" + "B"` 编译期优化为 `"AB"`(字节码验证见引用[2]) --- #### 四、字符串常量池(String Pool) **堆内存中的特殊区域**,避免重复创建相同字面量: ```java String s1 = "Fly"; // 常量池查找/创建 String s2 = new String("Fly"); // 强制堆中新对象 System.out.println(s1 == s2); // false(引用不同) ``` **内存机制**: 1. 字面量赋值(`String s = "x"`)触发池化 2. `intern()` 方法主动入池 ```java String s3 = new String("Fly").intern(); System.out.println(s1 == s3); // true(指向同一对象) ``` --- #### 五、关键方法实现 1. **`equals()`** :先比较引用,再逐字符比对 ```java public boolean equals(Object anObject) { if (this == anObject) return true; if (anObject instanceof String) { String s = (String)anObject; int n = value.length; if (n == s.value.length) { char v1[] = value; char v2[] = s.value; for (int i = 0; i < n; i++) { if (v1[i] != v2[i]) return false; } return true; } } return false; } ``` 2. **`hashCode()`** :延迟计算并缓存 ```java public int hashCode() { int h = hash; if (h == 0 && value.length > 0) { for (char v : value) { h = 31 * h + v; // 多项式哈希减少碰撞 } hash = h; } return h; } ``` --- #### 六、类型换陷阱(引用[3][4]) **错误示例**: ```java Object obj = 123; String s = (String) obj; // ClassCastException: Integer→String ``` **正确换**: ```java // 安全换路径 String s1 = String.valueOf(obj); // 调用obj.toString() String s2 = obj.toString(); // 需确保非null String s3 = "" + obj; // 编译优化为StringBuilder ``` --- ### 总结:String 设计哲学 | 特性 | 实现手段 | 价值 | |------|----------|------| | 不可变性 | `final char[]` + 无状态修改方法 | 线程安全、哈希缓存 | | 内存优化 | 常量池 + JDK9 压缩存储 | 减少堆内存占用 | | 安全性 | 禁止外部修改内部状态 | 防止敏感数据篡改 | | 性能 | 延迟哈希计算、编译期优化 | 提升运行时效率 | > 通过字节码可验证优化效果(如引用[2]中 `ldc` 指令直接加载常量池对象)[^2]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值