Java中String类常用的各种方法

Java中String类常见的方法

以下介绍字符串常见的几个方法。

介绍String类

在 Java 中，String 类是一个代表字符串的类，具有以下特性：

1. 不可变性：String 对象一旦被创建就是不可变的，即它们的值在创建后不能被更改。任何对 String 对象的修改操作实际上会创建一个新的 String 对象。

2. 字符串池：Java 中的字符串池是一种特殊的内存区域，用于存储字符串常量。当创建一个字符串时，它会首先检查字符串常量池中是否已经存在相同值的字符串，如果存在，则返回池中的字符串引用，而不会创建新的对象。

3. 比较：字符串可以通过 equals() 方法来比较它们的内容是否相同。在 Java 中，使用 equals() 比较字符串内容，而不是使用 == 来比较对象引用是否相等。

4. 不可变性带来的安全性：由于字符串是不可变的，它们可以作为参数安全地传递给方法，以免被意外地修改。

5. 性能：由于字符串是不可变的，它们可以被缓存起来重复利用，并且字符串连接的过程中可以使用 StringBuilder 或 StringBuffer 类来提高性能。

6. 字符串操作方法：String 类提供了许多方法用于对字符串进行操作，比如 length()、charAt(index)、substring() 等等，这些方法可以帮助开发人员方便地处理字符串。

总的来说，String 类在 Java 中具有重要的作用，是开发中经常使用的类之一。它的不可变性和字符串池特性使得字符串的处理更加安全和高效。

1.拼接：

在 Java 中，String 类的 concat() 方法和 + 操作符都用于拼接字符串。这两种方法都能够将两个字符串连接起来形成一个新的字符串，但有一些微小的区别：

1. concat() 方法：concat() 方法是 String 类的实例方法，用于将指定的字符串连接到调用该方法的字符串的末尾。它返回一个新的字符串对象，原始字符串不受影响。例如：

String str1 = "Hello";
String str2 = "World";
String result = str1.concat(str2); // 结果为 "HelloWorld"

2. + 操作符：+ 操作符也可以用于字符串拼接，它可以连接两个字符串（也可以连接字符串和其他数据类型，会进行类型转换），这种方式在 Java 中比较常见。例如：

String str1 = "Hello";
String str2 = "World";
String result = str1 + str2; // 结果为 "HelloWorld"

主要区别在于语法形式，使用操作符 + 时，其实是通过对 String 类的 concat() 方法进行隐式调用来实现字符串拼接。

在实际开发中，+ 操作符更为常用，因为它更直观，而且可以与其他数据类型混合使用，如：

String name = "Alice";
int age = 30;
String message = "My name is " + name + " and I am " + age + " years old.";

以上代码中，+ 操作符不仅连接了多个字符串，还将整数类型转换为字符串，形成了完整的输出信息。

总的来说，无论是使用 concat() 方法还是 + 操作符，最终目的都是将多个字符串连接成一个新的字符串。

2.比较字符串是否相等：

当我们想要比较两个字符串是否相同时，要特别注意，我们实际上是想比较字符串的内容是否相同。必须使用equals()方法而不能用==。

我们看下面的例子：

// String
public class Main {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
    }
}

从表面上看，两个字符串用==和equals()比较都为true，但实际上那只是Java编译器在编译期，会自动把所有相同的字符串当作一个对象放入常量池，自然s1和s2的引用就是相同的。

所以，这种==比较返回true纯属巧合。换一种写法，==比较就会失败：

// String
public class Main {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO".toLowerCase();
        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
    }
}

结论：两个字符串比较，必须总是使用equals()方法。

3.比较字符串的大小：

在 Java 中，String 类提供了 compareTo() 方法和 compareToIgnoreCase() 方法用于比较字符串之间的大小关系。这两个方法返回整数值，用于表示两个字符串之间的按字典排序的关系。以下是它们的介绍：

1. compareTo() 方法：

   • compareTo() 方法用于按字典顺序比较两个字符串，并返回一个整数值，根据比较结果不同返回不同的值：
     • 如果调用字符串小于参数字符串，则返回负整数。
     • 如果调用字符串大于参数字符串，则返回正整数。
     • 如果两个字符串相等，则返回0。
   • 示例：

   String str1 = "apple";
   String str2 = "banana";
   int result = str1.compareTo(str2);
   // result 小于 0，因为 "apple" 在字典顺序中排在 "banana" 之前
   

2. compareToIgnoreCase() 方法：

   • compareToIgnoreCase() 方法也用于按字典顺序比较两个字符串，并返回一个整数值。与 compareTo() 不同的是，compareToIgnoreCase() 方法在比较时不区分大小写。
   • 示例：

   String str1 = "apple";
   String str2 = "Banana";
   int result = str1.compareToIgnoreCase(str2);
   // result 小于 0，因为 "apple" 在忽略大小写并按字典顺序中排在 "Banana" 之前
   

这些方法是基于 Unicode 值来比较字符串的。在比较字符串时，JVM会逐个比较字符串中对应位置上的字符的 Unicode 值。如果在某个位置发现不同的字符，则根据这些字符的 Unicode 值来确定整体的大小关系。

总的来说，compareTo() 和 compareToIgnoreCase() 方法都是在对字符串进行比较排序时非常有用的工具，可以帮助我们确定字符串在字典序中的位置关系。

4.截取字符串

在 Java 中，String 类的 substring() 方法用于从原始字符串中提取子字符串。这个方法有两个重载形式，一个是通过指定开始索引的方式提取子字符串，另一个是同时指定开始索引和结束索引来提取子字符串。下面是关于这两种形式的介绍：

1. substring(int beginIndex) 方法：

   • 这个方法接受一个整数参数 beginIndex，表示子字符串的起始索引（包括 beginIndex 对应的字符）。
   • 返回一个新的字符串，包含从 beginIndex 到原始字符串结尾的所有字符。
   • 示例：

   String str = "Hello, World!";
   String subStr = str.substring(7); // subStr 等于 "World!"
   

2. substring(int beginIndex, int endIndex) 方法：

   • 这个方法接受两个整数参数 beginIndex 和 endIndex，分别表示子字符串的起始索引（包括 beginIndex 对应的字符）和结束索引（不包括 endIndex 对应的字符）。
   • 返回一个新的字符串，包含在 beginIndex 和 endIndex 之间的字符（不包括 endIndex 对应的字符）。
   • 示例：

   String str = "Hello, World!";
   String subStr = str.substring(7, 12); // subStr 等于 "World"
   

需要注意的是，beginIndex 表示子字符串的起始索引，而 endIndex 是不包含在子字符串内的。如果需要提取整个字符串，可以不指定 endIndex，这样会提取从 beginIndex 到字符串末尾的所有字符。

在使用 substring() 方法时，必须确保提供的索引在有效范围内，否则会抛出 IndexOutOfBoundsException 异常。这个方法在处理字符串时经常用到，可以帮助我们从一个较长的字符串中提取需要的子串。

5.去除首尾空格

在 Java 中，String 类中的 trim() 方法和 split() 方法是常用的字符串处理方法，用于去除字符串的空白字符和拆分字符串成为子字符串。以下是它们的介绍：

1. trim() 方法：

   • trim() 方法用于去除字符串的首尾空白字符（空格、制表符、换行符等），返回一个新的字符串，不修改原始字符串。
   • 示例：

   String str = "   Hello, World!    ";
   String trimmedStr = str.trim(); // trimmedStr 等于 "Hello, World!"
   

   • 注意：trim() 方法只去除首尾的空白字符，中间的空白字符不会被删除。

6.用指定的字符分隔字符串

split() 方法：

• split() 方法根据指定的分隔符将字符串拆分成子字符串，返回一个字符串数组。
• 可以提供一个正则表达式作为分隔符，或者直接提供一个普通字符串作为分隔符。
• 该方法支持传入一个限制参数，用于限制拆分得到的字符串数组的长度。
• 示例：

String str = "apple,banana,grape,orange";
String[] fruits = str.split(",");
// fruits 数组包含 ["apple", "banana", "grape", "orange"]

// 使用限制参数，最多拆分出两个子字符串
String[] firstTwoFruits = str.split(",", 2);
// firstTwoFruits 数组包含 ["apple", "banana,grape,orange"]

• 如果分隔符在字符串的开头或结尾，则 split() 方法会在结果数组中产生空字符串。如果不想包含空字符串，可以结合使用正则表达式 \\s*,\\s* 来去除可能存在的空格。

这两个方法是 Java 中经常用到的字符串处理方法，能够帮助我们对字符串进行清洗、分割等操作，使得字符串处理更加方便和灵活。

7.替换

在 Java 中，String 类中的 replace() 和 replaceAll() 方法都用于替换字符串中的字符或子字符串，但它们有一些区别。以下是它们的介绍：

1. replace() 方法：

   • replace() 方法用于将指定字符或字符序列替换为新的字符或字符序列。
   • 这个方法有两个重载形式：一种接受两个字符参数，另一种接受两个字符串参数。
   • 示例：

   String str1 = "Hello, World!";
   String replacedStr1 = str1.replace('o', '*'); // replacedStr1 等于 "Hell*, W*rld!"
   
   String str2 = "apple,banana,orange";
   String replacedStr2 = str2.replace(",", ";"); // replacedStr2 等于 "apple;banana;orange"
   

2. replaceAll() 方法：

   • replaceAll() 方法用于使用正则表达式替换字符串中的字符或字符序列。
   • 这个方法接受两个参数：一个正则表达式用于匹配，一个字符串用于替换匹配到的内容。
   • 示例：

   String str = "Hello, World!";
   String replacedStr = str.replaceAll("o", "*"); // replacedStr 等于 "Hell*, W*rld!"
   

   • 正则表达式的强大之处在于可以实现更复杂的匹配和替换逻辑，例如替换所有数字或特定模式的字符。
   • replaceAll的第一个参数是替换规则。
   • 示例：

   String str="hello world zhangsan";
   String temp=str.replaceAll("world|zhangsan","Java");
   

关于两者的区别：

• replace() 方法的参数是普通的字符或字符序列，不支持正则表达式，因此只能替换具体的字符或子字符串。
• replaceAll() 方法的第一个参数是正则表达式，因此可以进行更灵活、复杂的匹配和替换操作。这使得 replaceAll() 可以替换更广泛的模式，而不仅限于具体的字符或子字符串替换。

通过使用 replace() 和 replaceAll() 方法，我们可以轻松地对字符串进行替换操作，从而实现各种处理需求。

8.转换大小写

在 Java 中，toLowerCase() 和 toUpperCase() 方法是用于将字符串转换为小写和大写形式的方法。以下是它们的介绍：

1. toLowerCase() 方法：

   • toLowerCase() 方法用于将字符串中的所有字符转换为小写形式。
   • 这个方法不会修改原始字符串，而是返回一个新的字符串，其中所有字符都被转换为小写。
   • 示例：

   String str = "Hello, World!";
   String lowerCaseStr = str.toLowerCase(); // lowerCaseStr 等于 "hello, world!"
   

2. toUpperCase() 方法：

   • toUpperCase() 方法用于将字符串中的所有字符转换为大写形式。
   • 类似于 toLowerCase() 方法，toUpperCase() 也不会修改原始字符串，而是返回一个新的字符串，其中所有字符都被转换为大写。
   • 示例：

   String str = "Hello, World!";
   String upperCaseStr = str.toUpperCase(); // upperCaseStr 等于 "HELLO, WORLD!"
   

这两个方法非常实用，可以用于在不改变原始字符串的情况下，将字符串内容统一转换为相应的大小写形式。在许多文本处理的情景中，这些转换操作是很常见的。

一些需要注意的地方：

• 这两个方法会考虑转换为每个字符的对应大小写形式。在某些语言或特殊情况下，这种转换可能会产生一些意想不到的结果，因此需要谨慎使用。
• 在进行大小写转换时，需要考虑不同语言的特殊字符和转换规则，以确保转换的准确性。

9.查询字符串中一个字串出现的起始位置

在 Java 中，indexOf() 和 lastIndexOf() 方法用于在字符串中查找特定子字符串第一次出现的位置和最后一次出现的位置。以下是它们的介绍：

1. indexOf() 方法：

   • indexOf() 方法用于在字符串中查找指定子字符串第一次出现的位置。
   • 可以选择提供子字符串和（可选）起始搜索位置作为参数。
   • 如果找到子字符串，则返回该子字符串第一次出现的索引；如果未找到，则返回 -1。
   • 示例：

   String str = "Hello, World!";
   int index = str.indexOf("o"); // 返回 4，因为第一个 "o" 出现在索引位置 4
   

2. lastIndexOf() 方法：

   • lastIndexOf() 方法用于在字符串中查找指定子字符串最后一次出现的位置。
   • 可以选择提供子字符串和（可选）起始搜索位置作为参数。
   • 如果找到子字符串，则返回该子字符串最后一次出现的索引；如果未找到，则返回 -1。
   • 示例：

   String str = "Hello, World!";
   int index = str.lastIndexOf("o"); // 返回 8，因为最后一个 "o" 出现在索引位置 8
   

这两个方法对于在字符串中查找特定子字符串的位置非常有用。如果您想要知道子字符串在字符串中的位置或者需要定位特定字符的位置，indexOf() 和 lastIndexOf() 是很方便的工具。记住，索引是从0开始计数的，即第一个字符的索引为0。

10.查询字符串中是否包含另一个子串

在 Java 中，contains() 方法用于检查一个字符串是否包含另一个指定的子字符串。以下是它的介绍：

• contains() 方法:

  • contains() 方法用于检查字符串中是否包含指定的子字符串。

  • 如果包含指定的子字符串，则返回 true；如果不包含，则返回 false。

  • 这个方法是区分大小写的，因此在比较时会考虑字符的大小写情况。

  • 示例：

    String str = "Hello, World!";
    boolean contains1 = str.contains("Hello"); // 返回 true，因为字符串中包含子字符串 "Hello"
    boolean contains2 = str.contains("world"); // 返回 false，因为字符串中不包含子字符串 "world"（大小写不匹配）
    

contains() 方法通常用于检查一个字符串是否包含另一个字符串，以便在逻辑判断或执行某些操作时确定是否存在特定内容。作为字符串类的一部分，这个方法是字符串操作中非常常用的一个函数。

请注意，contains() 方法只检查是否包含指定的子字符串，而不提供子字符串的位置。如果您需要找到子字符串的位置，应该使用 indexOf() 或 lastIndexOf() 方法。

11.查询字符串是否是以一个子串开头，或是以一个子串结尾

在 Java 中，startsWith() 方法和 endsWith() 方法用于检查字符串是否以指定的前缀开头或者以指定的后缀结尾。以下是它们的介绍：

1. startsWith() 方法:

   • startsWith() 方法用于检查字符串是否以指定的前缀开头。
   • 接受一个参数，即要检查的前缀字符串。
   • 如果字符串以指定的前缀开头，则返回 true；否则返回 false。
   • 比较是区分大小写的。
   • 示例：

   String str = "Hello, World!";
   boolean startsWithHello = str.startsWith("Hello"); // 返回 true，因为字符串以 "Hello" 开头
   boolean startsWithHi = str.startsWith("Hi"); // 返回 false，因为字符串不以 "Hi" 开头
   

2. endsWith() 方法:

   • endsWith() 方法用于检查字符串是否以指定的后缀结尾。
   • 接受一个参数，即要检查的后缀字符串。
   • 如果字符串以指定的后缀结尾，则返回 true；否则返回 false。
   • 比较是区分大小写的。
   • 示例：

   String str = "Hello, World!";
   boolean endsWithWorld = str.endsWith("World!"); // 返回 true，因为字符串以 "World!" 结尾
   boolean endsWithJava = str.endsWith("Java"); // 返回 false，因为字符串不以 "Java" 结尾
   

startsWith() 和 endsWith() 方法常用于检查字符串的特定前缀和后缀，这对于处理文件扩展名、URL等具有特定格式的字符串时非常有用。这些方法提供了检查字符串开头和结尾的简单而有效的方式。

12.判断字符串是否为空

在 Java 中，isEmpty() 方法用于检查一个字符串是否为空，即其长度是否为0。以下是它的介绍：

• isEmpty() 方法:

  • isEmpty() 方法用于检查字符串是否为空，即字符串的长度是否为0。

  • 如果字符串为空，则返回 true；如果字符串不为空（长度大于0），则返回 false。

  • 示例：

    String str1 = ""; // 空字符串
    String str2 = "Hello, World!"; // 非空字符串
    
    boolean empty1 = str1.isEmpty(); // 返回 true，因为字符串为空
    boolean empty2 = str2.isEmpty(); // 返回 false，因为字符串不为空
    

isEmpty() 方法通常用于检查字符串是否包含任何字符。这是一个方便的方法，特别适用于需要确保字符串不包含任何内容时。在一些情况下，避免尝试处理空字符串可以提高代码的健壮性，因此在需要时应该使用这个方法来验证字符串是否为空。