看到这句话的时候证明：此刻你我都在努力
加油陌生人


个人主页：Gu Gu Study
专栏：一步一步了解Java

喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹

喜欢的话可以点个赞谢谢了。
作者：小闭

String在Java中是一个类，平常我们存储字符串时也是储存在这个类型中的，但是Java创建Strring类肯定不仅仅让我们储存字符串而已，他也为我们提供了许多成员方法。接下来就让我们来学习一下。

String的构造

字符串的构造有挺多的，现在我就列出比较常用的三种构造方式：
以下是三种构造方式：

1. 使用常量串进行构造
2. 使用new关键字进行构造
3. 使用字符串进行构造

public class Test {     public static void main(String[] args) {         //使用常量串进行构造         String s1="hehe";          //使用new关键字进行构造         String s2=new String("hehe");         //使用字符串进行构造         char[] arr={'h','e','h','e'};         String s3=new String(arr);      }    } 

注意：String是一个引用类型， 内部并不存储字符串本身，在String类的实现源码中，String类实例变量如下： 在现在的jdk中是一个byte类型的数组进行储存的。

String 的比较

在Java中String中，==的比较对于不同类型的数据比较方式是不同的，对于基本类型是比较其中的值是否相等，对于引用类型是进行比较引用的地址是否相等。当然如果用常量字符串进行构造那么其地址是一样的，也就是两个用常量字符串构造的字符串成员变量他们是相等的。

public static void main(String[] args) {         int a = 10;         int b = 20;         int c = 10; // 对于基本类型变量，==比较两个变量中存储的值是否相同         System.out.println(a == b); // false         System.out.println(a == c); // true // 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象         String s1 = new String("hello");         String s2 = new String("hello");         String s3 = new String("world");         String s4 = s1;         String s5 = "hehe";    //字符串构造的方法构造字符串         String s6 = "hehe";         System.out.println(s1 == s2); // false         System.out.println(s2 == s3); // false         System.out.println(s1 == s4); // true         System.out.println(s5 == s6); // true              } 

那么使用什么比较方法可以比较里面的内容呢？这时我们就要引入一个方法了equals，这是字符串自带的一个比较方法。那接下来我们就看看如何使用吧。

public class Test {      String s1=new String("hehe");     String s2=new String("haha");     String s3=new String("hehe");     String s4=s1;      public static void main(String[] args) {         Test t=new Test();         System.out.println(t.s1.equals(t.s2));          System.out.println(t.s1.equals(t.s4));          System.out.println(t.s1.equals(t.s3));          System.out.println(t.s1==t.s3);       }    } 

equals是比较字符串里面的内容的，而不是比较地址所以有了以上的结果。

字符串的查找

大家在了解了一定的字符串知识后可能也想到了一个问题。那就是字符串能不能查找某个字符所在的位置呢？答案肯定是可以的。这时我们就又需要到String类自带的方法了。

Java 中的 String 类提供了多种查找方法，这些方法可以用于在字符串中查找子字符串、字符或者模式。以下是一些常用的查找方法：

1. indexOf(int ch) - 返回指定字符 ch 在字符串中首次出现的索引。
2. indexOf(int ch, int fromIndex) - 从 fromIndex 位置开始搜索，返回指定字符 ch 在字符串中首次出现的索引。
3. indexOf(String str) - 返回子字符串 str 在字符串中首次出现的索引。
4. indexOf(String str, int fromIndex) - 从 fromIndex 位置开始搜索，返回子字符串 str 在字符串中首次出现的索引。
5. lastIndexOf(int ch) - 返回指定字符 ch 在字符串中最后一次出现的索引。
6. lastIndexOf(int ch, int fromIndex) - 从 fromIndex 位置开始反向搜索，返回指定字符 ch 在字符串中最后一次出现的索引。
7. lastIndexOf(String str) - 返回子字符串 str 在字符串中最后一次出现的索引。
8. lastIndexOf(String str, int fromIndex) - 从 fromIndex 位置开始反向搜索，返回子字符串 str 在字符串中最后一次出现的索引。
9. contains(CharSequence s) - 判断字符串是否包含序列 s。
10. startsWith(String prefix) - 判断字符串是否以指定前缀 prefix 开始。
11. startsWith(String prefix, int toffset) - 从指定索引 toffset 开始，判断字符串是否以指定前缀 prefix 开始。
12. endsWith(String suffix) - 判断字符串是否以指定后缀 suffix 结束。

这些方法在处理字符串时非常有用，可以根据需要选择适当的方法来进行字符串的查找操作。

因为函数太多就不一一示例了，就简单给大家简单使用几个函数。

public class Test1 {     String s1="holle world";     String s2="this is a person";      public static void main(String[] args) {         Test1 t=new Test1();         System.out.println(t.s1.indexOf("w", 2));         System.out.println(t.s1.indexOf("w", 7));         System.out.println(t.s1.lastIndexOf("w",2));         System.out.println(t.s1.lastIndexOf("w"));         System.out.println(t.s1.contains("holle "));       } } 

如上就是代码的运行结果。

那如果我们想要取出字符串中下标为n的字符，那么这时我们就需要到另一个字符串方法了。那就是
char charAt( int n);

public class Test1 {     String s1="holle world";     String s2="this is a person";      public static void main(String[] args) {         Test1 t=new Test1();         System.out.println(t.s1.charAt(6));     } 

字符串的转化

String类也包含了方法转化为其它类型，当然其它类型也是可以转化成字符串。接下来我们看一下。
在Java中，String类提供了一个静态方法valueOf()，它可以将各种类型转换为String类型。这个方法非常通用，适用于原始数据类型、对象、数组等。以下是一些使用String.valueOf()方法的例子：

• 原始数据类型：可以直接将原始类型（如int, double等）转换为String。

int num = 10; String numStr = String.valueOf(num);  double d = 3.14; String dStr = String.valueOf(d); 

• 对象：如果对象是null，String.valueOf(null)将返回"null"字符串。对于非null对象，valueOf()将调用对象的toString()方法来获取其字符串表示。

Object obj = new Object(); String objStr = String.valueOf(obj); // 调用obj的toString()方法  String nullStr = String.valueOf(null); // 返回"null" 

• 数组：String.valueOf()可以用于将数组转换为字符串，但不会像Arrays.toString()那样提供友好的数组格式。它只是简单地调用数组的toString()方法。

int[] array = {1, 2, 3}; String arrayStr = String.valueOf(array); // 返回"[I@15aeb7ab"（示例） 

• 集合：对于集合类型，String.valueOf()会调用集合的toString()方法。

List list = Arrays.asList("Hello", "World"); String listStr = String.valueOf(list); // 返回"[Hello, World]" 

• 枚举：枚举类型也可以使用String.valueOf()转换为字符串。

enum Color { RED, GREEN, BLUE } String colorStr = String.valueOf(Color.RED); // 返回"RED" 

• 字符串字面量：对于字符串字面量，String.valueOf()将直接返回该字符串。

String literal = "Hello, World!"; String str = String.valueOf(literal); // 返回"Hello, World!" 

String.valueOf()方法是一个方便的工具，可以用于将几乎所有类型转换为字符串，但它不会对数组或集合进行特殊格式化，只会调用它们的toString()方法。如果需要更友好的格式化输出，可能需要使用其他方法，如Arrays.toString()或自定义的格式化逻辑。

public class Test {     String s1 = "hello world";      public static void main(String[] args) {         Test t = new Test();  // 数字转字符串         String s1 = String.valueOf(1234);         String s2 = String.valueOf(12.34);         String s3 = String.valueOf(true);         String s4 = String.valueOf(new Student("Hanmeimei", 18));         System.out.println(s1);         System.out.println(s2);          System.out.println(s3);         System.out.println(s4);         System.out.println();          // 字符串转数字 // 注意：Integer、Double等是Java中的包装类型         int data1 = Integer.parseInt("1234");         double data2 = Double.parseDouble("12.34");         System.out.println(data1);         System.out.println(data2);     } } 

String类中的替换和截取方法

在Java中，String 类提供了多种方法来替换字符串中的字符或子串，以及截取字符串的一部分。以下是一些常用的字符串操作方法：
替换方法：

1. replace(char oldChar, char newChar)： 替换字符串中的所有指定字符。

String str = "hello world"; String replaced = str.replace('o', 'e'); // "hellE werd" 

2. replace(CharSequence target, CharSequence replacement)： 替换字符串中所有匹配的子串。

String str = "hello world"; String replaced = str.replace("world", "Java"); // "hello Java" 

3. replaceAll(String regex, String replacement)： 使用正则表达式来替换字符串中的匹配项。

String str = "hello world"; String replaced = str.replaceAll("\\w+", "X"); // "X X" 

4. replaceFirst(String regex, String replacement)： 使用正则表达式替换字符串中的第一个匹配项。

String str = "hello world"; String replaced = str.replaceFirst("\\w+", "X"); // "X world" 

截取方法：

1. substring(int beginIndex)： 从指定位置开始截取到字符串末尾。

String str = "hello world"; String sub = str.substring(6); // "world" 

2. substring(int beginIndex, int endIndex)： 截取字符串的一部分，从beginIndex开始到endIndex - 1结束。

String str = "hello world"; String sub = str.substring(0, 5); // "hello" 

3. charAt(int index)： 获取字符串中指定位置的字符。

String str = "hello world"; char ch = str.charAt(0); // 'h' 

4. split(String regex)： 使用正则表达式来分割字符串，返回一个字符串数组。

String str = "hello,world"; String[] parts = str.split(","); // ["hello", "world"] 

5. substringBefore(String delimiter) 和 substringAfter(String delimiter)： 根据指定的分隔符截取字符串。

String str = "hello-world"; String before = str.substringBefore("-"); // "hello" String after = str.substringAfter("-"); // "world" 

6. substringTrimmed()： 截取字符串，同时去除首尾的空白字符。

String str = "  hello world  "; String trimmed = str.substringTrimmed(); // "hello world" 

请注意，String 类在Java中是不可变的，这意味着所有这些操作都会返回一个新的字符串实例，而不会修改原始字符串。

spilt方法详解
相信大家用过split方法用空格（“ ”）后有时会出现有空字符的元素，那么这是为什么呢？，这就需要我们好好了解一下，split这个方法了。在传给它的参数是“ ”时会怎么分割的呢？

1. 基本分割： 如果字符串中包含空格，split() 会按照空格分割字符串。

String str = "hello world"; String[] parts = str.split(" "); // 使用单个空格作为分隔符 // parts 将是 ["hello", "world"] 

2. 忽略连续空格： split() 方法默认情况下不会忽略连续的空格。如果字符串中有连续的空格，它们将导致数组中出现空字符串。

String str = "hello   world"; String[] parts = str.split(" "); // 将返回 ["hello", "", "", "world"] 

3. 字符串首尾空格： split() 方法不会自动去除字符串首尾的空格。如果需要去除这些空格，你需要在分割前使用 trim() 方法。

String str = " hello world "; String[] parts = str.trim().split(" "); // 先去除首尾空格，然后分割 // parts 将是 ["hello", "world"] 

4. 分割后去除空白： 如果你想要去除分割后数组元素的首尾空白，可以在分割后对每个元素使用 trim() 方法。

String str = " hello world "; String[] parts = str.split(" "); for (int i = 0; i < parts.length; i++) {     parts[i] = parts[i].trim(); // 去除每个元素的首尾空白 } // parts 将是 ["hello", "world"] 

5. 使用正则表达式分割： 如果你想要更灵活地处理空格，比如同时忽略多个连续空格和首尾空格，你可以使用正则表达式 \s+ 来代替单个空格。

String str = " hello world "; String[] parts = str.trim().split("\\s+"); // 使用正则表达式来分割 // parts 将是 ["hello", "world"] 

6. 空字符串： 如果原始字符串是空字符串或者只包含空格，split(" ") 将返回一个包含单个空字符串的数组。

String str = " "; String[] parts = str.split(" "); // 将返回 [""] 

7. null 值： 如果输入的字符串是 null，使用 split(" ") 将抛出 NullPointerException。

split() 方法返回的数组大小取决于字符串中空格的数量，包括连续的空格。如果需要忽略连续空格或首尾空格，你可能需要使用 trim() 和正则表达式 \s+ 的组合。

StringBuffer和StringBuilder
StringBuffer 是Java中一个线程安全的可变字符串类。它是 AbstractStringBuilder 类的一个具体实现，并且扩展了 CharSequence 接口。由于其线程安全性，StringBuffer 在多线程环境中经常被使用，以避免多个线程同时修改字符串时发生的问题。
以下是 StringBuffer 的一些主要特点和用法：

1. 线程安全： StringBuffer 类中的所有方法都是同步的，这意味着它可以在多线程环境中安全使用，而不需要额外的同步措施。
2. 可变字符串： 与 String 类不同，StringBuffer 允许修改字符串内容，如插入、删除或替换字符。
3. 容量自动增长： StringBuffer 内部维护了一个容量足够大的字符数组来存储字符串。如果字符串增长超出了当前容量，StringBuffer 会自动增长其内部数组。
4. 常用方法：
   • append(Object obj)：将对象的字符串表示追加到 StringBuffer 的末尾。
   • insert(int offset, Object obj)：在指定位置插入对象的字符串表示。
   • delete(int start, int end)：删除从 start 到 end - 1 之间的字符。
   • reverse()：反转 StringBuffer 中的字符顺序。
   • substring(int start) 和 substring(int start, int end)：返回 StringBuffer 的子字符串。
   • capacity()：返回当前分配给 StringBuffer 的容量。
   • ensureCapacity(int minimumCapacity)：确保 StringBuffer 的容量至少为指定的最小容量。
   • toString()：返回 StringBuffer 的当前字符串表示。
5. 性能考虑： 由于同步带来的开销，StringBuffer 的性能可能不如 StringBuilder（非线程安全的可变字符串类）。因此，如果你不需要线程安全，可以考虑使用 StringBuilder。
6. 示例代码：

StringBuffer sb = new StringBuffer("Hello"); sb.append(" World"); // "Hello World" sb.insert(5, " there"); // "Hello there World" sb.delete(5, 11); // "Hello World" sb.reverse(); // "dlroW olleH" System.out.println(sb.toString()); // 输出 "dlroW olleH" 

请注意，StringBuffer 是Java 1.0 引入的，随着Java的发展，一些新的API和特性可能已经出现，但 StringBuffer 仍然是处理多线程字符串操作的可靠选择。

StringBuilder 是Java中一个可变的字符串类，与 StringBuffer 类似，但它不是线程安全的。这意味着 StringBuilder 适合在单线程环境中使用，因为它的性能比 StringBuffer 更高，因为它没有同步的开销。
以下是 StringBuilder 的一些主要特点和用法：

1. 非线程安全： StringBuilder 不包含同步机制，因此在单线程环境中使用时，性能优于 StringBuffer。
2. 可变字符串： StringBuilder 允许对字符串进行修改，包括插入、删除、替换和追加操作。
3. 容量自动增长： 与 StringBuffer 类似，StringBuilder 内部维护了一个字符数组，如果字符串增长超出当前容量，它会自动增长。
4. 常用方法：
   • append(Object obj)：将对象的字符串表示追加到 StringBuilder 的末尾。
   • insert(int index, Object obj)：在指定位置插入对象的字符串表示。
   • delete(int start, int end)：删除从 start 到 end - 1 之间的字符。
   • reverse()：反转 StringBuilder 中的字符顺序。
   • substring(int start) 和 substring(int start, int end)：返回 StringBuilder 的子字符串。
   • capacity()：返回当前分配给 StringBuilder 的容量。
   • ensureCapacity(int minimumCapacity)：确保 StringBuilder 的容量至少为指定的最小容量。
   • toString()：返回 StringBuilder 的当前字符串表示。
5. 性能考虑： 由于 StringBuilder 不是线程安全的，所以在多线程环境中使用时，需要额外的同步措施，或者考虑使用 StringBuffer。
6. 示例代码：

StringBuilder sb = new StringBuilder("Hello"); sb.append(" World"); // "Hello World" sb.insert(5, " there"); // "Hello there World" sb.delete(5, 11); // "Hello World" sb.reverse(); // "dlroW olleH" System.out.println(sb.toString()); // 输出 "dlroW olleH" 

7. API 变更： StringBuilder 是Java 5引入的，它提供了与 StringBuffer 类似的API，但是没有同步机制。如果你的代码不需要线程安全，推荐使用 StringBuilder 来提高性能。

总结：在多线程环境时为确保安全使用StringBuffer方法，在单线程环境时使用StringBuilder。