Java 字符串

12 月 ago

宇, 华

6 minutes

Java字符串是最广泛使用的类之一。Java字符串类的定义在java.lang包中。

Java 字符串

Basically, string is a sequence of characters but it’s not a primitive type.
When we create a string in java, it actually creates an object of type String.
String is immutable object which means that it cannot be changed once it is created.
String is the only class where operator overloading is supported in java. We can concat two strings using + operator. For example “a”+”b”=”ab”.
Java provides two useful classes for String manipulation – StringBuffer and StringBuilder.

让我们继续深入了解Java的String类吧。

创建字符串的不同方法

在Java中，有许多种方法可以创建字符串对象，以下是一些常用的方法。

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

使用new关键字
我们可以使用new运算符来创建String对象，就像创建任何普通的java类一样。String类中有几个构造函数可用于从char数组、byte数组、StringBuffer和StringBuilder中获取字符串。
String str = new String(“abc”);
char[] a = {‘a’, ‘b’, ‘c’};
String str2 = new String(a);

Java字符串比较

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

package com.Olivia.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

字符串类实现了可比较接口，提供了compareTo()和compareToIgnoreCase()方法，用于按字典顺序比较两个字符串。这两个字符串会被转换为Unicode值进行比较，并返回一个整数值，该值可以大于、小于或等于零。如果字符串相等，则返回零，否则返回大于或小于零的值。

package com.Olivia.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
	}

}

以上程序的输出结果是：

请更详细地阅读字符串 compareTo 示例，详细内容请参阅字符串 compareTo 示例。

Java字符串方法

让我们来看一下一些常用的String类方法，并附上一个示例程序。

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

package com.Olivia.examples;

/**
* Java字符串拆分示例
*
* @author pankaj
*
*/
public class StringSplitExample {

public static void main(String[] args) {

String s = “a/b/c/d”;
String[] a1 = s.split(“/”);
System.out.println(“只使用正则表达式拆分字符串：”);
for (String string : a1) {
System.out.println(string);
}
System.out.println(“使用带有限制的正则表达式拆分字符串：”);
String[] a2 = s.split(“/”, 2);
for (String string : a2) {
System.out.println(string);
}
}

}

上面程序的输出是：
只使用正则表达式拆分字符串：
a
b
c
d
使用带有限制的正则表达式拆分字符串：
a
b/c/d

contains(CharSequence s)
Java String contains()方法用于检查字符串是否包含指定的字符序列。如果字符串包含指定的字符序列，则该方法返回true，否则返回false。
package com.Olivia.examples;

/**
* Java字符串包含()示例
*
* @作者：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.Olivia.examples;

/**
* Java字符串长度
*
* @作者：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.Olivia.examples;

/**
* Java字符串替换
*
* @作者：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(“将l替换为m后的字符串：”);
System.out.println(s);

//replaceAll(String regex, String replacement)
String s1 = “Hello journaldev, Hello pankaj”;
s1 = s1.replaceAll(“Hello”, “Hi”);
System.out.println(“将Hello替换为Hi后的字符串：”);
System.out.println(s1);

//replaceFirst(String regex, String replacement)
String s2 = “Hello guys, Hello world”;
s2 = s2.replaceFirst(“Hello”, “Hi”);
System.out.println(“将第一个Hello替换为Hi后的字符串：”);
System.out.println(s2);

}

上面程序的输出是：
将l替换为m后的字符串：
Hemmo Wormd
将Hello替换为Hi后的字符串：
Hi journaldev, Hi pankaj
将第一个Hello替换为Hi后的字符串：
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.Olivia.examples;

import java.util.Locale;

/**
* Java字符串格式化
*
* @作者：pankaj
*
*/
public class StringFormatExample {

public static void main(String[] args) {

String s = “journaldev.com”;
// %s用于附加字符串
System.out.println(String.format(“这是%s”, s));

//使用Locale.US作为Locale
System.out.println(String.format(Locale.US, “%f”, 3.14));
}
}

上面程序的输出是：
这是journaldev.com
3.140000

substring()
此方法根据指定的索引返回字符串的一部分。
package com.Olivia.examples;

/**
* Java字符串子字符串
*
*/
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.Olivia.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中，字符串的内存管理与其他类有些不同。为了使Java更加内存高效，JVM引入了一个特殊的内存区域，称为字符串常量池。当我们创建一个字符串文字时，它会检查字符串池中是否已经存在相同的字符串。如果存在，则返回字符串池中现有字符串的引用。让我们来看看下面的示例程序。

package com.Olivia.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

请阅读这篇文章了解有关Java字符串池的更多信息。

字符串的intern()方法

当我们使用字符串字面量创建一个字符串时，它将被创建在字符串池中，但是如果我们使用相同的值使用new关键字创建一个字符串，它会怎样呢？我们能将堆内存中的字符串移到字符串池中吗？为此，可以使用intern()方法，它返回字符串对象的规范表示。当我们在使用new关键字创建的字符串对象上调用intern()方法时，它会检查池中是否已经存在一个具有相同值的字符串？如果是，则从池中返回该字符串对象的引用。如果没有，则在池中创建一个具有相同内容的新字符串并返回引用。

package com.Olivia.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

	}

}

查看此帖子以了解更多关于Java String intern方法的信息。

字符串的不可变性的好处

不可变类String的一些好处包括：

点击这篇帖子了解更多关于Sting的不可变性优势。

Java 8 的字符串 join() 方法

在Java 8中，String类新增了一个静态方法join()。该方法返回一个由CharSequence元素的副本组合而成的新String，并使用指定的分隔符进行分隔。让我们看一个例子来更容易理解。

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

输出：你好，世界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));

结果：

Java 11 字符串类的新方法

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

isBlank() – returns true if the string is empty or contains only white space codepoints, otherwise false.
lines() – returns a stream of lines extracted from this string, separated by line terminators.
strip(), stripLeading(), stripTrailing() – for stripping leading and trailing white spaces from the string.
repeat() – returns a string whose value is the concatenation of this string repeated given number of times.

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

package com.Olivia.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类的所有内容，包括它的方法和字符串操作示例。

你可以从我们的GitHub仓库中查看更多有关字符串的例子。

参考文档：API文档