打开 idea，Ctrl + Shift + F / Shift Shift 输入 String

在IntelliJ IDEA中，Ctrl + Shift + F和Shift + Shift是两个不同的快捷键命令。

首先，Ctrl + Shift + F用于全局查找。这将打开“在路径”对话框，查找整个项目或指定目录中的文本片段。可以使用各种选项来限制搜索范围，包括文件类型、排除文件、大小写敏感等，以帮助您更快地找到所需的文本。

另一方面，Shift + Shift是用于执行各种操作的通用快捷方式。它类似于Windows上的Win + R组合键。当按下Shift + Shift时，将弹出一个快速导航框，可以在其中输入要执行的操作的名称，例如重命名文件、运行配置、调试等。还可以使用它来快速切换到最近打开的文件、类或方法，以及执行其他常见操作。

比如 在 idea中，Ctrl + Shift + F / Ctrl + Shift + R 可以找到整个项目或指定目录中的文本片段用到了 String, 而 Shift + Shift 则是把String作为文件名(String.class)去寻找。

开始

package java.lang;

java.lang是一个包（package）的名称。它是Java平台核心库的一部分，提供了Java基础类和基本数据类型的支持。其中包括许多常用的类，如String、Math、Object等。这些类在Java程序开发时非常有用且经常使用。java.lang包中的所有类都被自动导入到Java源文件中，因此，在Java程序中不需要手动导入这个包。

java.io…

这些类和接口都不属于java.lang包。因此，在使用它们之前，需要在Java文件中通过import语句将它们导入到程序中, 之后类就可以使用以上所列出的类和接口了。

public final class String implements java.io.Serializable, Comparable, CharSequence {

public final class String 表示这是一个不可继承的类，因为它使用了 final 关键字。
String 类实现了 java.io.Serializable 接口，这意味着该类可以被序列化和反序列化。
String 类实现了 Comparable 接口，说明该类的对象可以进行比较。
最后，String 类实现了 CharSequence 接口，这是一个字符序列接口，表示该类的实例是字符序列。

CharSequence 接口定义了操作字符集合的通用方法，包括获取长度、获取字符、截取子序列等。通过实现 CharSequence 接口，String 类获得了许多有用的字符串操作方法。

总之，String 类是Java中最常用的类之一，它提供了大量的字符串操作方法，使得在Java程序中处理文本变得更加容易而方便。

private final char value[];

private final char value[]是Java中实例变量的声明方式，表示一个不可变字符数组。其中，private关键字表示该变量仅在类内部可见；final关键字表示变量值一旦被初始化就不能被修改；而char value[]则声明了一个名为value的字符数组。

private int hash; // Default to 0

声明了一个名为hash的私有整数变量，并将其默认值设置为0。这意味着，如果在没有显式地为hash变量赋值的情况下使用它，它将具有默认值0。

private static final long serialVersionUID = -6849794470754667710L;

声明了一个名为serialVersionUID的私有静态长整型变量，并将其值设置为-6849794470754667710L。

在Java中，serialVersionUID是用于版本控制的机制之一。当类被序列化时，它会自动计算serialVersionUID的值。如果没有明确地声明serialVersionUID，则编译器会根据类的成员生成一个默认值。但是，如果在以后修改了类的成员，这种默认值就不能保证唯一性和一致性，可能会导致反序列化失败。

因此，通过显式地声明serialVersionUID，可以确保每个类都有唯一的标识符，并且在对类进行重构时能够保持向后兼容性。在这里，设置serialVersionUID的值为-6849794470754667710L可以帮助确保序列化和反序列化操作的正确性。

在不同的 Java 版本之间，可能会有一些变化，比如新增或删除某些字段，而这些变化可能导致旧版的类与新版的类不兼容。通过设置serialVersionUID，可以在多个 Java 版本之间保持类的版本兼容性。

private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];

这段代码是一个类的成员变量，它声明了一个类型为ObjectStreamField数组的私有静态常量serialPersistentFields并将其初始化为空数组。

在Java中，ObjectOutputStream和ObjectInputStream类用于实现对象的序列化和反序列化。在序列化过程中，需要确定哪些字段需要被序列化以及它们的顺序，这些信息都包含在ObjectStreamField对象中。使用serialPersistentFields数组可以指定哪些字段应该被序列化，并且通过改变数组的元素来控制序列化的版本兼容性。

这段代码的注释说明了字符串类型在序列化机制中的特殊处理方式，而空数组的初始化意味着该类没有定义任何需要持久化的字段。也就是说，如果该类的对象需要被序列化，只会保存该对象的数据本身，而不是由该类定义的任何状态信息。

public boolean java.lang.String.equals(java.lang.Object)

String 类的一个重载方法，用于比较字符串是否相等。

它接受一个参数 Object，该参数将被转换为 String 类型并与当前字符串进行比较。如果参数不是 String 类型，则返回 false。如果参数是 String 类型但与当前字符串不相等，则返回 false。否则，返回 true。

@Testpublic void testEquals() {String str1 = "hello";String str2 = "world";String str3 = "hello";Object obj = new Object();// 测试两个字符串相等的情况assertTrue(str1.equals(str1));assertFalse(str1.equals(str2));assertTrue(str1.equals(str3));// 测试与非 String 类型比较的情况assertFalse(str1.equals(obj));}

public java.lang.String java.lang.String.toString()

String 类的一个重载方法，用于返回当前字符串对象本身。

因为 String 类已经重写了 Object 类中的 toString() 方法，所以该方法直接返回当前字符串对象本身，而不是像 Object 类中的 toString() 方法一样返回包含类名和哈希码的字符串。

@Testpublic void testToString() {String str = "hello world";// 测试 toString() 方法返回本身的情况assertEquals(str.toString(), str);}

public int java.lang.String.hashCode()

String 类的一个重载方法，用于返回当前字符串对象的哈希码。

该哈希码可以作为哈希表中键的值，以加快查找字符串的速度。String 类中使用了一种称为 MurmurHash3 的哈希算法来计算哈希码。

@Testpublic void testHashCode() {String str1 = "hello world";String str2 = "HELLO WORLD";// 测试相同字符串的哈希码是否相等的情况assertEquals(str1.hashCode(), str1.hashCode());// 测试不同大小写字符串的哈希码是否不同的情况assertNotEquals(str1.hashCode(), str2.hashCode());}

public int java.lang.String.compareTo(java.lang.String)

String 类的一个重载方法，用于比较当前字符串对象与另一个字符串对象的大小关系。

该方法返回一个整数，表示两个字符串之间的大小关系。如果当前字符串小于另一个字符串，则返回一个负整数；如果当前字符串大于另一个字符串，则返回一个正整数；如果两个字符串相等，则返回零。

@Testpublic void testCompareTo() {String str1 = "hello";String str2 = "world";String str3 = "hello";String str4 = "HELLO";// 测试相同字符串的大小关系assertEquals(str1.compareTo(str1), 0);assertEquals(str1.compareTo(str3), 0);// 测试不同字符串的大小关系assertTrue(str1.compareTo(str2) < 0);assertTrue(str2.compareTo(str1) > 0);// 测试大小写敏感的字符串的大小关系assertTrue(str1.compareTo(str4) > 0);assertTrue(str4.compareTo(str1) < 0);}

public int java.lang.String.compareTo(java.lang.Object)

String 类的一个重载方法，用于比较当前字符串对象与另一个对象的大小关系。

如果参数不是 String 类型，则会抛出 ClassCastException 异常。否则，该方法会将参数转换为 String 类型，并调用 compareTo(String) 方法来进行比较。

@Testpublic void testCompareTo() {String str1 = "hello";String str2 = "world";Object obj = new Object();// 测试与非 String 类型比较的情况try {// str1.compareTo(obj); // java: 不兼容的类型: java.lang.Object无法转换为java.lang.String} catch (ClassCastException e) {// expected exception}// 测试与 String 类型比较的情况assertTrue(str1.compareTo(str2) < 0);}

public int java.lang.String.indexOf(java.lang.String,int)

String 类的一个重载方法，用于返回指定子字符串在当前字符串中第一次出现的位置。

该方法接受两个参数：要搜索的子字符串和开始搜索的索引。它从指定的索引处开始搜索，并返回子字符串在当前字符串中第一次出现的位置。如果找不到子字符串，则返回 -1。

@Testpublic void testIndexOf() {String str1 = "hello world";String str2 = "world";String str3 = "l";String str4 = "x";// 测试找到子字符串的情况assertEquals(str1.indexOf(str2), 6);// 测试找到字符的情况assertEquals(str1.indexOf(str3), 2);// 测试未找到子字符串或字符的情况assertEquals(str1.indexOf(str4), -1);assertEquals(str1.indexOf(str2, 7), -1);}

public int java.lang.String.indexOf(java.lang.String)

String 类的一个重载方法，用于返回指定子字符串在当前字符串中第一次出现的位置。

该方法接受一个参数：要搜索的子字符串。它从字符串的开头开始搜索，并返回子字符串在当前字符串中第一次出现的位置。如果找不到子字符串，则返回 -1。

@Testpublic void testIndexOf() {String str1 = "hello world";String str2 = "world";String str3 = "l";String str4 = "x";// 测试找到子字符串的情况assertEquals(str1.indexOf(str2), 6);// 测试找到字符的情况assertEquals(str1.indexOf(str3), 2);// 测试未找到子字符串或字符的情况assertEquals(str1.indexOf(str4), -1);}

public int java.lang.String.indexOf(int,int)

String 类的一个重载方法，用于返回指定字符在当前字符串中第一次出现的位置。

该方法接受两个参数：要搜索的字符和开始搜索的索引。它从指定的索引处开始搜索，并返回字符在当前字符串中第一次出现的位置。如果找不到字符，则返回 -1。

@Testpublic void testIndexOf() {String str1 = "hello world";char c1 = 'w';char c2 = 'l';char c3 = 'x';// 测试找到字符的情况assertEquals(str1.indexOf(c1), 6);// 测试找到字符的情况assertEquals(str1.indexOf(c2), 2);// 测试未找到字符的情况assertEquals(str1.indexOf(c3), -1);assertEquals(str1.indexOf(c1, 7), -1);}

public int java.lang.String.indexOf(int)

String 类的一个重载方法，用于返回指定字符在当前字符串中第一次出现的位置。

该方法接受一个参数：要搜索的字符。它从字符串的开头开始搜索，并返回字符在当前字符串中第一次出现的位置。如果找不到字符，则返回 -1。

@Testpublic void testIndexOf() {String str1 = "hello world";char c1 = 'w';char c2 = 'l';char c3 = 'x';// 测试找到字符的情况assertEquals(str1.indexOf(c1), 6);// 测试找到字符的情况assertEquals(str1.indexOf(c2), 2);// 测试未找到字符的情况assertEquals(str1.indexOf(c3), -1);}

public static java.lang.String java.lang.String.valueOf(int)

这是Java中的一个静态方法，它将一个int类型的值转换为一个字符串。

@Test
public void testValueOfIntToString() {int number = 123;String result = String.valueOf(number);assertEquals("123", result);
}

public static java.lang.String java.lang.String.valueOf(long)

这是Java中的一个静态方法，它将一个long类型的值转换为一个字符串。

@Test
public void testValueOfLongToString() {long number = 123456789L;String result = String.valueOf(number);assertEquals("123456789", result);
}

public static java.lang.String java.lang.String.valueOf(float)

这是Java中的一个静态方法，它将一个float类型的值转换为一个字符串。

@Test
public void testValueOfFloatToString() {float number = 3.14f;String result = String.valueOf(number);assertEquals("3.14", result);
}

public static java.lang.String java.lang.String.valueOf(boolean)

这是Java中的一个静态方法，它将一个boolean类型的值转换为一个字符串。

@Test
public void testValueOfBooleanToString() {boolean flag = true;String result = String.valueOf(flag);assertEquals("true", result);
}

public static java.lang.String java.lang.String.valueOf(char[])

这是Java中的一个静态方法，它将一个char数组转换为一个字符串。

@Test
public void testValueOfCharArrayToString() {char[] chars = {'h', 'e', 'l', 'l', 'o'};String result = String.valueOf(chars);assertEquals("hello", result);
}

public static java.lang.String java.lang.String.valueOf(char[],int,int)

这是Java中的一个静态方法，它将一个char数组的一部分转换为一个字符串。

该方法有三个参数：第一个参数是要转换的字符数组，第二个参数是开始位置（包括），第三个参数是结束位置（不包括）。

@Test
public void testValueOfCharArrayRangeToString() {char[] chars = {'h', 'e', 'l', 'l', 'o'};String result = String.valueOf(chars, 1, 4);assertEquals("ell", result);
}

public static java.lang.String java.lang.String.valueOf(java.lang.Object)

这是Java中的一个静态方法，它将一个Object类型的值转换为一个字符串。如果该对象为null，则返回字符串"null"。

@Test
public void testValueOfObjectToString() {Integer number = 123;String result = String.valueOf(number);assertEquals("123", result);Object obj = null;String nullResult = String.valueOf(obj);assertEquals("null", nullResult);
}

public static java.lang.String java.lang.String.valueOf(char)

这是Java中的一个静态方法，它将一个char类型的值转换为一个字符串。

@Test
public void testValueOfCharToString() {char c = 'a';String result = String.valueOf(c);assertEquals("a", result);
}

public static java.lang.String java.lang.String.valueOf(double)

这是Java中的一个静态方法，它将一个double类型的值转换为一个字符串。

@Test
public void testValueOfDoubleToString() {double number = 3.1415926;String result = String.valueOf(number);assertEquals("3.1415926", result);
}

public char java.lang.String.charAt(int)

public char java.lang.String.charAt(int) 是一个方法，用于返回指定索引处的字符。其中参数 int 表示要返回的字符的索引位置，第一个字符的索引为 0。

以下是一个使用 JUnit 进行单元测试的例子：

    @Testpublic void testCharAt() {String str = "Hello World";assertEquals('H', str.charAt(0));assertEquals('o', str.charAt(4));assertEquals('l', str.charAt(9));}

这个例子首先创建了一个字符串，然后对其调用 charAt() 方法，并使用 assertEquals() 来断言实际返回值与预期值是否相同。最后的测试结果应该是通过的。

public int java.lang.String.codePointAt(int)

public int java.lang.String.codePointAt(int) 是一个方法，用于返回字符串中指定位置的 Unicode 代码点。其中参数 int 表示要返回其代码点的字符的索引位置。

以下是一个使用 JUnit 进行单元测试的例子：

    @Testpublic void testCodePointAt() {String str = "Hello World";assertEquals(72, str.codePointAt(0)); // HassertEquals(111, str.codePointAt(4)); // oassertEquals(119, str.codePointAt(9)); // w}

这个例子首先创建了一个字符串，然后对其调用 codePointAt() 方法，并使用 assertEquals() 来断言实际返回的代码点与预期值是否相同。最后的测试结果应该是通过的。

public int java.lang.String.codePointBefore(int)

public int java.lang.String.codePointBefore(int) 是一个方法，用于返回字符串中指定位置前一个字符的 Unicode 代码点。其中参数 int 表示要返回其代码点的字符的索引位置。

以下是一个使用 JUnit 进行单元测试的例子：

@Testpublic void testCodePointBefore() {String str = "Hello World";assertEquals(108, str.codePointBefore(6)); // lassertEquals(111, str.codePointBefore(5)); // oassertEquals(87, str.codePointBefore(6));  // W}

这个例子首先创建了一个字符串，然后对其调用 codePointBefore() 方法，并使用 assertEquals() 来断言实际返回的代码点与预期值是否相同。最后的测试结果应该是通过的。

public int java.lang.String.codePointCount(int,int)

public int java.lang.String.codePointCount(int,int) 是一个方法，用于返回字符串中从指定起始位置到指定终止位置之间的 Unicode 代码点数量。其中参数 int 表示要计数的字符的起始和终止索引位置。

以下是一个使用 JUnit 进行单元测试的例子：

    @Testpublic void testCodePointCount() {String str = "Hello World";assertEquals(5, str.codePointCount(0, 5));   // H e l l oassertEquals(6, str.codePointCount(1, 7));   // e l l o  assertEquals(2, str.codePointCount(5, 7));   // _W o r l d}

这个例子首先创建了一个字符串，然后对其调用 codePointCount() 方法，并使用 assertEquals() 来断言实际返回的代码点数量与预期值是否相同。最后的测试结果应该是通过的。

public int java.lang.String.compareToIgnoreCase(java.lang.String)

public int java.lang.String.compareToIgnoreCase(java.lang.String) 是一个方法，用于比较字符串与指定对象（忽略大小写）的顺序。如果该字符串小于、等于或大于指定对象，则分别返回负整数、零或正整数。

以下是一个使用 JUnit 进行单元测试的例子：

@Testpublic void testCompareToIgnoreCase() {String str1 = "hello world";String str2 = "Hello World";String str3 = "HELLO WORLD";assertTrue(str1.compareToIgnoreCase(str2) == 0);assertTrue(str1.compareToIgnoreCase(str3) == 0);assertFalse(str1.compareToIgnoreCase("Hello") == 0);}

这个例子首先创建了三个字符串，其中 str1 和 str2 相等（忽略大小写），而 str1 和 str3 也相等（忽略大小写）。然后对 compareToIgnoreCase() 方法进行测试，并使用 assertTrue() 和 assertFalse() 来断言实际返回值是否符合预期。最后的测试结果应该是通过的。

public java.lang.String java.lang.String.concat(java.lang.String)

public java.lang.String java.lang.String.concat(java.lang.String) 是一个方法，用于将指定的字符串连接到此字符串的末尾。

以下是一个使用 JUnit 进行单元测试的例子：

@Testpublic void testConcat() {String str1 = "Hello";String str2 = " World";String result = str1.concat(str2);assertEquals("Hello World", result);}

这个例子首先创建了两个分别为 “Hello” 和 " World" 的字符串。然后对 concat() 方法进行测试，并使用 assertEquals() 来断言实际返回值是否与预期相同。最后的测试结果应该是通过的。

public boolean java.lang.String.contains(java.lang.CharSequence)

public java.lang.String java.lang.String.concat(java.lang.String) 是一个方法，用于将指定的字符串连接到此字符串的末尾。

以下是一个使用 JUnit 进行单元测试的例子：

    @Testpublic void testConcat() {String str1 = "Hello";String str2 = " World";String result = str1.concat(str2);assertEquals("Hello World", result);}

这个例子首先创建了两个分别为 “Hello” 和 " World" 的字符串。然后对 concat() 方法进行测试，并使用 assertEquals() 来断言实际返回值是否与预期相同。最后的测试结果应该是通过的。

public boolean java.lang.String.contentEquals(java.lang.CharSequence)

public boolean java.lang.String.contentEquals(java.lang.CharSequence) 是一个方法，用于比较此字符串与指定的字符序列是否相等。

以下是一个使用 JUnit 进行单元测试的例子：

    @Testpublic void testContentEquals() {String str = "Hello World";CharSequence seq1 = new StringBuilder("Hello World");CharSequence seq2 = new StringBuffer("Hello World");CharSequence seq3 = new StringBuilder("Hello Java");assertTrue(str.contentEquals(seq1));assertTrue(str.contentEquals(seq2));assertFalse(str.contentEquals(seq3));}

这个例子首先创建了一个字符串为 “Hello World”，以及三个不同类型的字符序列。然后对 contentEquals() 方法进行测试，并使用 assertTrue() 和 assertFalse() 来断言实际返回值是否符合预期。最后的测试结果应该是通过的。

public boolean java.lang.String.contentEquals(java.lang.StringBuffer)

public boolean java.lang.String.contentEquals(java.lang.StringBuffer) 是一个方法，用于比较此字符串与指定的 StringBuffer 对象是否相等。

以下是一个使用 JUnit 进行单元测试的例子：

    @Testpublic void testContentEquals() {String str = "Hello World";StringBuffer buffer1 = new StringBuffer("Hello World");StringBuffer buffer2 = new StringBuffer("Hello Java");assertTrue(str.contentEquals(buffer1));assertFalse(str.contentEquals(buffer2));}

这个例子首先创建了一个字符串为 “Hello World”，以及两个不同内容的 StringBuffer 对象。然后对 contentEquals() 方法进行测试，并使用 assertTrue() 和 assertFalse() 来断言实际返回值是否符合预期。最后的测试结果应该是通过的。

public static java.lang.String java.lang.String.copyValueOf(char[])

public static java.lang.String java.lang.String.copyValueOf(char[]) 是一个静态方法，用于返回指定字符数组的内容作为新字符串。

以下是一个使用 JUnit 进行单元测试的例子：

@Testpublic void testCopyValueOf() {char[] arr = {'H', 'e', 'l', 'l', 'o'};String str = String.copyValueOf(arr);assertEquals("Hello", str);}

这个例子首先创建了一个包含字符 ‘H’, ‘e’, ‘l’, ‘l’, ‘o’ 的数组。然后对 copyValueOf() 方法进行测试，并使用 assertEquals() 来断言实际返回值是否与预期相同。最后的测试结果应该是通过的。

public static java.lang.String java.lang.String.copyValueOf(char[],int,int)

public static java.lang.String java.lang.String.copyValueOf(char[],int,int) 是一个静态方法，用于返回指定字符数组中从指定位置开始的指定长度的内容作为新字符串。

以下是一个使用 JUnit 进行单元测试的例子：

    @Testpublic void testCopyValueOf() {char[] arr = {'H', 'e', 'l', 'l', 'o'};String str = String.copyValueOf(arr, 1, 3);assertEquals("ell", str);}

这个例子首先创建了一个包含字符 ‘H’, ‘e’, ‘l’, ‘l’, ‘o’ 的数组。然后对 copyValueOf() 方法进行测试，并使用 assertEquals() 来断言实际返回值是否与预期相同。该方法从索引位置 1（即字母 “e”）开始，提取 3 个字符，因此返回的字符串应该是 “ell”。最后的测试结果应该是通过的。

public boolean java.lang.String.endsWith(java.lang.String)

public static java.lang.String java.lang.String.copyValueOf(char[],int,int) 是一个静态方法，用于返回指定字符数组中从指定位置开始的指定长度的内容作为新字符串。

以下是一个使用 JUnit 进行单元测试的例子：

@Testpublic void testCopyValueOf() {char[] arr = {'H', 'e', 'l', 'l', 'o'};String str = String.copyValueOf(arr, 1, 3);assertEquals("ell", str);}

这个例子首先创建了一个包含字符 ‘H’, ‘e’, ‘l’, ‘l’, ‘o’ 的数组。然后对 copyValueOf() 方法进行测试，并使用 assertEquals() 来断言实际返回值是否与预期相同。该方法从索引位置 1（即字母 “e”）开始，提取 3 个字符，因此返回的字符串应该是 “ell”。最后的测试结果应该是通过的。

public boolean java.lang.String.equalsIgnoreCase(java.lang.String)

public boolean java.lang.String.equalsIgnoreCase(java.lang.String) 是一个方法，用于比较此字符串与指定字符串是否相等（忽略大小写）。

以下是一个使用 JUnit 进行单元测试的例子：

@Testpublic void testEqualsIgnoreCase() {String str1 = "Hello World";String str2 = "hello world";String str3 = "HELLO WORLD";assertTrue(str1.equalsIgnoreCase(str2));assertTrue(str1.equalsIgnoreCase(str3));assertFalse(str1.equalsIgnoreCase("Hello"));}

这个例子首先创建了三个字符串，其中 str1 与 str2 和 str3 相等（忽略大小写）。然后对 equalsIgnoreCase() 方法进行测试，并使用 assertTrue() 和 assertFalse() 来断言实际返回值是否符合预期。最后的测试结果应该是通过的。

public static java.lang.String java.lang.String.format(java.util.Locale,java.lang.String,java.lang.Object[])

public boolean java.lang.String.equalsIgnoreCase(java.lang.String) 是一个方法，用于比较此字符串与指定字符串是否相等（忽略大小写）。

以下是一个使用 JUnit 进行单元测试的例子：

@Testpublic void testEqualsIgnoreCase() {String str1 = "Hello World";String str2 = "hello world";String str3 = "HELLO WORLD";assertTrue(str1.equalsIgnoreCase(str2));assertTrue(str1.equalsIgnoreCase(str3));assertFalse(str1.equalsIgnoreCase("Hello"));}

这个例子首先创建了三个字符串，其中 str1 与 str2 和 str3 相等（忽略大小写）。然后对 equalsIgnoreCase() 方法进行测试，并使用 assertTrue() 和 assertFalse() 来断言实际返回值是否符合预期。最后的测试结果应该是通过的。

public static java.lang.String java.lang.String.format(java.lang.String,java.lang.Object[])

public static java.lang.String java.lang.String.format(java.lang.String,java.lang.Object[]) 是一个静态方法，用于使用指定的格式字符串和参数返回格式化的字符串。

以下是一个使用 JUnit 进行单元测试的例子：

    @Testpublic void testFormat() {int intValue = 10;double doubleValue = 3.14;String str = String.format("value is %d, doubleValue is %.2f", intValue, doubleValue);assertEquals("value is 10, doubleValue is 3.14", str);}

这个例子首先创建了两个变量 intValue 和 doubleValue 分别为整数 10 和浮点数 3.14。然后对 format() 方法进行测试，并使用 assertEquals() 来断言实际返回值是否与预期相同。该方法使用了格式化字符串，其中 %d 表示整数，%.2f 表示带有 2 位小数的浮点数。最后的测试结果应该是通过的。

public void java.lang.String.getBytes(int,int,byte[],int)

public void java.lang.String.getBytes(int,int,byte[],int) 是一个方法，将此字符串的子串转换为字节数组，并将结果存储到指定的 byte 数组中。

以下是一个使用 JUnit 进行单元测试的例子：

    @Testpublic void testGetBytes() {String str = "Hello World";byte[] bytes = new byte[5];str.getBytes(6, 11, bytes, 0);byte[] expected = {'W', 'o', 'r', 'l', 'd'};assertArrayEquals(expected, bytes);}

这个例子首先创建了一个字符串 str，并创建了一个长度为 5 的 byte 数组。然后对 getBytes() 方法进行测试，提取从索引位置 6 到 11 的子串，并将其存储在指定的 byte 数组中。使用 assertArrayEquals() 来断言实际返回值是否与预期相同。最后的测试结果应该是通过的。

public byte[] java.lang.String.getBytes(java.nio.charset.Charset)

public byte[] java.lang.String.getBytes(java.nio.charset.Charset) 是一个方法，将此字符串编码为指定的字符集并将其转换为字节数组。

以下是一个使用 JUnit 进行单元测试的例子：

@Testpublic void testGetBytes() {String str = "Hello World";Charset charset = StandardCharsets.UTF_8;byte[] bytes = str.getBytes(charset);byte[] expected = {72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100};assertArrayEquals(expected, bytes);}

这个例子首先创建了一个字符串 str 和一个 Charset 对象，这里使用了 UTF-8 编码。然后对 getBytes() 方法进行测试，将字符串以指定的字符集编码成字节数组，并使用 assertArrayEquals() 来断言实际返回值是否与预期相同。最后的测试结果应该是通过的。

public byte[] java.lang.String.getBytes(java.lang.String) throws java.io.UnsupportedEncodingException

public byte[] java.lang.String.getBytes(java.lang.String) throws java.io.UnsupportedEncodingException 是一个方法，将此字符串编码为指定的字符集并将其转换为字节数组。

以下是一个使用 JUnit 进行单元测试的例子：

@Testpublic void testGetBytes() throws UnsupportedEncodingException {String str = "Hello World";byte[] bytes = str.getBytes("UTF-8");byte[] expected = {72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100};assertArrayEquals(expected, bytes);}

这个例子首先创建了一个字符串 str 和一个字符串表示所需的字符集，这里使用了 UTF-8 编码。然后对 getBytes() 方法进行测试，将字符串以指定的字符集编码成字节数组，并使用 assertArrayEquals() 来断言实际返回值是否与预期相同。最后的测试结果应该是通过的。注意，该方法可能会抛出 UnsupportedEncodingException 异常，因此需要在方法声明中进行处理或抛出。

public byte[] java.lang.String.getBytes()

public byte[] java.lang.String.getBytes() 是一个方法，将此字符串编码为默认的字符集并将其转换为字节数组。

以下是一个使用 JUnit 进行单元测试的例子：

    @Testpublic void testGetBytes() {String str = "Hello World";byte[] bytes = str.getBytes();byte[] expected = {72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100};assertArrayEquals(expected, bytes);}

这个例子首先创建了一个字符串 str。然后对 getBytes() 方法进行测试，将字符串以默认字符集（通常是 UTF-8）编码成字节数组，并使用 assertArrayEquals() 来断言实际返回值是否与预期相同。最后的测试结果应该是通过的。

public void java.lang.String.getChars(int,int,char[],int)

public void java.lang.String.getChars(int,int,char[],int) 是一个方法，将此字符串的子串复制到指定的字符数组中。

以下是一个使用 JUnit 进行单元测试的例子：

@Testpublic void testGetChars() {String str = "Hello World";char[] chars = new char[5];str.getChars(6, 11, chars, 0);char[] expected = {'W', 'o', 'r', 'l', 'd'};assertArrayEquals(expected, chars);}

这个例子首先创建了一个字符串 str，并创建了一个长度为 5 的字符数组。然后对 getChars() 方法进行测试，提取从索引位置 6 到 11 的子串，并将其存储在指定的字符数组中。使用 assertArrayEquals() 来断言实际返回值是否与预期相同。最后的测试结果应该是通过的。

private int java.lang.String.indexOfSupplementary(int,int)

private int java.lang.String.indexOfSupplementary(int,int) 是一个私有方法，用于查找指定范围内字符串中 Unicode 辅助字符的索引。

由于这是一个私有方法，无法直接进行单元测试。它通常会被公共的 indexOf() 或 lastIndexOf() 方法调用，以支持查找包含辅助字符的字符串。

以下是一个使用 JUnit 进行单元测试的例子，测试了 indexOf() 方法：

    @Testpublic void testIndexOf() {String str = "Hello 😊 World";int index = str.indexOf("😊");assertEquals(6, index);}

这个例子首先创建了一个包含辅助字符的字符串 str。然后对 indexOf() 方法进行测试，查找字符串中 Unicode 辅助字符的索引，并使用 assertEquals() 来断言实际返回值是否与预期相同。最后的测试结果应该是通过的。

public native java.lang.String java.lang.String.intern()

public native java.lang.String java.lang.String.intern() 是一个本地方法，返回字符串对象的规范化表示。

以下是一个使用 JUnit 进行单元测试的例子：

    @Testpublic void testIntern() {String str1 = "Hello World";String str2 = new String("Hello World");assertTrue(str1 == str1.intern());assertTrue(str1 != str2);assertTrue(str1.intern() == str2.intern());}

这个例子首先创建了两个字符串 str1 和 str2，它们都包含相同的字符序列。然后对 intern() 方法进行测试，使用 assert 来断言 str1.intern() 返回的字符串是否与 str1 相同，并且 str1.intern() 和 str2.intern() 是否相等。注意，由于 intern() 方法返回此字符串对象的规范化表示形式，因此可以在比较字符串时使用 == 运算符而不是 equals() 方法。最后的测试结果应该是通过的。

public boolean java.lang.String.isEmpty()

public native java.lang.String java.lang.String.intern() 是一个本地方法，返回字符串对象的规范化表示。

以下是一个使用 JUnit 进行单元测试的例子：

    @Testpublic void testIntern() {String str1 = "Hello World";String str2 = new String("Hello World");assertTrue(str1 == str1.intern());assertTrue(str1 != str2);assertTrue(str1.intern() == str2.intern());}

这个例子首先创建了两个字符串 str1 和 str2，它们都包含相同的字符序列。然后对 intern() 方法进行测试，使用 assert 来断言 str1.intern() 返回的字符串是否与 str1 相同，并且 str1.intern() 和 str2.intern() 是否相等。注意，由于 intern() 方法返回此字符串对象的规范化表示形式，因此可以在比较字符串时使用 == 运算符而不是 equals() 方法。最后的测试结果应该是通过的。

public static java.lang.String java.lang.String.join(java.lang.CharSequence,java.lang.CharSequence[])

public static java.lang.String java.lang.String.join(java.lang.CharSequence,java.lang.CharSequence[]) 是一个静态方法，用于将指定的字符序列连接到一个字符串中。

以下是一个使用 JUnit 进行单元测试的例子：

    @Testpublic void testJoin() {CharSequence delimiter = "-";CharSequence[] elements = {"Hello", "World"};String str = String.join(delimiter, elements);assertEquals("Hello-World", str);}

这个例子首先创建了一个分隔符 delimiter 和一个字符序列数组 elements，其中每个元素都是一个字符串。然后对 join() 方法进行测试，将字符序列连接成一个字符串，并使用 assertEquals() 来断言实际返回值是否与预期相同。最后的测试结果应该是通过的。

public static java.lang.String java.lang.String.join(java.lang.CharSequence,java.lang.Iterable)

public static java.lang.String java.lang.String.join(java.lang.CharSequence,java.lang.Iterable) 是一个静态方法，用于将 iterable 对象中的元素连接成一个字符串。

以下是一个使用 JUnit 进行单元测试的例子：

    @Testpublic void testJoin() {CharSequence delimiter = "-";List<String> elements = Arrays.asList("Hello", "World");String str = String.join(delimiter, elements);assertEquals("Hello-World", str);}

这个例子首先创建了一个分隔符 delimiter 和一个包含两个字符串元素的列表 elements。然后对 join() 方法进行测试，将 iterable 对象中的元素连接成一个字符串，并使用 assertEquals() 来断言实际返回值是否与预期相同。最后的测试结果应该是通过的。

public int java.lang.String.lastIndexOf(int)

java.lang.String.lastIndexOf(int)方法是用来查找给定字符在字符串中最后一次出现的位置的索引。如果该字符没有在字符串中出现，则返回-1。

以下是一个示例单元测试：

    @Testpublic void testLastIndexOf() {String str = "hello world";int index1 = str.lastIndexOf('o');assertEquals(7, index1);int index2 = str.lastIndexOf('z');assertEquals(-1, index2);}

该单元测试创建了一个字符串变量str，并使用lastIndexOf方法搜索该字符串中指定字符的最后一次出现位置。第一个断言验证’o’的最后一个出现位置为7，而第二个断言验证’z’不在字符串中，因此返回-1。

public int java.lang.String.lastIndexOf(java.lang.String)

java.lang.String.lastIndexOf(String)方法是用来查找给定子字符串在当前字符串中最后一次出现的位置的索引。如果该子字符串没有在当前字符串中出现，则返回-1。

以下是一个示例单元测试：

    @Testpublic void testLastIndexOf() {String str = "Hello Hello World";int index1 = str.lastIndexOf("Hello");assertEquals(6, index1);int index2 = str.lastIndexOf("Goodbye");assertEquals(-1, index2);}

该单元测试创建了一个字符串变量str，并使用lastIndexOf方法搜索该字符串中指定子字符串的最后一次出现位置。第一个断言验证"Hello"的最后一个出现位置为6，而第二个断言验证"Goodbye"不在字符串中，因此返回-1。

public int java.lang.String.lastIndexOf(java.lang.String,int)

java.lang.String.lastIndexOf(String, int)方法是用来查找给定子字符串在当前字符串中，从指定索引开始往前搜索的最后一次出现位置的索引。如果该子字符串没有在当前字符串中出现，则返回-1。

以下是一个示例单元测试：

    @Testpublic void testLastIndexOf() {String str = "hello world";int index1 = str.lastIndexOf("l", 8);assertEquals(3, index1);int index2 = str.lastIndexOf("z", 8);assertEquals(-1, index2);}

该单元测试创建了一个字符串变量str，并使用lastIndexOf方法从索引8开始往前搜索该字符串中指定子字符串的最后一次出现位置。第一个断言验证"l"的最后一个出现位置为3，而第二个断言验证"z"不在索引8之前的部分字符串中，因此返回-1。

public int java.lang.String.lastIndexOf(int,int)

java.lang.String.lastIndexOf(int, int)方法是用来查找给定字符在当前字符串中，从指定索引开始往前搜索的最后一次出现位置的索引。如果该字符没有在当前字符串中出现，则返回-1。

以下是一个示例单元测试：

    @Testpublic void testLastIndexOf() {String str = "hello world";int index1 = str.lastIndexOf('l', 8);assertEquals(3, index1);int index2 = str.lastIndexOf('z', 8);assertEquals(-1, index2);}

该单元测试创建了一个字符串变量str，并使用lastIndexOf方法从索引8开始往前搜索该字符串中指定字符的最后一次出现位置。第一个断言验证’l’的最后一个出现位置为3，而第二个断言验证’z’不在索引8之前的部分字符串中，因此返回-1。

public int java.lang.String.length()

java.lang.String.length()方法返回当前字符串的长度，即该字符串中包含的字符数。

以下是一个示例单元测试：

    @Testpublic void testLength() {String str = "hello world";int length = str.length();assertEquals(11, length);}

该单元测试创建了一个字符串变量str，并使用length方法获取该字符串的长度。断言验证该字符串的长度为11个字符。

public boolean java.lang.String.matches(java.lang.String)

java.lang.String.matches(String)方法是用来判断当前字符串是否满足给定的正则表达式。如果该字符串与正则表达式匹配，则返回true，否则返回false。

以下是一个示例单元测试：

    @Testpublic void testMatches() {String str1 = "hello world";String str2 = "12345";boolean match1 = str1.matches("[a-z ]+");assertTrue(match1);boolean match2 = str2.matches("[a-z]+");assertFalse(match2);}

该单元测试创建了两个字符串变量str1和str2，并使用matches方法判断它们是否满足给定的正则表达式。第一个断言验证str1能够匹配包含小写字母和空格的正则表达式，而第二个断言验证str2不能匹配只包含小写字母的正则表达式。

private boolean java.lang.String.nonSyncContentEquals(java.lang.AbstractStringBuilder)

java.lang.String.matches(String)方法是用来判断当前字符串是否满足给定的正则表达式。如果该字符串与正则表达式匹配，则返回true，否则返回false。

以下是一个示例单元测试：

    @Testpublic void testMatches() {String str1 = "hello world";String str2 = "12345";boolean match1 = str1.matches("[a-z ]+");assertTrue(match1);boolean match2 = str2.matches("[a-z]+");assertFalse(match2);}

该单元测试创建了两个字符串变量str1和str2，并使用matches方法判断它们是否满足给定的正则表达式。第一个断言验证str1能够匹配包含小写字母和空格的正则表达式，而第二个断言验证str2不能匹配只包含小写字母的正则表达式。

public int java.lang.String.offsetByCodePoints(int,int)

java.lang.String.offsetByCodePoints(int, int)方法是用来计算从指定的偏移量开始，通过遍历该字符串中的Unicode代码点，并返回相对于起始索引的新偏移量。如果起始索引或偏移量不在范围内，则抛出IndexOutOfBoundsException。

以下是一个示例单元测试：

    @Testpublic void testOffsetByCodePoints() {String str = "Hello world\\uD83D\\uDE00";int offset1 = str.offsetByCodePoints(0, 5);assertEquals(5, offset1);int offset2 = str.offsetByCodePoints(10, -1);assertEquals(9, offset2);}

该单元测试创建了一个字符串变量str，其中包含一个代理对字符，即一个占用两个char的字符：\\uD83D\\uDE00。它使用offsetByCodePoints方法计算从索引0和10开始，分别向后和向前遍历两个Unicode代码点所对应的字符集合，并返回相对于起始索引的新偏移量。第一个断言验证相对于索引0，向后遍历5个Unicode代码点后的索引为5，而第二个断言验证相对于索引10，向前遍历1个Unicode代码点后的索引为9。

public boolean java.lang.String.regionMatches(boolean,int,java.lang.String,int,int)

java.lang.String.regionMatches(boolean, int, String, int, int)方法是用来比较当前字符串的一个子区间和另一个给定字符串的一个子区间是否相等。如果它们相等，则返回true，否则返回false。该方法还有一个布尔型参数用于指定是否忽略大小写。

以下是一个示例单元测试：

    @Testpublic void testRegionMatches() {String str1 = "hello world";String str2 = "WORLD";boolean match1 = str1.regionMatches(true, 6, str2, 0, 5);assertTrue(match1);boolean match2 = str1.regionMatches(true, 0, str2, 0, 5);assertFalse(match2);}

该单元测试创建了两个字符串变量str1和str2，并使用regionMatches方法比较它们的子区间是否相同，并忽略大小写。第一个断言验证忽略大小写时，str1中索引6开始长度为5的子区间与str2中从索引0开始长度为5的子区间相等，因此返回true。第二个断言验证忽略大小写时，str1中索引0开始长度为5的子区间与str2中从索引0开始长度为5的子区间不相等，因此返回false。

public java.lang.String java.lang.String.replace(char,char)

java.lang.String.replace(char, char)方法是用来将当前字符串中所有的给定字符替换为另一个给定字符，并返回替换后得到的新字符串。

以下是一个示例单元测试：

    @Testpublic void testReplace() {String str1 = "hello world";String replaced1 = str1.replace('l', 'L');assertEquals("heLLo worLd", replaced1);String replaced2 = str1.replace('z', 'Z');assertEquals("hello world", replaced2);}

该单元测试创建了一个字符串变量str1，并使用replace方法将其中所有的小写字母"l"替换为大写字母"L"。第一个断言验证替换后得到的新字符串为"heLLo worLd"。之后，尝试将其中不存在的字符"z"替换为"Z"，并测试结果是否与原始字符串相同。第二个断言验证t2与原始字符串相同，因为没有找到匹配的字符进行替换。

public java.lang.String java.lang.String.replace(java.lang.CharSequence,java.lang.CharSequence)

java.lang.String.replace(char, char)方法是用来将当前字符串中所有的给定字符替换为另一个给定字符，并返回替换后得到的新字符串。

以下是一个示例单元测试：

    @Testpublic void testReplace() {String str1 = "hello world";String replaced1 = str1.replace('l', 'L');assertEquals("heLLo worLd", replaced1);String replaced2 = str1.replace('z', 'Z');assertEquals("hello world", replaced2);}

该单元测试创建了一个字符串变量str1，并使用replace方法将其中所有的小写字母"l"替换为大写字母"L"。第一个断言验证替换后得到的新字符串为"heLLo worLd"。之后，尝试将其中不存在的字符"z"替换为"Z"，并测试结果是否与原始字符串相同。第二个断言验证t2与原始字符串相同，因为没有找到匹配的字符进行替换。

public java.lang.String java.lang.String.replaceAll(java.lang.String,java.lang.String)

java.lang.String.replaceAll(String, String)方法是用来将当前字符串中所有的与给定正则表达式匹配的子串替换为另一个给定字符串，并返回替换后得到的新字符串。

以下是一个示例单元测试：

    @Testpublic void testReplaceAll() {String str1 = "hello world";String regex1 = "[aeiou]";String replaced1 = str1.replaceAll(regex1, "*");assertEquals("h*ll* w*rld", replaced1);String regex2 = "[z]";String replaced2 = str1.replaceAll(regex2, "*");assertEquals("hello world", replaced2);}

该单元测试创建了一个字符串变量str1和一个正则表达式regex1，并使用replaceAll方法将其中所有的小写元音字母替换为"“。第一个断言验证替换后得到的新字符串为"hll* wrld”。之后，尝试将其中不存在的字符"z"替换为""，并测试结果是否与原始字符串相同。第二个断言验证t2与原始字符串相同，因为没有找到匹配的子串进行替换。

public java.lang.String java.lang.String.replaceFirst(java.lang.String,java.lang.String)

java.lang.String.replaceFirst(String, String)方法是用来将当前字符串中第一个与给定正则表达式匹配的子串替换为另一个给定字符串，并返回替换后得到的新字符串。

以下是一个示例单元测试：

    @Testpublic void testReplaceFirst() {String str1 = "hello world";String regex1 = "[l]";String replaced1 = str1.replaceFirst(regex1, "*");assertEquals("he*lo world", replaced1);String regex2 = "[z]";String replaced2 = str1.replaceFirst(regex2, "*");assertEquals("hello world", replaced2);}

该单元测试创建了一个字符串变量str1和一个正则表达式regex1，并使用replaceFirst方法将其中第一个小写字母"l"替换为"“。第一个断言验证替换后得到的新字符串为"helo world”。之后，尝试将其中不存在的字符"z"替换为"*"，并测试结果是否与原始字符串相同。第二个断言验证t2与原始字符串相同，因为没有找到匹配的子串进行替换。

public java.lang.String[] java.lang.String.split(java.lang.String)

java.lang.String.replaceFirst(String, String)方法是用来将当前字符串中第一个与给定正则表达式匹配的子串替换为另一个给定字符串，并返回替换后得到的新字符串。

以下是一个示例单元测试：

    @Testpublic void testReplaceFirst() {String str1 = "hello world";String regex1 = "[l]";String replaced1 = str1.replaceFirst(regex1, "*");assertEquals("he*lo world", replaced1);String regex2 = "[z]";String replaced2 = str1.replaceFirst(regex2, "*");assertEquals("hello world", replaced2);}

该单元测试创建了一个字符串变量str1和一个正则表达式regex1，并使用replaceFirst方法将其中第一个小写字母"l"替换为"“。第一个断言验证替换后得到的新字符串为"helo world”。之后，尝试将其中不存在的字符"z"替换为"*"，并测试结果是否与原始字符串相同。第二个断言验证t2与原始字符串相同，因为没有找到匹配的子串进行替换。

public java.lang.String[] java.lang.String.split(java.lang.String,int)

java.lang.String.split(String, int)方法是用来将当前字符串按照给定的正则表达式分割为一个字符串数组，并返回该数组。分割后的子串不包括与正则表达式匹配的部分。

此外，该方法还有一个整型参数，用于指定分割成的最大子串数目。如果未指定此参数或指定为0，则分割出所有的子串。

以下是一个示例单元测试：

    @Testpublic void testSplit() {String str1 = "hello,world,foo,bar";String regex1 = ",";String[] split1 = str1.split(regex1, 2);assertArrayEquals(new String[]{"hello", "world,foo,bar"}, split1);String[] split2 = str1.split(regex1, 0);assertArrayEquals(new String[]{"hello", "world", "foo", "bar"}, split2);}

该单元测试创建了一个字符串变量str1和一个正则表达式regex1，并使用split方法将其中的",“作为分隔符，将字符串分割为两个子串"hello"和"world,foo,bar”。第一个断言验证分割后得到的字符串数组为[“hello”, “world,foo,bar”]。之后，尝试将其中的","作为分隔符，最多分割成4个子串，即不分割。第二个断言验证分割后得到的字符串数组为[“hello”, “world”, “foo”, “bar”]。

public boolean java.lang.String.startsWith(java.lang.String,int)

java.lang.String.startsWith(String, int)方法是用来判断当前字符串从指定索引开始是否以给定的字符串开头。如果是，则返回true，否则返回false。

以下是一个示例单元测试：

    @Testpublic void testStartsWith() {String str1 = "hello world";boolean startsWith1 = str1.startsWith("hello", 0);assertTrue(startsWith1);boolean startsWith2 = str1.startsWith("world", 6);assertFalse(startsWith2);}

该单元测试创建了一个字符串变量str1，并使用startsWith方法检查它是否从索引0开始以"hello"开头。第一个断言验证t1是以"hello"开头的，因此返回true。之后，尝试从索引6开始检查是否以"world"开头，由于不是以"world"开头的，所以第二个断言验证t2返回false。

public boolean java.lang.String.startsWith(java.lang.String)

java.lang.String.startsWith(String)方法是用来判断当前字符串是否以给定的字符串开头。如果是，则返回true，否则返回false。

以下是一个示例单元测试：

    @Testpublic void testStartsWith() {String str1 = "hello world";boolean startsWith1 = str1.startsWith("hello");assertTrue(startsWith1);boolean startsWith2 = str1.startsWith("world");assertFalse(startsWith2);}

该单元测试创建了一个字符串变量str1，并使用startsWith方法检查它是否以"hello"开头。第一个断言验证t1是以"hello"开头的，因此返回true。之后，尝试检查是否以"world"开头，由于不是以"world"开头的，所以第二个断言验证t2返回false。

public java.lang.CharSequence java.lang.String.subSequence(int,int)

java.lang.String.subSequence(int, int)方法是用来获取当前字符串中指定索引范围内的子序列，并返回该子序列。

以下是一个示例单元测试：

    @Testpublic void testSubSequence() {String str1 = "hello world";CharSequence subSequence1 = str1.subSequence(0, 5);assertEquals("hello", subSequence1);CharSequence subSequence2 = str1.subSequence(6, 6);assertEquals("", subSequence2);}

该单元测试创建了一个字符串变量str1，并使用subSequence方法获取它的一个子序列。第一个断言验证从索引0到5的子序列为"hello"。之后，尝试获取长度为0的子序列，即起始索引和结束索引都为6。第二个断言验证得到的子序列为空字符串。

public java.lang.String java.lang.String.substring(int)

java.lang.String.substring(int)方法是用来获取当前字符串中从指定索引开始到结尾的子串，并返回该子串。

以下是一个示例单元测试：

    @Testpublic void testSubstring() {String str1 = "hello world";String substring1 = str1.substring(6);assertEquals("world", substring1);String substring2 = str1.substring(str1.length());assertEquals("", substring2);}

该单元测试创建了一个字符串变量str1，并使用substring方法获取它的一个子串。第一个断言验证从索引6开始的子串为"world"。之后，尝试获取起始索引与字符串长度相等的子串，即空串。第二个断言验证得到的子串为""（空字符串）。

public java.lang.String java.lang.String.substring(int,int)

java.lang.String.substring(int, int)方法是用来获取当前字符串中从指定起始索引（包含）到指定结束索引（不包含）的子串，并返回该子串。

以下是一个示例单元测试：

    @Testpublic void testSubstring() {String str1 = "hello world";String substring1 = str1.substring(6, 11);assertEquals("world", substring1);String substring2 = str1.substring(str1.length(), str1.length());assertEquals("", substring2);}

该单元测试创建了一个字符串变量str1，并使用substring方法获取它的一个子串。第一个断言验证从索引6到11的子串为"world"。之后，尝试获取起始索引和结束索引相等的子串，即空串。第二个断言验证得到的子串为""（空字符串）。

public char[] java.lang.String.toCharArray()

java.lang.String.toCharArray()方法是用来获取当前字符串中的字符数组，并返回该数组。

以下是一个示例单元测试：

    @Testpublic void testToCharArray() {String str1 = "hello world";char[] charArray1 = str1.toCharArray();assertArrayEquals(new char[]{'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'}, charArray1);char[] charArray2 = "".toCharArray();assertArrayEquals(new char[0], charArray2);}

该单元测试创建了一个字符串变量str1，并使用toCharArray方法获取它的字符数组。第一个断言验证得到的字符数组与预期的一致。之后，尝试将空字符串转换为字符数组，即长度为0的字符数组。第二个断言验证得到的字符数组与预期的一致。

public java.lang.String java.lang.String.toLowerCase(java.util.Locale)

java.lang.String.toCharArray()方法是用来获取当前字符串中的字符数组，并返回该数组。

以下是一个示例单元测试：

    @Testpublic void testToCharArray() {String str1 = "hello world";char[] charArray1 = str1.toCharArray();assertArrayEquals(new char[]{'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'}, charArray1);char[] charArray2 = "".toCharArray();assertArrayEquals(new char[0], charArray2);}

该单元测试创建了一个字符串变量str1，并使用toCharArray方法获取它的字符数组。第一个断言验证得到的字符数组与预期的一致。之后，尝试将空字符串转换为字符数组，即长度为0的字符数组。第二个断言验证得到的字符数组与预期的一致。

public java.lang.String java.lang.String.toLowerCase()

java.lang.String.toLowerCase()方法是用来将当前字符串中的所有大写字母转换为小写字母，并返回转换后的新字符串。使用默认的区域设置进行转换。

以下是一个示例单元测试：

    @Testpublic void testToLowerCase() {String str1 = "Hello World";String lowerCase1 = str1.toLowerCase();assertEquals("hello world", lowerCase1);String lowerCase2 = "".toLowerCase();assertEquals("", lowerCase2);}

该单元测试创建了一个字符串变量str1，并使用toLowerCase方法将其中的大写字母转换为小写字母。第一个断言验证得到的结果与预期一致。之后，尝试将空字符串转换为小写，该方法不会修改空字符串，因此得到的结果应该也是空字符串。第二个断言验证得到的结果与预期的一致。

public java.lang.String java.lang.String.toUpperCase()

java.lang.String.toUpperCase()方法是用来将当前字符串中的所有小写字母转换为大写字母，并返回转换后的新字符串。使用默认的区域设置进行转换。

以下是一个示例单元测试：

    @Testpublic void testToUpperCase() {String str1 = "Hello World";String upperCase1 = str1.toUpperCase();assertEquals("HELLO WORLD", upperCase1);String upperCase2 = "".toUpperCase();assertEquals("", upperCase2);}

该单元测试创建了一个字符串变量str1，并使用toUpperCase方法将其中的小写字母转换为大写字母。第一个断言验证得到的结果与预期一致。之后，尝试将空字符串转换为大写，该方法不会修改空字符串，因此得到的结果应该也是空字符串。第二个断言验证得到的结果与预期的一致。

public java.lang.String java.lang.String.toUpperCase(java.util.Locale)

java.lang.String.toUpperCase(Locale)方法是用来将当前字符串中的所有小写字母转换为大写字母，使用给定的区域设置。如果不提供Locale参数，则使用默认的区域设置进行转换。

以下是一个示例单元测试：

    @Testpublic void testToUpperCase() {String str1 = "Hello World";String upperCase1 = str1.toUpperCase();assertEquals("HELLO WORLD", upperCase1);String upperCase2 = str1.toUpperCase(Locale.ENGLISH);assertEquals("HELLO WORLD", upperCase2);}

该单元测试创建了一个字符串变量str1，并使用toUpperCase方法将其中的小写字母转换为大写字母。第一个断言验证在没有指定Locale参数的情况下，得到的结果与预期一致。之后，尝试使用Locale.ENGLISH作为Locale参数，以确保转换正确地适用于不同的语言环境。第二个断言验证得到的结果与预期的一致。

public java.lang.String java.lang.String.trim()

java.lang.String.trim()方法是用来去除当前字符串的首尾空格，并返回处理后的新字符串。字符串中间的空格不受影响。

以下是一个示例单元测试：

    @Testpublic void testTrim() {String str1 = "   hello world   ";String trimmed1 = str1.trim();assertEquals("hello world", trimmed1);String trimmed2 = "".trim();assertEquals("", trimmed2);String trimmed3 = "no whitespace".trim();assertEquals("no whitespace", trimmed3);}

该单元测试创建了一个带有前导和尾随空格的字符串变量str1，并使用trim方法去掉这些空格。第一个断言验证得到的结果与预期一致。之后，尝试对空字符串进行修剪，此时应不进行修改。第二个断言验证得到的结果与预期的一致。最后，尝试对没有前导或尾随空格的字符串进行修剪，此时不应进行任何修改。第三个断言验证得到的结果与预期的一致。

public final void java.lang.Object.wait() throws java.lang.InterruptedException

java.lang.Object.wait()方法是一个非常重要的方法，用于使当前线程进入等待状态，直到另一个线程调用此对象的notify()或notifyAll()方法唤醒该线程。在调用此方法之前，应该先获得该对象的锁定。

以下是一个示例单元测试：

    @Testpublic void testWaitAndNotify() throws InterruptedException {Object lock = new Object();Thread threadA = new Thread(() -> {synchronized (lock) {try {// Make the current thread wait and release the locklock.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Thread A is awake!");}});Thread threadB = new Thread(() -> {synchronized (lock) {System.out.println("Thread B is starting and will sleep for 1 second");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}lock.notify();}});threadA.start();threadB.start();threadA.join();threadB.join();}

该单元测试创建了一个带有锁定对象lock的线程threadA和threadB。在threadA中，使用synchronized块来获取lock的锁，并在其中调用wait()方法，将线程挂起等待另一个线程唤醒。在threadB中，也使用synchronized块获取lock的锁，并休眠1秒钟后调用notify()方法来唤醒等待的线程。然后，启动两个线程并等待它们完成。

该测试模拟了一个非常基本的使用wait()和notify()方法的场景，其中一个线程正在等待另一个线程执行操作后发出信号。此测试通过输出字符串来验证线程是否已成功唤醒。

public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException

java.lang.Object.wait(long,int)方法是wait()方法的一个重载版本，它使当前线程进入等待状态并在指定的时间内等待另一线程调用此对象的notify()或notifyAll()方法唤醒该线程。如果指定的时间已过，则当前线程会自动从等待状态返回。在调用此方法之前，应该先获得该对象的锁定。

以下是一个示例单元测试：

    @Testpublic void testWaitAndNotifyWithTimeout() throws InterruptedException {Object lock = new Object();Thread threadA = new Thread(() -> {synchronized (lock) {try {lock.wait(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Thread A is awake!");}});Thread threadB = new Thread(() -> {synchronized (lock) {System.out.println("Thread B is starting and will sleep for 1 second");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}lock.notify();}});threadA.start();threadB.start();threadA.join();threadB.join();}

该单元测试创建了一个带有锁定对象lock的线程threadA和threadB。在threadA中，使用synchronized块来获取lock的锁，并在其中调用wait(2000)方法，将线程挂起等待另一个线程唤醒或超时2秒钟后自动返回。在threadB中，也使用synchronized块获取lock的锁，并休眠1秒钟后调用notify()方法来唤醒等待的线程。然后，启动两个线程并等待它们完成。

该测试模拟了一个使用带有超时参数的wait()和notify()方法的场景，其中一个线程正在等待另一个线程执行操作后发出信号，但如果一定时间内没有收到通知，则会自动返回。此测试通过输出字符串来验证线程是否已成功唤醒。

public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException

java.lang.Object.wait(long)方法是wait()方法的另一个重载版本，它使当前线程进入等待状态并在指定的时间内等待另一线程调用此对象的notify()或notifyAll()方法唤醒该线程。如果指定的时间已过，则当前线程会自动从等待状态返回。在调用此方法之前，应该先获得该对象的锁定。

以下是一个示例单元测试：

    @Testpublic void testWaitWithTimeout() throws InterruptedException {Object lock = new Object();synchronized (lock) {System.out.println("Main thread is starting and will wait for 2 seconds");lock.wait(2000);System.out.println("Main thread is awake!");}// Test that the main thread has woken up after the specified timeoutassertTrue(true);}

该单元测试创建了一个带有锁定对象lock的主线程，并使用synchronized块来获取lock的锁，并在其中调用wait(2000)方法，将线程挂起等待另一个线程唤醒或超时2秒钟后自动返回。然后，使用assertTrue断言验证程序是否已成功从wait()方法中返回。

该测试模拟了一个使用带有超时参数的wait()方法的场景，其中一个线程正在等待另一个线程执行操作后发出信号，但如果一定时间内没有收到通知，则会自动返回。此测试不使用另一个线程来唤醒等待的线程，而是在主线程中等待超时时间过去。

public boolean java.lang.Object.equals(java.lang.Object)

java.lang.Object.equals(Object)方法是一个用于比较两个对象是否相等的方法。默认情况下，该方法比较的是两个对象的引用是否相同，即判断是否指向同一个对象。如果需要比较两个对象的内容是否相同，则应该在自定义类中覆盖equals()方法。

以下是一个示例单元测试：

    @Testpublic void testEquals() {String str1 = "hello world";String str2 = new String("hello world");assertTrue(str1.equals(str2));Integer int1 = new Integer(5);Integer int2 = new Integer(5);assertFalse(int1.equals(int2));CustomObject obj1 = new CustomObject("data");CustomObject obj2 = new CustomObject("data");assertTrue(obj1.equals(obj2));}private static class CustomObject {private final String data;public CustomObject(String data) {this.data = data;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;CustomObject that = (CustomObject) o;return data.equals(that.data);}}

该单元测试包含三个不同的场景来测试equals()方法。首先，创建了两个不同的字符串对象，但它们具有相同的内容。使用assertTrue断言来验证这两个字符串是否相等。接下来，创建了两个不同的整数对象，但它们具有相同的值。此时应该返回false，因为整数类没有覆盖equals()方法，比较的是两个对象的引用。最后，创建了两个自定义类的实例，这些类覆盖了equals()方法以比较它们的内容。使用assertTrue断言来验证这两个对象是否相等。

public java.lang.String java.lang.Object.toString()

java.lang.Object.toString()方法是一个用于生成对象的字符串表示的方法。默认情况下，该方法返回一个字符串，其中包含对象的类名和哈希码值。可以在自定义类中覆盖toString()方法来返回有意义的对象表示形式。

以下是一个示例单元测试：

    @Testpublic void testToString() {String str = "hello world";assertEquals("hello world", str.toString());Integer integer = new Integer(42);assertEquals("42", integer.toString());CustomObject obj = new CustomObject("data");assertEquals("CustomObject{data='data'}", obj.toString());}private static class CustomObject {private final String data;public CustomObject(String data) {this.data = data;}@Overridepublic String toString() {return "CustomObject{" +"data='" + data + '\\'' +'}';}}

该单元测试测试了三种不同情况下的toString()方法。首先，在字符串和整数对象上测试默认的toString()方法，以验证它们是否返回期望的结果。接下来，在自定义类上测试重写的toString()方法，以验证它是否在返回对象的字符串表示时生成有意义的信息。

在自定义类中，只要按照约定格式编写toString()方法，即返回类名和有意义的字段值，就可以生成适当的字符串表示形式。使用assertEquals断言来验证返回的字符串是否与期望的字符串相等。

public native int java.lang.Object.hashCode()

java.lang.Object.hashCode()方法是一个用于返回对象的哈希码值的方法。默认情况下，该方法返回对象的内部地址作为哈希码值。可以在自定义类中覆盖hashCode()方法来生成有意义的哈希码值。

以下是一个示例单元测试：

    @Testpublic void testHashCode() {String str = "hello world";assertEquals(str.hashCode(), System.identityHashCode(str));Integer integer = new Integer(42);assertEquals(integer.hashCode(), System.identityHashCode(integer));CustomObject obj1 = new CustomObject("data");CustomObject obj2 = new CustomObject("data");assertNotEquals(System.identityHashCode(obj1), System.identityHashCode(obj2));assertEquals(obj1.hashCode(), obj2.hashCode());}private static class CustomObject {private final String data;public CustomObject(String data) {this.data = data;}@Overridepublic int hashCode() {return Objects.hash(data);}}

该单元测试测试了三种不同情况下的hashCode()方法。首先，在字符串和整数对象上测试默认的hashCode()方法，以验证它们是否返回期望的结果。由于默认实现是返回对象的内部地址作为哈希码值，因此使用System.identityHashCode方法检查这些对象的哈希码值是否符合预期。

然后，在自定义类上测试重写的hashCode()方法，以验证它是否生成有意义的哈希码值。使用Objects.hash()方法来生成哈希码值，该方法接受任意数量的对象并生成哈希码值，这些值结合为一个总体哈希码值。使用assertNotEquals和assertEquals断言来验证生成的哈希码值是否符合预期。

public final native java.lang.Class java.lang.Object.getClass()

java.lang.Object.getClass()方法是一个用于返回对象所属类的Class对象的方法。该方法返回Class对象的引用，该对象包含有关该对象所属类的信息。

以下是一个示例单元测试：

    @Testpublic void testGetClass() {String str = "hello world";assertEquals(String.class, str.getClass());Integer integer = new Integer(42);assertEquals(Integer.class, integer.getClass());CustomObject obj = new CustomObject("data");assertEquals(CustomObject.class, obj.getClass());}private static class CustomObject {private final String data;public CustomObject(String data) {this.data = data;}}

该单元测试测试了三种不同情况下的getClass()方法。首先，在字符串和整数对象上测试getClass()方法，以验证它们是否返回期望的结果。接下来，在自定义类上测试getClass()方法，以验证它是否返回正确的类对象引用。

使用assertEquals断言来验证返回的类对象是否与期望的类对象相等。

public final native void java.lang.Object.notify()

java.lang.Object.notify()方法是一个用于唤醒等待该对象监视器的一个线程的方法。该方法只能在同步代码块中使用，否则会抛出IllegalMonitorStateException异常。

以下是一个示例单元测试：

   @Testpublic void testNotify() throws InterruptedException {Object lock = new Object();boolean flag = false;Thread thread = new Thread(() -> {synchronized (lock) {try {lock.wait();} catch (InterruptedException e) {fail("Thread was interrupted");}flag = true;}});thread.start();Thread.sleep(500);synchronized (lock) {lock.notify();}// Wait for the other thread to set the flagThread.sleep(500);assertTrue(flag);}

该单元测试创建了一个锁对象，并在另一个线程中对其进行等待。主线程在一段时间后调用notify()方法来唤醒等待的线程。然后，等待一段时间以确保等待的线程已被唤醒并设置了标志。最后，使用assertTrue断言来验证标志已被设置为true。

要注意的是，必须在同步代码块中调用notify()方法，否则会抛出IllegalMonitorStateException异常。而且，调用notify()方法只能唤醒正在等待该对象监视器的一个线程，具体唤醒哪个线程是不确定的。

public final native void java.lang.Object.notifyAll()

java.lang.Object.notifyAll()方法是一个用于唤醒等待该对象监视器的所有线程的方法。该方法只能在同步代码块中使用，否则会抛出IllegalMonitorStateException异常。

以下是一个示例单元测试：

    @Testpublic void testNotifyAll() throws InterruptedException {Object lock = new Object();boolean flag1 = false;boolean flag2 = false;Thread thread1 = new Thread(() -> {synchronized (lock) {try {lock.wait();} catch (InterruptedException e) {fail("Thread was interrupted");}flag1 = true;}});Thread thread2 = new Thread(() -> {synchronized (lock) {try {lock.wait();} catch (InterruptedException e) {fail("Thread was interrupted");}flag2 = true;}});thread1.start();thread2.start();Thread.sleep(500);synchronized (lock) {lock.notifyAll();}Thread.sleep(500);assertTrue(flag1);assertTrue(flag2);}

该单元测试创建了一个锁对象，并在两个线程中对其进行等待。主线程在一段时间后调用notifyAll()方法来唤醒等待的线程。然后，等待一段时间以确保等待的线程已被唤醒并设置了标志。最后，使用assertTrue断言来验证标志已被设置为true。

要注意的是，必须在同步代码块中调用notifyAll()方法，否则会抛出IllegalMonitorStateException异常。而且，调用notifyAll()方法将唤醒正在等待该对象监视器的所有线程。

private static native void java.lang.Object.registerNatives()

java.lang.Object.registerNatives()方法是一个用于注册本地方法的本地方法。它是Object类的静态私有方法，用于提供与底层操作系统的交互。

以下是一个示例单元测试：

    @Testpublic void testRegisterNatives() throws ReflectiveOperationException {Class<?> objectClass = Class.forName("java.lang.Object");Method registerNativesMethod = objectClass.getDeclaredMethod("registerNatives");assertTrue(Modifier.isPrivate(registerNativesMethod.getModifiers()));assertTrue(Modifier.isStatic(registerNativesMethod.getModifiers()));registerNativesMethod.setAccessible(true);registerNativesMethod.invoke(null);}

该单元测试使用反射机制获取Object类中的registerNatives()方法。然后，使用assertTrue断言来验证该方法是私有和静态的。最后，通过调用invoke方法来注册本地方法。

要注意的是，该方法仅用于在JVM启动时设置本地方法，并且通常不需要在应用程序中调用此方法。