Java中String类有哪些使用方法

目录

1. String类概述
2. String类的构造方法
3. String类的常用方法
   • 字符串长度
   • 字符串比较
   • 字符串查找
   • 字符串截取
   • 字符串替换
   • 字符串分割
   • 字符串连接
   • 字符串大小写转换
   • 字符串去空格
   • 字符串格式化
   • 字符串转换为其他类型
   • 其他常用方法
4. String类的不可变性
5. StringBuffer和StringBuilder
6. 总结

String类概述

在Java中，String类是一个非常重要的类，用于表示和操作字符串。字符串是字符序列，String类提供了丰富的方法来操作这些字符序列。由于字符串在Java中是不可变的，因此每次对字符串的操作都会生成一个新的字符串对象。

String类的构造方法

String类提供了多种构造方法，用于创建字符串对象。以下是一些常用的构造方法：

1. 无参构造方法：

   String str = new String();
   

   创建一个空的字符串对象。

2. 使用字符数组构造方法：

   char[] charArray = {'H', 'e', 'l', 'l', 'o'};
   String str = new String(charArray);
   

   使用字符数组创建一个字符串对象。

3. 使用字节数组构造方法：

   byte[] byteArray = {72, 101, 108, 108, 111};
   String str = new String(byteArray);
   

   使用字节数组创建一个字符串对象。

4. 使用字符串字面量构造方法：

   String str = new String("Hello");
   

   使用字符串字面量创建一个字符串对象。

5. 使用StringBuffer或StringBuilder构造方法：

   StringBuffer sb = new StringBuffer("Hello");
   String str = new String(sb);
   

   使用StringBuffer或StringBuilder对象创建一个字符串对象。

String类的常用方法

字符串长度

1. length()：

   
   String str = "Hello";
   int length = str.length(); // 返回5
   

   返回字符串的长度。

字符串比较

1. equals(Object obj)：

   String str1 = "Hello";
   String str2 = "Hello";
   boolean isEqual = str1.equals(str2); // 返回true
   

   比较两个字符串的内容是否相等。

2. equalsIgnoreCase(String str)：

   String str1 = "Hello";
   String str2 = "hello";
   boolean isEqual = str1.equalsIgnoreCase(str2); // 返回true
   

   忽略大小写比较两个字符串的内容是否相等。

3. compareTo(String str)：

   String str1 = "Hello";
   String str2 = "World";
   int result = str1.compareTo(str2); // 返回负数，表示str1小于str2
   

   按字典顺序比较两个字符串。

4. compareToIgnoreCase(String str)：

   String str1 = "Hello";
   String str2 = "hello";
   int result = str1.compareToIgnoreCase(str2); // 返回0，表示相等
   

   忽略大小写按字典顺序比较两个字符串。

字符串查找

1. charAt(int index)：

   String str = "Hello";
   char ch = str.charAt(1); // 返回'e'
   

   返回指定索引处的字符。

2. indexOf(int ch)：

   String str = "Hello";
   int index = str.indexOf('e'); // 返回1
   

   返回指定字符在字符串中第一次出现的索引。

3. indexOf(String str)：

   String str = "Hello World";
   int index = str.indexOf("World"); // 返回6
   

   返回指定子字符串在字符串中第一次出现的索引。

4. lastIndexOf(int ch)：

   String str = "Hello";
   int index = str.lastIndexOf('l'); // 返回3
   

   返回指定字符在字符串中最后一次出现的索引。

5. lastIndexOf(String str)：

   String str = "Hello World";
   int index = str.lastIndexOf("o"); // 返回7
   

   返回指定子字符串在字符串中最后一次出现的索引。

字符串截取

1. substring(int beginIndex)：

   String str = "Hello World";
   String subStr = str.substring(6); // 返回"World"
   

   返回从指定索引开始到字符串末尾的子字符串。

2. substring(int beginIndex, int endIndex)：

   String str = "Hello World";
   String subStr = str.substring(0, 5); // 返回"Hello"
   

   返回从指定开始索引到结束索引之间的子字符串。

字符串替换

1. replace(char oldChar, char newChar)：

   String str = "Hello";
   String newStr = str.replace('l', 'L'); // 返回"HeLLo"
   

   替换字符串中所有指定的字符。

2. replace(CharSequence target, CharSequence replacement)：

   String str = "Hello World";
   String newStr = str.replace("World", "Java"); // 返回"Hello Java"
   

   替换字符串中所有指定的子字符串。

字符串分割

1. split(String regex)：

   String str = "Hello,World,Java";
   String[] parts = str.split(","); // 返回["Hello", "World", "Java"]
   

   根据指定的正则表达式分割字符串。

2. split(String regex, int limit)：

   String str = "Hello,World,Java";
   String[] parts = str.split(",", 2); // 返回["Hello", "World,Java"]
   

   根据指定的正则表达式和限制次数分割字符串。

字符串连接

1. concat(String str)：

   String str1 = "Hello";
   String str2 = "World";
   String newStr = str1.concat(str2); // 返回"HelloWorld"
   

   将指定字符串连接到当前字符串的末尾。

2. +运算符：

   String str1 = "Hello";
   String str2 = "World";
   String newStr = str1 + str2; // 返回"HelloWorld"
   

   使用+运算符连接字符串。

字符串大小写转换

1. toLowerCase()：

   String str = "Hello";
   String lowerStr = str.toLowerCase(); // 返回"hello"
   

   将字符串转换为小写。

2. toUpperCase()：

   String str = "Hello";
   String upperStr = str.toUpperCase(); // 返回"HELLO"
   

   将字符串转换为大写。

字符串去空格

1. trim()：

   
   String str = "  Hello  ";
   String trimmedStr = str.trim(); // 返回"Hello"
   

   去除字符串两端的空格。

字符串格式化

1. format(String format, Object... args)：

   
   String str = String.format("Hello, %s!", "World"); // 返回"Hello, World!"
   

   使用指定的格式字符串和参数格式化字符串。

字符串转换为其他类型

1. toCharArray()：

   String str = "Hello";
   char[] charArray = str.toCharArray(); // 返回['H', 'e', 'l', 'l', 'o']
   

   将字符串转换为字符数组。

2. getBytes()：

   String str = "Hello";
   byte[] byteArray = str.getBytes(); // 返回[72, 101, 108, 108, 111]
   

   将字符串转换为字节数组。

3. valueOf(Object obj)：

   int num = 123;
   String str = String.valueOf(num); // 返回"123"
   

   将其他类型的对象转换为字符串。

其他常用方法

1. isEmpty()：

   String str = "";
   boolean isEmpty = str.isEmpty(); // 返回true
   

   判断字符串是否为空。

2. contains(CharSequence s)：

   String str = "Hello World";
   boolean contains = str.contains("World"); // 返回true
   

   判断字符串是否包含指定的子字符串。

3. startsWith(String prefix)：

   String str = "Hello World";
   boolean startsWith = str.startsWith("Hello"); // 返回true
   

   判断字符串是否以指定的前缀开头。

4. endsWith(String suffix)：

   String str = "Hello World";
   boolean endsWith = str.endsWith("World"); // 返回true
   

   判断字符串是否以指定的后缀结尾。

5. matches(String regex)：

   String str = "Hello";
   boolean matches = str.matches("H.*"); // 返回true
   

   判断字符串是否匹配指定的正则表达式。

String类的不可变性

在Java中，String类是不可变的，这意味着一旦创建了一个字符串对象，它的内容就不能被改变。每次对字符串的操作（如连接、替换等）都会生成一个新的字符串对象，而原始的字符串对象保持不变。

例如：

String str = "Hello";
str = str + " World"; // 创建一个新的字符串对象

由于字符串的不可变性，频繁的字符串操作可能会导致大量的临时对象产生，从而影响性能。在这种情况下，可以使用StringBuffer或StringBuilder类来进行字符串操作。

StringBuffer和StringBuilder

StringBuffer和StringBuilder类是可变的字符串类，它们提供了与String类相似的方法，但允许对字符串进行修改而不生成新的对象。

1. StringBuffer：

   StringBuffer sb = new StringBuffer("Hello");
   sb.append(" World"); // 修改原字符串
   String str = sb.toString(); // 返回"Hello World"
   

   StringBuffer是线程安全的，适合在多线程环境下使用。

2. StringBuilder：

   StringBuilder sb = new StringBuilder("Hello");
   sb.append(" World"); // 修改原字符串
   String str = sb.toString(); // 返回"Hello World"
   

   StringBuilder不是线程安全的，但在单线程环境下性能更好。

总结

String类是Java中用于表示和操作字符串的核心类。它提供了丰富的方法来操作字符串，但由于其不可变性，频繁的字符串操作可能会导致性能问题。在这种情况下，可以使用StringBuffer或StringBuilder类来进行字符串操作。理解String类及其相关类的使用方法，对于编写高效的Java程序至关重要。