# java.lang 包
# Object类
Object类是 Java 类的共同祖先，我们使用到的 Java 的所有的类都可以说是继承至了Object类。
// 返回当前对象所属的类对象
public final native Class<?> getClass();
// 返回当前对象的哈希值，哈希值往往是作为当前对象的唯一标识
public native int hashCode();
// 判断是否相等，其实是简单地比较两个对象的引用是否相等
// 那么可以引申出，equals() 与 == 的区别
public boolean equals(Object obj) {
return (this == obj);
}
// 将一个类型字符串化，通过我们需要重写这个方法
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
// 这个 clone 方法是实现浅拷贝，使用时会经常需要被重写，改为 public 方法
// 注意，要求被克隆的对象所属的类必须实现 Cloneable 接口
protected native Object clone() throws ClongNotSupportedException;
// 这个方法是对象在被垃圾回收器回收之后执行的清理操作。
// 但是因为这个方法可能会引起 OOM，所以在JDK9版本之后已经废弃，建议使用 java.lang.ref.Cleaner 来代替
protected void finalize() throws Throwable {
}
// 随机唤醒某个具有相同锁的对象，从wait状态进入争夺锁的状态
public final native void notify();
// 唤醒所有具有相同锁的对象，从wait状态进入争夺锁的状态
public final native void notifyAll();
这个类中列出的一些方法都是在Java类中都可以使用到的方法（如果您的 IntelliJ IDEA 中有代码自动提示，您应该能感受到）。除此之外，还要一个重要的方法是下面的wait()方法：
// wait 方法是使调用 wait 方法的线程放弃锁的持有权，并且进入 WAITING 或者 TIMED_WAITING 的状态
// wait 方法应该要调用synchronized一起使用
// wait 线程醒来的条件是：
// 1. 超时
// 2. 被 notify() 或者 notifyAll() 唤醒
// 3. 在其它线程中调用该线程的 interrupt() 方法
// wait 方法持有的锁是当前 wait 所处的上下文的对象。
// 如果 wait 持有的锁和当前上下文的锁不一致，或者 wait 和 notify 的锁也不一致，就会触发 InterruptedException
// 这个方法中并不含有参数，所以是一个永不超时的方法，只有上面的条件 2 或 3 能够唤醒
public final void wait() throws InterruptedException {
wait(0L);
}
// 上面那个方法的实现就是通过下面这个方法，即等待 timeoutMillis 毫秒之后会自动醒来，当然也可以通过上述条件 2 或 3 来唤醒
public final native void wait(long timeoutMillis) throws InterruptedException;
// 除此之外，还可以使用下面这个方法
// 这意味着至少需要等待 timeoutMillis 毫秒，nanos 是一个纳秒级的附加时间，是用来微调 timeoutMillis 参数的（释放锁）
// 内部实现可以参考T hread 类中的 void sleep(long millis, int nanos)方 法
public final void wait(long timeoutMillis, int nanos) throws InterruptedException {
if (timeoutMillis < 0) {
throw new IllegalArgumentException("timeoutMillis value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException("nanosecond timeout value out of range");
}
if (nanos > 0) {
timeoutMillis++;
}
wait(timeoutMillis);
}
上面的代码中我们会发现有一个特点，就是凡是用native修饰符修饰的方法，里面都并没有具体的方法实现内容。要知道，这个类可是所有类的父类，它不是一个抽象类，也不是一个接口，那么它定义的方法怎么可能不去实现呢？
这一切都是通过native来实现。当使用这个修饰符来修饰某个方法时，这就代表着该方法的实现并非通过 Java 语言来实现，即这个一个 Java 调用非 Java 代码的接口。因为 Java 无法直接访问到操作系统的底层（如系统硬件等），所以 Java 就得使用native方法来扩展 Java 程序的功能。
native方法是通过 Java 中的 JNI 实现的，JNI 就是 Java Native Interface 的缩写。从 Java 1.1 版本之后，JNI 就已经成为了 Java 平台的一部分，它允许 Java 代码和其它语言编写的代码进行交互。
# String类
从 JDK9 开始，String 对象不再用char[]的形式存储，而是用名为 value 的byte[]的形式存储。value 中有一个名叫 coder 的标记，这个标记有两个取值，一个是LATIN1，一个是UFT-16。那么，Java 中存储 String 的默认编码就是 LATIN1（即 ISO-8859-1，Latin1 是 ISO-8859-1 的别名）和 UTF-16。
public final class String implements Serializable, Comparable<String>, CharSequence {
// 所以，接下来肯定是实现例如 Serializable 和 Comparable 接口的变量和方法
// 如果禁用了字符串压缩，则其字符串使用会以 UTF-16编码，默认设置为 true
static final boolean COMPACT_STRINGS;
@Native
static final byte LATIN1 = 0;
@Native
static final byte UTF16 = 1;
// 以字节的形式来存储 String 中的 char
// 如果是纯英文字符，就采用压缩存储，一个 byte 代表一个 char
// 如果是汉字字符等，那么汉字可以占用多个 byte，且一个英文字符也将占有两个 byte
@Stable
private final byte[] value;
// 这个标记代表当前字符串的编码：LATIN1(0) 或者 UTF-16(1)
private final byte coder;
// 当前字符串的哈希值，初始值默认为 0
private int hash;
static {
// 默认情况下，JVM 会开启「紧凑字符串」的选项，即 COMPACT_STRINGS 默认为 true
// 如果为 true，那么 String 会有 LATIN1 或者 UTF-16两个选项；如果为 false，则只能使用 UTF-16 形式
COMPACT_STRINGS = true;
}
// 构造一个空字符串
public String() {
this.value = "".value;
this.coder = "".coder;
}
// 构造包含指定字节序列和字符串编码的 String
String(byte[] value, byte coder) {
this.value = value;
this.coder = coder;
}
// 返回 JVM 默认字符集格式的 byte[]
public byte[] getBytes() {
// 通过 coder 来指示 String 到底是 LATIN1 格式还是 UTF-16 格式
return StringCoding.encode(coder(), value);
}
// 返回 charsetName 字符集格式的 byte[]
public byte[] getBytes(String charsetName) throws UnsupportedEncodingException {
if (charsetName == null)
throw new NullPointerException();
return StringCoding.encode(charsetName, coder(), value);
}
// 返回 charset 字符集格式的 byte[]
public byte[] getBytes(Charset charset) {
if (charset == null) throw new NullPointerException();
return StringCoding.encode(charset, coder(), value);
}
// 将 String 内部的字节转换为 char 后返回
// 可以发现，里面实际上调用的还是各自类里的 charAt() 方法
public char charAt(int index) {
if (isLatin1()) {
return StringLatin1.charAt(value, index);
} else {
return StringUTF16.charAt(value, index);
}
}
// 将当前字符串的存储形式转化为 char[] 格式
public char[] toCharArray() {
return isLatin1()
? StringLatin1.toChars(value)
: StringUTF16.toChars(value);
}
// 以下 valueOf 的函数都是将其他类型转换为字符串类型
public static String valueOf(boolean b) {}
public static String valueOf(cchar c) {}
public static String valueOf(int i) {
return Integer.toString(i);
}
// ----------
// 查找子串的下标 index
public int indexOf(String str) {}
// 从前往后搜索，返回在当前「字符序列」中首次遇到 Unicode 符号 ch 时的下标
public int indexOf(int ch) {}
// 返回子串 str 在当前串的第一次出现的位置
public int indexOf(String str, int fromIndex) {}
// 返回子串 str 在当前串最后一次出现的位置
public int lastIndexOf(String str) {}
// 从后往前搜索，返回在当前字符串序列中首次遇到 Unicode 符号 ch 时的下标
public int lastIndexOf(int ch) {}
// 转为小写，本地语言环境
public String toLowerCase() {}
// 转为大小，本地语言环境
public String toUpperCase() {}
// 截取 beginIndex 起始处的字符序列，以 String 的形式返回，即从 beginIndex 开始截取
public String subString(int beginIndex) {}
// 截取 [beginIdex, endIndex) 范围内的字符串
public String subString(int beginIndex, int endIndex) {}
// regex 是正则表达式，所以是把当前 String 与正则表达式匹配的地方切割，返回切割后的子串
public String[] split(String regex) {
return split(regex, 0);
}
// 与上面一样是按照正则表达式切割，但是 limit 限制了切割后返回的子串数量，因为可能有几个子串满足该正则表达式
public String[] split(String regex, int limit) {}
// 使用字符串 replacement 替换首个符合正则表达式 regex 规则的子串
public String replaceFirst(String regex, String replacement) {}
// 使用 replacement 替换符合所有正则表达式 regex 的子串
// 可能有人会好奇，这个方法不是替换字符串的吗？实际上，我们经常输入的首个参数——字符串，也是属于一个正则表达式的范畴
// 例如：replace("abc", "a"); 用到的就是如下这个方法，"abc" 实际上是一个正则表达式
public String replaceAll(String regex, String replacement) {}
// 删掉字符串的首尾「空格字符」
public String trim() {}
// 删除字符串首尾的「空白符」
public String strip() {}
// 拼接子串 elements，中间用 分隔符 delimiter 分隔开
public static String join(CharSequence delimiter, CharSequence... elements) {}
public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements) {}
// 将 str 拼接到字符串的末尾
public String concat(String str) {}
// 判断指定范围内的字符串是否以 prefix 开头，并且是从下标 toffset 开始搜索
public boolean startsWith(String prefix, int toffset) {}
// 直接从 0 处开始搜索
public boolean startWith(String prefix) {}
// 判断字符串是否以 suffix 结尾
public boolean endsWith(String suffix) {}
// 判断字符串是否包含子序列
public boolean contains(CharSequence s) {}
// 判断当前字符串是否与给定的正则表达式 regex 相符
public boolean matches(String regex) {}
// 返回对指定的字符串格式化后的结果
public static String format(String format, Object... args) {}
// 比较两个 String，区分大小写的，返回是否编码方式一致
public int compareTo(String anotherString) {}
// 忽略大小地比较两个 String
public int compareToIgnoreCase(String str) {}
// 比较两个 String 指定的区域是否相同，区分大小写
public boolean regionMatches(int toffest, String other, int ooffsest, int len) {}
// 比较两个 String 的内容是否相等
// 这是一个非常重要的方法，它与 == 有什么区别？
public boolean equals(Object anObject) {}
// 判断字符串是否为空
public boolean isEmpty() {
return value.length == 0;
}
// 如果 String 为空字符串，或者只包含了空白的符号，则返回 true
public boolean isBlank() {}
// 返回 String 中包含的 char 的个数
public int length() {}
// 返回当前字符串重复 count 次后的字符串
public String repeat(int count) {}
// 计算 String 的哈希值，计算公式为：s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]。空串的哈希值为 0。
public int hashCode() {}
public String toString() {}
// 越界检查，检查索引是否符合规范，例如是否会 < 0 || index >= length
static void checkIndex(int index, int length) {}
static void checkOffset(int offset, int length) {}
// 将 String 中的字节拷贝到数组中
void getBytes(byte dst[], int dstBegin, byte coder) {}
// 返回存储 String 内容的 byte 数组
byte[] value() {
return value;
}
}
# AbstractStringBuilder类
它是字符序列的抽象实现，是 StringBuilder 和 StringBuffer 的父类。
// 以字节的形式存储字符序列
byte[] value;
// 表示当前字符序列的编码：LATIN1 或者 UTF16
byte coder;
// 表示当前 ASB 内包含的 char 的数量
int count;
// 构造指定容量 capacity 的 ASB，内容为空
AbstractStringBuilder(int capacity) {
if (String.COMPACT_STRINGS) {
value = new byte[capacity];
coder = String.LATIN1;
} else {
value = StringUTF16.newBytesFor(capacity);
coder = String.UTF16;
}
}
// 向 ASB 末尾添加一个字符序列 s
@Override
public AbstractStringBuilder append(CharSequence s) {}
// 向 ASB 末尾添加一个子序列，该子序列取自字符序列 s 的 [start, end) 范围
@Override
public AbstractStringBuilder append(CharSequence s, int start, int end) {}
// 向 ASB 末尾添加一个 StringBuffer
public AbstractStringBuilder append(StringBuffer sb) {}
// 向 ASB 末尾添加一个 ASB 序列
AbstractStringBuilder append(AbstractStringBuilder asb) {}
// 向 ASB 末尾添加一个字符序列
public AbstractStringBuilder append(char[] str) {}
// 向 ASB 末尾添加一个子序列，该子序列取自字符数组 s 的 [offset, offset+len) 的范围
public AbstractStringBuilder append(char str[], int offset, int len) {}
// 向 ASB 末尾添加一个 Object 值的字符串序列
public AbstractStringBuilder append(Object obj) {}
// 添加一个空字符串：Null
private AbstractStringBuilder appendNull() {}
// 删除 [start, end) 范围内的 char
public AbstractStringBuilder delete(int start, int end) {}
// 删除索引为 index 的 char
public AbstractStringBuilder deleteAt(int index) {}
// 向 ASB 的 dstOffset 索引处插入一个子序列 s
public AbstractStringBuilder insert(int dstOffset, CharSequence s) {}
// 向 ASB 的 dstOffset 索引处插入一个子序列，该子序列取自字符序列 s 的 [start, end) 的范围
public AbstractStringBuilder insert(int dstOffset, CharSequence s, int start, int end) {}
// 用 str 替换 ASB 在 [start, end) 范围内的字符序列
public AbstractStringBuilder replace(int start, int end, String str) {}
// 向 ASB 的 index 索引处插入一个字符串 str
private final void putStringAt(int index, String str) {}
// 求 ASB 在 [start, ∞) 范围内的子串
public String substring(int start) {}
// 求 ASB 在 [start, start+end) 范围内的子串
public String substring(int start, int end) {}
// 返回子串 str 在当前主串 ASB 中第一次出现的位置
public int indexOf(String str) {}
// 返回子串 str 在当前主串 ASB 中第一次出现的位置（从主串 fromIndex 处向后搜索）
public int indexOf(String str, int fromIndex) {}
// 返回子串 str 在当前主串 ASB 中最后一次出现的位置
public int lastIndexOf(String str) {}
// 返回 ASB 内的 index 索引处的 char
@Override
public char CharAt(int index) {}
// 将 ASB[srcBegin, srcEnd) 内的字节批量转化为 char 后存入 dst
public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) {}
// 将 ch 存入 ASB 的 index 索引处
public void setCharAt(int index, char ch) {}
// 返回当前 ASB 的容量（可以容纳的 char 的数量）
public int capacity() {
return value.length >> coder;
}
// 缩减 ASB 的容量以恰好容纳其内容
public void trimToSize() {}
// 扩展 ASB 容量，多出来的部分用 0 填充，且设置 ASB 的长度为 newLength
public void setLength(int newLength) {}
// 逆置 ASB
public AbstractStringBuilder reverse() {}
// 比较两个 ASB 的内容
int compareTo(AbstractStringBuilder another) {}
# StringBuffer类
StringBuffer 是一个线程安全的字符序列，适合多线程下操作大量字符，内部实现为字符数组。其线程安全的原理是涉及到修改 StringBuffer 的操作以及被 synchronized 修饰。
public final class StringBuffer extends AbstractStringBuilder implements Serializable, Comparable<StringBuffer>, CharSequence {
// 调用 toString() 方法来用于存储 ASB 中的字符系列，每次更改 ASB 后都会清理缓存
private transient String toStringCache;
}
# StringBuilder类
StringBuilder 是一个非线程安全的字符序列，适合单线程下的操作大量字符，内部实现为字节数组。
public final class StringBuilder extends AbstractStringBuilder implements Serializable, Comparable<StringBuilder>, CharSequence {
从源码上看，StringBuilder 类相比 StringBuffer 类的区别就是，StringBuffer 基本上都使用了 synchronized 修饰。
# Boolean类
Boolean 类其实就是 boolean 的包装类，其中包含有装箱和拆箱。
// 将 boolean -> Boolean，是默认的装箱行为
public static Boolean valueOf(boolean b) {
return (b ? TRUE : FALSE);
}
// Boolean -> boolean 默认的拆箱行为
public boolean booleanValue() {
return value;
}
# Byte类
Byte 是 byte 的包装类。
public final class Byte extends Number implements Comparable<Byte> {
// byte 最小值
public static final byte MIN_VALUE = -128;
// byte 最大值
public static final byte MAX_VALUE = 127;
// 当前类型所占 bit[位]数
public static final int SIZE = 8;
// 当前类包装的值
private final byte value;
}
# Double类
# Float类
# Short类
# Thread类
public class Thread implements Runnable {
// 线程最小优先级
public static final int MIN_PRIORITY = 1;
// 线程默认优先级
public static final int NORM_PRIORITY = 5;
// 线程最大优先级
public static final int MAX_PRIORITY = 10;
// 线程名称
private volatile String name;
// 当前线程所处的线程组
private ThreadGroup group;
// 线程优先级
private int priority;
// 当前线程是否为守护线程，默认与父线程属性一致
private boolean daemon = false;
// 线程 ID
private final long tid;
// 当前线程将要执行的动作
private Runnable target;
// 返回调用此方法的当前线程
public static native Thread currentThread();
// 启动线程，线程状态从 NEW 进入 RUNNABLE
public synchronized void start() {
}
// 使线程进入 TIMED_WAITING 状态，millis 毫秒后自己醒来（不释放锁）
public static native void sleep(long millis) throws InterruptedException;
// 使 join() 的调用者所在的线程进入 WAITING 状态；直到当前线程死亡之后，再去执行上述调用者线程
public final void join() throws InterruptedException {
}
// 当前线程让出 CPU 时间片，大家重新抢占执行权
public static native void yield();
// 中断线程（只是给线程预设一个标记，不是立即让线程停下来）
public void interrupt() {}
// 当前线程是否仍然存活（没有到达 TERMINATED 状态）
public final native boolean isAlive();
}
* 线程状态标记
*
* ●
* ↓
* NEW
* ↓ ┌→ WAITING
* ↓ | ↓
* RUNNABLE ←-┼→ BLOCKED
* ↓ | ↑
* ↓ └→ TIMED_WAITING
* TERMINATED
*
*
* 6种状态，10个转换：
* -------------------------
* 1.NEW -> RUNNABLE
* 2.RUNNABLE -> TERMINATED
* -------------------------
* 3.RUNNABLE -> BLOCKED
* 4.BLOCKED -> RUNNABLE
* -------------------------
* 5.RUNNABLE -> WAITING
* 6.WAITING -> RUNNABLE
* -------------------------
* 7.RUNNABLE -> TIMED_WAITING
* 8.TIMED_WAITING -> RUNNABLE
* -------------------------
* 9.WAITING -> BLOCKED
* 10.TIMED_WAITING -> BLOCKED
# ThreadLocal类
ThreadLocal 是线程局部缓存，为了线程缓存数据，将数据本地化（脱离共享）。其原理是：
- 每个线程由一个 ThreadLocalMap 属性，本质就是一个 map
- 一个线程对应多个 ThreadLocal，一个 ThreadLocal 对应一个值
- ThreadLocal 不能解决线程同步的问题
# Enum类
# Throwable类
# Error类
# Exception类
# Class类
# ClassLoader类
# Compiler类
# System类
# Package类
# Void类
← 源码笔记目录 java.util 包 →