Java 字符串 String 详解

Java String 是使用最广泛的类之一。Java String 类在java.langpackage.json 中定义。

Java字符串

• 基本上，字符串是一个字符序列，但它不是原始类型。
• 当我们在java中创建一个字符串时，它实际上创建了一个String类型的对象。
• 字符串是不可变对象，这意味着它一旦创建就无法更改。
• String 是 Java 中唯一支持运算符重载的类。我们可以使用 + 运算符连接两个字符串。例如"a"+"b"="ab"。
• Java 为字符串操作提供了两个有用的类—— StringBuffer和StringBuilder。

创建字符串的不同方法

在java中有很多创建字符串对象的方法，下面给出了一些流行的方法。

1. 使用字符串文字

   这是创建字符串的最常见方式。在这种情况下，字符串文字用双引号括起来。

   String str = "abc"; 

当我们使用双引号创建一个字符串时，JVM 会在字符串池中查找是否有任何其他字符串使用相同的值存储。如果找到，它只返回对该 String 对象的引用，否则它会创建一个具有给定值的新 String 对象并将其存储在 String 池中。

2. 使用新关键字

   我们可以使用 new 运算符创建 String 对象，就像任何普通的 Java 类一样。String 类中有几个构造函数可用于从字符数组、字节数组、StringBuffer 和 StringBuilder 中获取 String。

   String str  =  new String("abc");
   char[] a = {'a', 'b', 'c'};
   String str2  =  new String(a);

Java 字符串比较

String类提供了equals()和equalsIgnoreCase()方法来比较两个字符串。这些方法比较字符串的值以检查两个字符串是否相等。true如果两个字符串相等，false则返回，否则返回。

package com.journaldev.string.examples;

/**
 * Java String Example
 * 
 * @author pankaj
 *
 */
public class StringEqualExample {

    public static void main(String[] args) {
        //creating two string object
        String s1 = "abc";
        String s2 = "abc";
        String s3 = "def";
        String s4 = "ABC";

        System.out.println(s1.equals(s2));//true
        System.out.println(s2.equals(s3));//false

        System.out.println(s1.equals(s4));//false;
        System.out.println(s1.equalsIgnoreCase(s4));//true
    }

}

上述程序的输出是：

true
false
false
true

String 类实现了Comparable接口，该接口提供compareTo()和compareToIgnoreCase() 方法，并按字典顺序比较两个字符串。

两个字符串都被转换成 Unicode 值进行比较，并返回一个可以大于、小于或等于零的整数值。如果字符串相等，则返回零，否则返回大于或小于零。

package com.journaldev.examples;

/**
 * Java String compareTo Example
 * 
 * @author pankaj
 *
 */
public class StringCompareToExample {

    public static void main(String[] args) {

        String a1 = "abc";
        String a2 = "abc";
        String a3 = "def";
        String a4 = "ABC";

        System.out.println(a1.compareTo(a2));//0
        System.out.println(a2.compareTo(a3));//less than 0
        System.out.println(a1.compareTo(a4));//greater than 0
        System.out.println(a1.compareToIgnoreCase(a4));//0
    }

}

上述程序的输出是：

0
-3
32
0

Java 字符串方法

让我们通过示例程序来看看一些流行的 String 类方法。

split（）

Java String split() 方法用于使用给定的表达式拆分字符串。split() 方法有两种变体。

• split(String regex)：此方法使用给定的正则表达式拆分字符串并返回字符串数组。
• split(String regex, int limit)：此方法使用给定的正则表达式拆分字符串并返回字符串数组，但数组元素受指定限制的限制。如果指定的限制为 2，则该方法返回大小为 2 的数组。

package com.journaldev.examples;

/**
 * Java String split example
 * 
 * @author pankaj
 *
 */
public class StringSplitExample {

    public static void main(String[] args) {

        String s = "a/b/c/d";
        String[] a1 = s.split("/");
        System.out.println("split string using only regex:");
        for (String string : a1) {
            System.out.println(string);
        }
        System.out.println("split string using regex with limit:");
        String[] a2 = s.split("/", 2);
        for (String string : a2) {
            System.out.println(string);
        }
    }

}

上述程序的输出是：

split string using only regex:
a
b
c
d
split string using regex with limit:
a
b/c/d

contains（CharSequence s）

Java String contains() 方法检查字符串是否包含指定的字符序列。如果字符串包含指定的字符序列，则此方法返回真，否则返回假。

package com.journaldev.examples;

/**
 * Java String contains() Example
 * 
 * @author pankaj
 *
 */
public class StringContainsExample {

    public static void main(String[] args) {
        String s = "Hello World";

        System.out.println(s.contains("W"));//true
        System.out.println(s.contains("X"));//false
    }

}

上述程序的输出是：

true
false

length（）

Java String length() 方法返回字符串的长度。

package com.journaldev.examples;

/**
 * Java String length
 * 
 * @author pankaj
 *
 */
public class StringLengthExample {

    public static void main(String[] args) {

        String s1 = "abc";
        String s2 = "abcdef";
        String s3 = "abcdefghi";

        System.out.println(s1.length());//3
        System.out.println(s2.length());//6
        System.out.println(s3.length());//9

    }

}

replace（）

Java String replace() 方法用于将字符串的特定部分替换为其他字符串。replace() 方法有四种变体。

• replace(char oldChar, char newChar): 此方法将字符串中所有出现的 oldChar 替换为 newChar。
• replace(CharSequence target, CharSequence replacement)：此方法用字符串中的替换文字替换每个目标文字。
• replaceAll(String regex, String replacement)：此方法用指定的正则表达式替换所有出现的子字符串匹配，并在字符串中指定替换。
• replaceFirst(String regex, String replacement)：此方法用字符串中的指定替换替换与指定正则表达式匹配的第一次出现的子字符串。

package com.journaldev.examples;

/**
 * Java String replace
 * 
 * @author pankaj
 *
 */
public class StringReplaceExample {

    public static void main(String[] args) {

        //replace(char oldChar,  char newChar)
        String s = "Hello World";
        s = s.replace('l', 'm');
        System.out.println("After Replacing l with m :");
        System.out.println(s);

        //replaceAll(String regex, String replacement)
        String s1 = "Hello journaldev, Hello pankaj";
        s1 = s1.replaceAll("Hello", "Hi");
        System.out.println("After Replacing :");
        System.out.println(s1);

        //replaceFirst(String regex, String replacement) 
        String s2 = "Hello guys, Hello world";
        s2 = s2.replaceFirst("Hello", "Hi");
        System.out.println("After Replacing :");
        System.out.println(s2);

    }

}

上述程序的输出为：

After Replacing l with m :
Hemmo Wormd
After Replacing :
Hi journaldev, Hi pankaj
After Replacing :
Hi guys, Hello world

format（）

Java Sting format() 方法用于格式化字符串。java String format() 方法有两种变体。

• format(Locale l, String format, Object… args)：此方法使用指定的语言环境、字符串格式和参数来格式化字符串。
• format(String format, Object… args)：此方法使用指定的字符串格式和参数格式化字符串。

package com.journaldev.examples;

import java.util.Locale;

/**
 * Java String format
 * 
 * @author pankaj
 *
 */
public class StringFormatExample {

    public static void main(String[] args) {

        String s = "journaldev.com";
        // %s is used to append the string
        System.out.println(String.format("This is %s", s));

        //using locale as Locale.US
        System.out.println(String.format(Locale.US, "%f", 3.14));
    }
}

上述程序的输出是：

This is journaldev.com
3.140000

substring（）

此方法根据指定的索引返回字符串的一部分。

package com.journaldev.examples;

/**
 * Java String substring
 *
 */
public class StringSubStringExample {

    public static void main(String[] args) {

        String s = "This is journaldev.com";
        s = s.substring(8,18);
        System.out.println(s);
    }
}

字符串连接

字符串连接是java中非常基本的操作。可以使用“+”运算符或使用concat()方法连接字符串。

package com.journaldev.examples;

/**
 * Java String concatenation
 * 
 * @author pankaj
 *
 */
public class StringConcatExample {

    public static void main(String[] args) {

        String s1 = "Hello";
        String s2 = "World";
        String s3 = s1 + s2;
        //using + operator
        System.out.println("Using + operator: ");
        System.out.println(s3);

        //using concat method
        System.out.println("Using concat method: ");
        System.out.println(s1.concat(s2));

    }

}

上述程序的输出是：

Using + operator: 
HelloWorld
Using concat method: 
HelloWorld

Java 字符串池

内存管理是任何编程语言最重要的方面。Java 中字符串的内存管理与任何其他类都有点不同。为了使 Java 的内存效率更高，JVM 为字符串引入了一个称为 String Constant Pool 的特殊内存区域。

当我们创建一个字符串文字时，它会检查字符串池中是否已经存在相同的字符串。如果它在那里，那么它将返回字符串池的现有字符串的引用。

让我们看看下面的示例程序。

package com.journaldev.examples;

/**
 * Java String Pool Example
 * 
 */
public class StringPoolExample {

    public static void main(String[] args) {

        String a = "abc";
        String b = "abc";
        String c = "def";

        //same reference
        if (a==b) {
            System.out.println("Both string refer to the same object");
        }

        //different reference
        if (a==c) {
            System.out.println("Both strings refer to the same object");
        }else {
            System.out.println("Both strings refer to the different object");
        }

    }

}

上述程序的输出为：

Both string refer to the same object
Both strings refer to the different object

String intern() 方法

当我们使用字符串字面量创建字符串时，它将在字符串池中创建，但是如果我们使用 new 关键字创建一个与字符串池中存在的值相同的字符串呢？我们可以将字符串从堆内存移动到字符串池吗？

为此使用了 intern() 方法，它返回字符串对象的规范表示。当我们对使用 new 关键字创建的字符串对象调用 intern() 方法时，它会检查池中是否已经存在具有相同值的字符串？

如果是，则它从池中返回该 String 对象的引用。如果没有，那么它会在池中创建一个具有相同内容的新字符串并返回引用。

package com.journaldev.examples;

/**
 * Java String intern
 * 
 * @author pankaj
 *
 */
public class StringInternExample {

    public static void main(String[] args) {

        String s1 = "pankaj";
        String s2 = "pankaj";
        String s3 = new String("pankaj");

        System.out.println(s1==s2);//true
        System.out.println(s2==s3);//false

        String s4 = s3.intern();
        System.out.println(s1==s4);//true

    }

}

字符串不变性的好处

String 是不可变类的一些好处是：

1. 字符串常量池，从而节省内存。
2. 安全性无法更改。
3. 线程安全
4. 类加载安全

Java 8 字符串连接（）

在 Java 8 的 String 类中添加了一个新的静态方法 join()。该方法返回一个新的 String，它由 CharSequence 元素的副本和指定分隔符的副本连接在一起组成。让我们看一个例子来轻松理解它。

List<String> words = Arrays.asList(new String[]{"Hello", "World", "2019"});
String msg = String.join(" ", words);
System.out.println(msg);

输出： Hello World 2019

Java 9 字符串方法

在 Java 9 版本的 String 类中添加了两个方法。它们是 – codePoints() 和 chars()。这两种方法都返回 IntStream 对象，我们可以在该对象上执行一些操作。

让我们快速浏览一下这些方法。

String s = "abc";

s.codePoints().forEach(x -> System.out.println(x));

s.chars().forEach(x -> System.out.println(x));

输出：

97
98
99
97
98
99

Java 11 字符串类新方法

在 Java 11 版本中，String 类中添加了许多新方法。

• isBlank() – 如果字符串为空或仅包含空白代码点，则返回 true，否则返回 false。
• lines() – 返回从该字符串中提取的行流，由行终止符分隔。
• strip()、stripLeading()、stripTrailing()——用于从字符串中去除前导和尾随空格。
• repeat() – 返回一个字符串，其值是该字符串重复给定次数的串联。

让我们看一下这些方法的示例程序。

package com.journaldev.strings;

import java.util.List;
import java.util.stream.Collectors;

/**
 * JDK 11 New Functions in String class
 * 
 * @author pankaj
 *
 */
public class JDK11StringFunctions {

    public static void main(String[] args) {
        // isBlank()
        String s = "abc";
        System.out.println(s.isBlank());
        s = "";
        System.out.println(s.isBlank());

        // lines()
        String s1 = "Hi\nHello\rHowdy";
        System.out.println(s1);
        List lines = s1.lines().collect(Collectors.toList());
        System.out.println(lines);

        // strip(), stripLeading(), stripTrailing()
        String s2 = "  Java,  \tPython\t ";
        System.out.println("#" + s2 + "#");
        System.out.println("#" + s2.strip() + "#");
        System.out.println("#" + s2.stripLeading() + "#");
        System.out.println("#" + s2.stripTrailing() + "#");

        // repeat()
        String s3 = "Hello\n";
        System.out.println(s3.repeat(3));
        s3 = "Co";
        System.out.println(s3.repeat(2));

    }

}

输出：

false
true
Hi
Hello
Howdy
[Hi, Hello, Howdy]
#  Java,    Python   #
#Java,      Python#
#Java,      Python   #
#  Java,    Python#
Hello
Hello
Hello

CoCo

这就是 Java String 类的全部内容，它是方法和 String 操作示例。