Java String字符串

Java字符串通常被视为一种数据类型，但由于它们按顺序存储字符类型的元素，类似于数组，因此也常被视为数据结构。在本文中，我们将通过以下大纲简明地了解有关Java字符串的所有内容。

什么是Java字符串？
如何创建Java字符串？
创建可变字符串
Java字符串实现的接口
Java字符串的方法

什么是Java字符串？

我们可以将Java字符串定义为Java中的对象，用于按顺序存储字符。

例如：

char[] S = {'S', 'i', 'm', 'p', 'l', 'i', 'l', 'e', 'a', 'r', 'n'};
String str = new String(S);

或者：

String S = "Simplilearn";

现在我们已经学习了Java字符串的定义及其示例，接下来我们将了解如何在实际应用中创建Java字符串。

如何创建Java字符串？

创建Java字符串有两种不同的方法。为了提供更好的学习体验，我们将结合实例来学习这两种方法。

方法一 - 字符串字面量

可以通过使用字符串字面量方法来创建Java字符串，其语法如下：

String str = "Hello World";

在此方法中，使用双引号（"）是必须的。

每当您通过字符串字面量方法发出创建新字符串的命令时，Java虚拟机（JVM）会搜索字符串池中的字符串。如果字符串已存在，JVM将返回该字符串的引用；如果所需的字符串不在字符串池中，JVM则会根据用户的命令创建新的字符串。

方法二 - new关键字

在第二种方法中，我们使用’new’关键字来创建新的字符串。下面是创建唯一字符串所遵循的语法：

String str = new String("Hello World");

这里，字符串str将使用堆内存创建。然而，字面量"Hello World"存储在字符串池中。

现在我们已经理解了Java字符串以及如何使用两种不同方法及其语法创建它们。接下来，我们将了解如何创建可变的字符串。

创建可变的字符串

虽然 String 类本身是不可变的，但Java提供了两种主要的方式来构建可变的字符串：

StringBuilder
- StringBuilder 是一个线程不安全的可变字符串类，适用于单线程环境下的字符串拼接操作。由于不需要同步开销，因此在性能上优于 StringBuffer。
StringBuffer
- StringBuffer 是一个线程安全的可变字符串类，适用于多线程环境下的字符串拼接操作。它提供了与 StringBuilder 相同的方法，但所有的公共方法都进行了同步处理。

这两个类都实现了 CharSequence 接口，这意味着它们可以像 String 一样被用作字符序列，同时提供了更多的灵活性和性能优化选项。
在这里插入图片描述

示例代码

这里有一些简单的示例来展示如何使用 StringBuilder 和 StringBuffer：

// 使用 StringBuilder
StringBuilder sb = new StringBuilder();
sb.append("Hello ");
sb.append("World");
System.out.println(sb.toString()); // 输出: Hello World

// 使用 StringBuffer
StringBuffer sbf = new StringBuffer();
sbf.append("Hello ");
sbf.append("World");
System.out.println(sbf.toString()); // 输出: Hello World

Java字符串实现的接口

在Java中，String 类位于 java.lang 包内，它代表了不可变的字符序列。为了支持多种功能，String 类实现了以下几个接口：

Serializable
- Serializable 接口是一个标记接口，没有定义任何方法。当一个类实现了 Serializable 接口，意味着它的对象可以被序列化，即可以将对象的状态保存到文件中或通过网络传输。
Comparable
- Comparable 接口用于定义自然排序，比如数字的升序或字符串的字典顺序。String 类实现了 Comparable<String> 接口，这意味着 String 对象可以通过 compareTo 方法进行比较，这在集合排序时非常有用。
CharSequence
- CharSequence 是一个表示字符序列的接口。除了 String 类之外，CharSequence 还由其他几个类实现，如 StringBuffer 和 StringBuilder。这些类提供了可变字符串的功能，可以在不创建新对象的情况下修改字符串内容。

Java字符串的主要方法

以下是Java中提供的主要方法：

String charAt()

此方法用于返回字符串中指定索引位置的字符值。

语法:

public char charAt(int index)

示例:

package SimpliString;
public class StringDemo {
    public static void main(String args[]) {
        String name = "Simplilearn";
        char ch = name.charAt(5);
        System.out.println(ch); // 输出: i
    }
}

String compareTo()

此方法用于按字典顺序比较两个字符串。

语法:

public int compareTo(String anotherString)

示例:

package SimpliString;
public class StringDemo {
    public static void main(String args[]) {
        String s1 = "Simple";
        String s2 = "Simplilearn";
        String s3 = "Simplilearn";
        String s4 = "Learn";
        String s5 = "E-Learning";
        
        System.out.println(s1.compareTo(s2)); // 输出: -4
        System.out.println(s2.compareTo(s3)); // 输出: 0
        System.out.println(s1.compareTo(s4)); // 输出: 7
        System.out.println(s1.compareTo(s5)); // 输出: 14
    }
}

String concat()

此方法用于连接两个字符串。第二个字符串会被附加到第一个字符串的末尾。

语法:

public String concat(String str)

示例:

package SimpliString;
public class StringDemo {
    public static void main(String args[]) {
        String s1 = "Simplilearn ";
        s1 = s1.concat("Best in class E-Learning Platform");
        System.out.println(s1); // 输出: Simplilearn Best in class E-Learning Platform
    }
}

String contains()

此方法用于检查给定的字符串是否包含特定的字符或字符串片段。如果找到，则返回true；否则返回false。

语法:

public boolean contains(CharSequence s)

示例:

package SimpliString;
public class StringDemo {
    public static void main(String[] args) {
        String str = "Simplilearn E-Learning Platform";
        boolean isContains = str.contains("Simplilearn");
        System.out.println(isContains); // 输出: true
        System.out.println(str.contains("Simple")); // 输出: false
    }
}

String endsWith()

此方法用于检查字符串是否以特定的字符或字符序列结尾。如果是，则返回true；否则返回false。

语法:

public boolean endsWith(String suffix)

示例:

package SimpliString;
public class StringDemo {
    public static void main(String args[]) {
        String s1 = "Hello World. Welcome to Simplilearn";
        System.out.println(s1.endsWith("Simplilearn")); // 输出: true
    }
}

String equals()

此方法用于比较两个字符串是否相等。如果相等，则返回true；否则返回false。

语法:

public boolean equals(Object anObject)

示例:

package SimpliString;
public class StringDemo {
    public static void main(String args[]) {
        String s1 = "HelloWorld";
        String s2 = "HelloWorld";
        String s3 = "Welcome to Simplilearn";
        System.out.println(s1.equals(s2)); // 输出: true
        System.out.println(s1.equals(s3)); // 输出: false
    }
}

String format()

此方法用于打印给定字符串的格式化版本。

语法:

public static String format(String format, Object... args)

示例:

package SimpliString;
public class StringDemo {
    public static void main(String args[]) {
        String name = "simplilearn";
        String sf1 = String.format("String is %s", name);
        String sf2 = String.format("value is %f", 14.1234);
        String sf3 = String.format("value is %.12f", 14.1234);
        System.out.println(sf1); // 输出: String is simplilearn
        System.out.println(sf2); // 输出: value is 14.123400
        System.out.println(sf3); // 输出: value is 14.123400000000
    }
}

String equalsIgnoreCase()

此方法用于忽略大小写比较两个字符串。

语法:

public boolean equalsIgnoreCase(String anotherString)

示例:

package SimpliString;
public class StringDemo {
    public static void main(String args[]) {
        String s1 = "Simplilearn";
        String s2 = "SIMPLILEARN";
        System.out.println(s1.equalsIgnoreCase(s2)); // 输出: true
    }
}

String getBytes()

此方法用于获取给定字符串的字节数组。

语法:

public byte[] getBytes()

示例:

package SimpliString;
public class StringDemo {
    public static void main(String args[]) {
        String s1 = "SIMPLILEARN";
        byte[] byteArray = s1.getBytes();
        for (byte b : byteArray) {
            System.out.println(b);
        }
    }
}

String getChars()

此方法用于将给定字符串的内容复制到字符数组中。

语法:

public void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

示例:

package SimpliString;
public class StringDemo {
    public static void main(String args[]) {
        String str = "Welcome to Simplilearn";
        char[] ch = new char[10];
        try {
            str.getChars(5, 11, ch, 0);
            System.out.println(ch); // 输出: me to
        } catch (Exception ex) {
            System.out.println(ex);
        }
    }
}

String indexOf()

此方法用于返回字符串中指定字符或子字符串首次出现的位置。如果未找到，则返回-1。

语法:

public int indexOf(String str)

示例:

package SimpliString;
public class StringDemo {
    public static void main(String args[]) {
        String s1 = "Hello World, Welcome to Simplilearn";
        int ind1 = s1.indexOf("World");
        System.out.println(ind1); // 输出: 6
        int ind3 = s1.indexOf("to", 4);
        System.out.println(ind3); // 输出: 20
        int index4 = s1.indexOf('S');
        System.out.println(index4); // 输出: 23
    }
}

String intern()

此方法用于将给定字符串转换为一个规范化的内部字符串形式，并返回该形式。

语法:

public String intern()

示例:

package SimpliString;
public class StringDemo {
    public static void main(String args[]) {
        String s1 = new String("Simplilearn");
        String s2 = "Simplilearn";
        String s3 = s1.intern();
        System.out.println(s1 == s2); // 输出: false
        System.out.println(s2 == s3); // 输出: true
    }
}

String isEmpty()

此方法用于检查给定字符串是否为空。如果字符串为空，则返回true；否则返回false。

语法:

public boolean isEmpty()

示例:

package SimpliString;
public class StringDemo {
    public static void main(String args[]) {
        String s1 = "";
        String s2 = "Simplilearn";
        System.out.println(s1.isEmpty()); // 输出: true
        System.out.println(s2.isEmpty()); // 输出: false
    }
}

String join()

此方法用于将给定的字符串通过指定的分隔符连接起来。

语法:

public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

示例:

package SimpliString;
public class StringJoinDemo {
    public static void main(String args[]) {
        String joinString1 = String.join("-", "Welcome", "to", "Simplilearn");
        System.out.println(joinString1); // 输出: Welcome-to-Simplilearn
    }
}

String lastIndexOf()

此方法用于返回给定字符或字符串在字符串中最后出现的位置。如果未找到，则返回-1。

语法:

public int lastIndexOf(int ch)
public int lastIndexOf(String str)

示例:

package SimpliString;
public class StringLastIndexDemo {
    public static void main(String args[]) {
        String s1 = "Hello World. Welcome to Simplilearn";
        int indexV = s1.lastIndexOf('S');
        System.out.println(indexV); // 输出: 24
    }
}

String length()

此方法用于获取给定字符串的长度，即字符串中字符的数量。

语法:

public int length()

示例:

package SimpliString;
public class StringLengthDemo {
    public static void main(String args[]) {
        String s1 = "Simplilearn";
        System.out.println("字符串的长度是: " + s1.length()); // 输出: 字符串的长度是: 11
    }
}

String replace()

此方法用于将字符串中的旧字符序列替换为新的字符序列。

语法:

public String replace(char oldChar, char newChar)
public String replace(CharSequence target, CharSequence replacement)

示例:

package SimpliString;
public class StringReplaceDemo {
    public static void main(String args[]) {
        String s1 = "Hello World, Welcome to Java";
        String replaceString = s1.replace('W', 'H');
        System.out.println(replaceString); // 输出: Hello Horld, Helcome to Java
    }
}

String replaceAll()

此方法用于返回一个新的字符串，其中原字符串中的所有匹配正则表达式的字符序列都被替换成新的字符串。

语法:

public String replaceAll(String regex, String replacement)

示例:

package SimpliString;
public class StringReplaceAllDemo {
    public static void main(String args[]) {
        String s1 = "Hello World Welcome to Simplilearn";
        String replaceString = s1.replaceAll("l", "a");
        System.out.println(replaceString); // 输出: Heaao Worad Weacome to Simpaiaearn
    }
}

String split()

此方法用于按照给定的正则表达式分割当前字符串，并返回一个字符串数组。

语法:

public String[] split(String regex)
public String[] split(String regex, int limit)

示例:

package SimpliString;
public class StringSplitDemo {
    public static void main(String args[]) {
        String s1 = "Hello World Welcome to Simplilearn";
        String[] words = s1.split("\\s");
        for (String w : words) {
            System.out.println(w); // 分别输出: Hello, World, Welcome, to, Simplilearn
        }
    }
}

String startsWith()

此方法用于检查当前字符串是否以给定的前缀开始。如果以给定前缀开始，则返回true；否则返回false。

语法:

public boolean startsWith(String prefix)

示例:

package SimpliString;
public class StringStartsWithDemo {
    public static void main(String args[]) {
        String s1 = "Hello World";
        System.out.println(s1.startsWith("Hell")); // 输出: true
        System.out.println(s1.startsWith("Java")); // 输出: false
    }
}

String toCharArray()

此方法用于将字符串转换成字符数组。新字符数组的索引值与原字符串相同。

语法:

public char[] toCharArray()

示例:

package SimpliString;
public class StringToCharArrayDemo {
    public static void main(String args[]) {
        String s1 = "Simplilearn";
        char[] ch = s1.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            System.out.print(ch[i]); // 输出: Simplilearn
        }
    }
}

String toUpperCase()

此方法用于将字符串中的所有小写字母转换为大写字母。

语法:

public String toUpperCase()

示例:

package SimpliString;
public class StringToUpperDemo {
    public static void main(String args[]) {
        String s1 = "Simplilearn";
        String s1upper = s1.toUpperCase();
        System.out.println(s1upper); // 输出: SIMPLILEARN
    }
}

String toLowerCase()

此方法用于将字符串中的所有大写字母转换为小写字母。

语法:

public String toLowerCase()

示例:

package SimpliString;
public class StringToLowerDemo {
    public static void main(String args[]) {
        String s1 = "SIMPLIlearn";
        String s1lower = s1.toLowerCase();
        System.out.println(s1lower); // 输出: simplilearn
    }
}

String trim()

此方法用于去除给定字符串首尾的空白字符。

语法:

public String trim()

示例:

package SimpliString;
public class StringTrimDemo {
    public static void main(String args[]) {
        String s1 = " Hello World ";
        System.out.println(s1.trim() + " Welcome to Simplilearn"); // 输出: Hello World Welcome to Simplilearn
    }
}

String valueOf()

此方法用于将不同的数值或其他数据类型的值转换成字符串。

语法:

public static String valueOf(int i)
public static String valueOf(double d)
public static String valueOf(boolean b)
public static String valueOf(char c)
public static String valueOf(Object obj)

示例:

package SimpliString;
public class StringValueOfDemo {
    public static void main(String args[]) {
        int value = 100;
        String s1 = String.valueOf(value);
        System.out.println(s1 + 299); // 输出: 100299
    }
}

以上就是Java字符串的一些基本方法，掌握了这些方法可以帮助您更好地处理字符串相关的问题。

总结

1. 基本概念

不可变性：String 类是不可变的，一旦创建了一个 String 对象，其内容就不能改变。每次对字符串进行修改（如拼接、替换等）都会创建一个新的 String 对象。
线程安全：由于 String 是不可变的，因此它是线程安全的，多个线程可以共享同一个 String 对象而不会发生数据不一致的问题。

2. 实现的接口

Serializable：String 类实现了 Serializable 接口，这意味着 String 对象可以被序列化，即可以将对象的状态保存到文件中或通过网络传输。
Comparable：String 类实现了 Comparable<String> 接口，允许 String 对象之间进行自然排序（字典顺序）。
CharSequence：String 类实现了 CharSequence 接口，表示它可以作为一个字符序列被处理。其他实现 CharSequence 接口的类包括 StringBuilder 和 StringBuffer。

3. 常用方法

charAt(int index)：返回指定索引处的字符。
compareTo(String anotherString)：按字典顺序比较两个字符串。
concat(String str)：将指定的字符串连接到当前字符串的末尾。
contains(CharSequence s)：检查当前字符串是否包含指定的字符序列。
endsWith(String suffix)：检查当前字符串是否以指定的后缀结束。
equals(Object anObject)：检查当前字符串是否与指定的对象相等。
equalsIgnoreCase(String anotherString)：忽略大小写比较两个字符串。
getBytes()：将字符串转换为字节数组。
getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)：将字符串的一部分复制到字符数组中。
indexOf(String str)：返回指定子字符串在当前字符串中第一次出现的索引。
intern()：返回字符串池中的规范形式。
isEmpty()：检查字符串是否为空。
join(CharSequence delimiter, Iterable<? extends CharSequence> elements)：使用指定的分隔符连接多个字符串。
lastIndexOf(String str)：返回指定子字符串在当前字符串中最后一次出现的索引。
length()：返回字符串的长度。
replace(char oldChar, char newChar)：将字符串中的旧字符替换为新字符。
replaceAll(String regex, String replacement)：使用正则表达式替换字符串中的匹配项。
split(String regex)：根据正则表达式分割字符串。
startsWith(String prefix)：检查当前字符串是否以指定的前缀开始。
toCharArray()：将字符串转换为字符数组。
toLowerCase()：将字符串转换为小写。
toUpperCase()：将字符串转换为大写。
trim()：去除字符串首尾的空白字符。
valueOf(Object obj)：将对象转换为字符串。

4. 可变字符串

StringBuilder：线程不安全的可变字符串类，适用于单线程环境下的字符串拼接操作。
StringBuffer：线程安全的可变字符串类，适用于多线程环境下的字符串拼接操作。

5. 字符串常量池

字符串常量池：Java虚拟机（JVM）为每个类维护一个字符串常量池，用于存储字符串字面量和通过 intern() 方法创建的字符串。字符串常量池中的字符串是唯一的，这意味着相同的字符串字面量只会存储一次。

6. 性能考虑

避免频繁的字符串拼接：由于 String 是不可变的，频繁的字符串拼接会导致大量的临时对象创建，影响性能。在这种情况下，建议使用 StringBuilder 或 StringBuffer。
使用 equals() 而不是 ==：== 操作符用于比较对象引用，而 equals() 方法用于比较对象的内容。除非你明确需要比较引用，否则应使用 equals() 方法。

希望这个总结能帮助你更好地理解和使用Java中的字符串。