Java 字符串 - 《ZetCode 中文系列教程》

Java 字符串定义
Java 初始化字符串
Java 字符串是对象
Java 可变&不可变字符串
Java 连接字符串
Java 字符串的引号
Java 多行字符串
Java 字符串元素
回文示例
Java 子字符串
Java 分割字符串
Java 删除字符串字符
Java 连接字符串
Java 比较字符串
Java 格式化字符串

原文：http://zetcode.com/lang/java/strings/

在 Java 教程的这一部分中，我们将更详细地处理字符串数据。

字符串是计算机语言中非常重要的数据类型。这就是为什么我们将一整章专门讨论 Java 中的字符串的原因。

Java 字符串定义

在 Java 中，字符串是 Unicode 字符序列。字符串是对象。有两个用于处理字符串的基本类：

String
StringBuilder

String是不可变的字符序列。 StringBuilder是可变的字符序列。（还有一个StringBuffer类，可以由多个线程使用。如果不处理线程，则可以使用StringBuilder。）

字符串字面值源代码中用双引号引起来的一系列字符。例如，"Java"是字符串字面值。每当 Java 编译器在代码中遇到字符串字面值时，它都会使用其值创建一个String对象。

String lang = "Java"; // same as String lang = new String("Java");

字符串字面值被许多编程语言使用。这是一个既定的约定，还可以节省键入内容。

Java 初始化字符串

有多种创建字符串的方法，它们都是不可变的和可变的。我们将展示其中的一些。

com/zetcode/StringInit.java

package com.zetcode;
public class StringInit {
    public static void main(String[] args) {
        char[] cdb = {'M', 'y', 'S', 'Q', 'L'};
        String lang = "Java";
        String ide = new String("NetBeans");
        String db = new String(cdb);
        System.out.println(lang);
        System.out.println(ide);
        System.out.println(db);
        StringBuilder sb1 = new StringBuilder(lang);
        StringBuilder sb2 = new StringBuilder();
        sb2.append("Fields");
        sb2.append(" of ");
        sb2.append("glory");
        System.out.println(sb1);
        System.out.println(sb2);
    }
}

该示例显示了创建String和StringBuilder对象的几种方法。

String lang = "Java";

最常见的方法是根据字符串字面值创建字符串对象。

String ide = new String("NetBeans");

在这一行中，我们使用构建对象的常用方法创建一个字符串，即使用new关键字。

String db = new String(cdb);

在这里，我们从字符数组创建一个字符串对象。

StringBuilder sb1 = new StringBuilder(lang);

从String创建一个StringBuilder对象。

StringBuilder sb2 = new StringBuilder();
sb2.append("Fields");
sb2.append(" of ");
sb2.append("glory");

我们创建一个空的StringBuilder对象。我们将三个字符串附加到对象中。

$ java StringInit.java
Java
NetBeans
MySQL
Java
Fields of glory

运行示例可得出此结果。

Java 字符串是对象

字符串是对象；它们不是原始数据类型。字符串是String或StringBuilder类的实例。由于它们是对象，因此有多种方法可用于完成各种工作。

com/zetcode/StringObjects.java

package com.zetcode;
public class StringObjects {
    public static void main(String[] args) {
        String lang = "Java";
        String bclass = lang.getClass().toString();
        System.out.println(bclass);
        String sup = lang.getClass().getSuperclass().toString();
        System.out.println(sup);
        if (lang.isEmpty()) {
            System.out.println("The string is empty");
        } else {
            System.out.println("The string is not empty");
        }
        int l = lang.length();
        System.out.println("The string has " + l + " characters");
    }
}

在此程序中，我们演示了字符串是对象。对象必须具有一个类名，一个父类，并且还必须具有一些可以调用的方法。

String lang = "Java";

创建String类型的对象。

String bclass = lang.getClass().toString();

我们确定lang变量所引用的对象的类名称。

String sup = lang.getClass().getSuperclass().toString();

接收到我们对象的父类。所有对象都有至少一个父对象-Object。

if (lang.isEmpty()) {
    System.out.println("The string is empty");
} else {
    System.out.println("The string is not empty");
}

对象具有各种方法。有用的字符串方法之一是isEmpty()方法，它确定字符串是否为空。

int l = lang.length();

length()方法返回字符串的大小。

$ java StringObjects.java
class java.lang.String
class java.lang.Object
The string is not empty
The string has 4 characters

我们的字符串对象是String类的实例。它具有Object父类。该对象不为空，并且包含四个字符。

Java 可变&不可变字符串

String是不可变字符序列，而StringBuilder是可变字符序列。下一个示例将显示差异。

com/zetcode/MutableImmutable.java

package com.zetcode;
public class MutableImmutable {
    public static void main(String[] args) {
        String name = "Jane";
        String name2 = name.replace('J', 'K');
        String name3 = name2.replace('n', 't');
        System.out.println(name);
        System.out.println(name3);
        StringBuilder sb = new StringBuilder("Jane");
        System.out.println(sb);
        sb.setCharAt(0, 'K');
        sb.setCharAt(2, 't');
        System.out.println(sb);
    }
}

这两个对象都有替换字符串中字符的方法。

String name = "Jane";
String name2 = name.replace('J', 'K');
String name3 = name2.replace('n', 't');

在String上调用replace()方法将导致返回新的修改后的字符串。原始字符串不变。

sb.setCharAt(0, 'K');
sb.setCharAt(2, 't');

StringBuilder的setCharAt()方法将用新字符替换给定索引处的字符。原始字符串被修改。

$ java MutableImmutable.java
Jane
Kate
Jane
Kate

这是com.zetcode.MutableImmutable示例的输出。

Java 连接字符串

可以使用+运算符或concat()方法添加不可变的字符串。它们将形成一个新字符串，该字符串是所有连接字符串的链。可变字符串具有append()方法，该方法可以从任意数量的其他字符串中构建一个字符串。

com/zetcode/ConcatenateStrings.java

package com.zetcode;
public class ConcatenateStrings {
    public static void main(String[] args) {
        System.out.println("Return" + " of " + "the king.");
        System.out.println("Return".concat(" of ").concat("the king."));
        StringBuilder sb = new StringBuilder();
        sb.append("Return");
        sb.append(" of ");
        sb.append("the king.");
        System.out.println(sb);
    }
}

该示例通过添加字符串来创建三个句子。

System.out.println("Return" + " of " + "the king.");

通过使用+运算符形成一个新的字符串。

System.out.println("Return".concat(" of ").concat("the king."));

concat()方法返回一个字符串，该字符串表示此对象的字符及其后的字符串参数的字符的连接。

StringBuilder sb = new StringBuilder();
sb.append("Return");
sb.append(" of ");
sb.append("the king.");

通过三次调用append()方法来创建StringBuilder类型的可变对象。

$ java ConcatenateStrings.java
Return of the king.
Return of the king.
Return of the king.

这是示例输出。

Java 字符串的引号

在某些情况下，例如使用直接语音，必须对内引号进行转义。

com/zetcode/Quotes.java

package com.zetcode;
public class Quotes {
    public static void main(String[] args) {
        System.out.println("There are may stars");
        System.out.println("He said: \"Which one are you looking at?\"");
    }
}

我们使用\字符转义其他引号。

$ java Quotes.java
There are may stars
He said: "Which one are you looking at?"

在这里，我们看到com.zetcode.Quotes程序的输出。

Java 多行字符串

Java 13 引入了文本块，该文本块允许定义多行字符串。要创建多行字符串，我们使用三引号。

com/zetcode/MultilineStrings.java

package com.zetcode;
public class MultilineString {
    static String lyrics = """
        I cheated myself
        like I knew I would
        I told ya, I was trouble
        you know that I'm no good""";
    public static void main(String[] args) {
        System.out.println(lyrics);
    }
}

我们有一条跨越四行的空想。

$ java MultilineString.java
I cheated myself
like I knew I would
I told ya, I was trouble
you know that I'm no good

我们看到示例的输出。

在 Java 的早期版本中，我们需要执行连接操作并使用\n字符。

com/zetcode/MultilineString2.java

package com.zetcode;
public class MultilineString2 {
    static String lyrics = "I cheated myself\n" +
"like I knew I would\n" +
"I told ya, I was trouble\n" +
"you know that I'm no good";
    public static void main(String[] args) {
        System.out.println(lyrics);
    }
}

这四个字符串用+运算符连接。

Java 字符串元素

字符串是字符序列。字符是字符串的基本元素。以下两个示例显示了一些处理字符串字符的方法。

com/zetcode/StringElements.java

package com.zetcode;
public class StringElements {
    public static void main(String[] args) {
        char[] crs = {'Z', 'e', 't', 'C', 'o', 'd', 'e' };
        String s = new String(crs);
        char c1 = s.charAt(0);
        char c2 = s.charAt(s.length()-1);
        System.out.println(c1);
        System.out.println(c2);
        int i1 = s.indexOf('e');
        int i2 = s.lastIndexOf('e');
        System.out.println("The first index of character e is " + i1);
        System.out.println("The last index of character e is " + i2);
        System.out.println(s.contains("t"));
        System.out.println(s.contains("f"));
        char[] elements = s.toCharArray();
        for (char el : elements) {
            System.out.println(el);
        }
    }
}

在第一个示例中，我们将使用不可变的字符串。

char[] crs = {'Z', 'e', 't', 'C', 'o', 'd', 'e' };
String s = new String(crs);

由字符数组构成一个新的不可变字符串。

char c1 = s.charAt(0);
char c2 = s.charAt(s.length()-1);

使用charAt()方法，我们获得字符串的第一个和最后一个char值。

int i1 = s.indexOf('e');
int i2 = s.lastIndexOf('e');

使用indexOf()和lastIndexOf()方法，我们得到字符’e’的第一个和最后一个出现。

System.out.println(s.contains("t"));

使用contains()方法，我们检查字符串是否包含t字符。该方法返回一个布尔值。

char[] elements = s.toCharArray();
for (char el : elements) {
    System.out.println(el);
}

toCharArray()方法从字符串创建一个字符数组。我们遍历数组并打印每个字符。

$ java StringElements.java
Z
e
The first index of character e is 1
The last index of character e is 6
true
false
Z
e
t
C
o
d
e

This is the example output.

在第二个示例中，我们将处理StringBuilder类的元素。

com/zetcode/StringBuilderElements.java

package com.zetcode;
public class StringBuilderElements {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Misty mountains");
        System.out.println(sb);
        sb.deleteCharAt(sb.length()-1);
        System.out.println(sb);
        sb.append('s');
        System.out.println(sb);
        sb.insert(0, 'T');
        sb.insert(1, 'h');
        sb.insert(2, 'e');
        sb.insert(3, ' ');
        System.out.println(sb);
        sb.setCharAt(4, 'm');
        System.out.println(sb);
    }
}

形成可变的字符串。我们通过删除，附加，插入和替换字符来修改字符串的内容。

sb.deleteCharAt(sb.length()-1);

这行删除最后一个字符。

sb.append('s');

删除的字符将附加回字符串。

sb.insert(0, 'T');
sb.insert(1, 'h');
sb.insert(2, 'e');
sb.insert(3, ' ');

我们在字符串的开头插入四个字符。

sb.setCharAt(4, 'm');

最后，我们在索引 4 处替换一个字符。

$ java StringBuilderElements.java
Misty mountains
Misty mountain
Misty mountains
The Misty mountains
The misty mountains

从输出中，我们可以看到可变字符串是如何变化的。

回文示例

回文是一个单词，数字，短语或其他字符序列，它们的向前和向后读取相同，例如女士或赛车。有很多方法可以检查字符串是否是回文。以下示例是可能的解决方案之一。

com/zetcode/Palindrome.java

package com.zetcode;
// A palindrome is a word, number, phrase, or other sequence of characters
// which reads the same backward as forward, such as madam or racecar
public class Palindrome3 {
    public static void main(String[] args) {
        System.out.println(isPalindrome("radar"));
        System.out.println(isPalindrome("kayak"));
        System.out.println(isPalindrome("forest"));
    }
    private static boolean isPalindrome(String original) {
        char[] data = original.toCharArray();
        int i = 0;
        int j = data.length - 1;
        while (j > i) {
            if (data[i] != data[j]) {
                return false;
            }
            ++i;
            --j;
        }
        return true;
    }
}

我们已经实现了isPalindrome()方法。

private static boolean isPalindrome(String original) {
    char[] data = original.toCharArray();
...

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

int i = 0;
int j = data.length - 1;
while (j > i) {
    if (data[i] != data[j]) {
        return false;
    }
    ++i;
    --j;
}
return true;

我们遍历数组，并将左侧字符与右侧对应字符进行比较。如果全部匹配，则返回true，否则返回false。

$ java Palindrome.java
true
true
false

这是输出。

Java 子字符串

substring()方法返回字符串的一部分。起始索引是包含的，结束索引是排斥的。起始索引从零开始。

com/zetcode/Substrings.java

package com.zetcode;
public class Substrings {
    public static void main(String[] args) {
        String str = "bookcase";
        System.out.println(str.substring(0, 4));
        System.out.println(str.substring(4, str.length()));
    }
}

该示例使用substring()方法创建两个子字符串。

System.out.println(str.substring(0, 4));

在这里，我们得到"book"子字符串。零是指字符串的第一个字符。

System.out.println(str.substring(4, str.length()));

在此打印"case"子字符串。

$ java Substrings.java
book
case

这是输出。

Java 分割字符串

split()方法将字符串分割成几部分；它使用定界正则表达式作为参数。

com/zetcode/Splitting.java

package com.zetcode;
public class Splitting {
    public static void main(String[] args) {
        String s = "Today is a beautiful day.";
        String[] words = s.split(" ");
        for (String word : words) {
            System.out.println(word);
        }
    }
}

该示例将句子拆分为单词。

String s = "Today is a beautiful day.";

这是一个句子。单词之间用空格隔开。

String[] words = s.split(" ");

使用split()方法，我们将句子切成单词。空格字符用作分隔符。该方法返回一个字符串数组。

for (String word : words) {
    System.out.println(word);
}

我们遍历数组并打印其内容。

$ java Splitting.java
Today
is
a
beautiful
day.

这是输出。

Java 删除字符串字符

当我们将字符串拆分为单词时，某些单词的开头或结尾字符为逗号或点号。在下一个示例中，我们显示如何删除此类字符。

com/zetcode/RemovingChars.java

package com.zetcode;
public class RemovingChars {
    public static void main(String[] args) {
        String str = "Did you go there? We did, but we had a \"great\" service there.";
        String[] parts = str.split(" ");
        for (String part: parts) {
            String word = removeChars(part);
            System.out.println(word);
        }
    }
    private static String removeChars(String part) {
        String word = part;
        if (part.endsWith(".") || part.endsWith("?") || part.endsWith(",")) {
            word = part.substring(0, part.length()-1);
        }
        if (part.startsWith("\"") &&  part.endsWith("\"")) {
            word = part.substring(1, part.length()-1);
        }
        return word;
    }
}

该示例将字符串拆分为单词，并删除潜在的逗号，点，问号或双引号。

String str = "Did you go there? We did, but we had a \"great\" service there.";

在此字符串中，我们有一个问号，逗号，引号和附加在单词上的圆点。

private static String removeChars(String part) {

在此自定义方法内，我们从单词中删除了这些字符。

if (part.endsWith(".") || part.endsWith("?") || part.endsWith(",")) {
    word = part.substring(0, part.length()-1);
}

在此if语句中，我们删除结尾字符。我们使用endsWith()方法来标识要删除的字符。 substring()方法返回不包含字符的字符串的一部分。

if (part.startsWith("\"") &&  part.endsWith("\"")) {
    word = part.substring(1, part.length()-1);
}

同样，我们删除起始字符。起始字符通过startsWith()方法检查。

$ java RemovingChars.java
Did
you
go
there
We
did
but
we
had
a
great
service
there

这是示例的输出。字符已成功删除。

Java 连接字符串

从 Java8 开始，我们有了join()方法来连接字符串。请参阅 StringJoiner 教程，以了解有关在 Java 中连接字符串的更多信息。

com/zetcode/Joining.java

package com.zetcode;
public class Joining {
    public static void main(String[] args) {
        String joined = String.join(" ", "Today", "is", "Sunday");
        System.out.println(joined);
    }
}

在示例中，我们将三个字符串合并为一个最终字符串。

String joined = String.join(" ", "Today", "is", "Sunday");

join()方法的第一个参数是定界符，它将分隔最终字符串中的每个字符串。其余参数是要连接的字符串。

Java 比较字符串

比较字符串有两种基本方法。 equals()方法比较两个字符串的内容，并返回一个布尔值，指示字符串是否相等。 equalsIgnoreCase()做相同的事情，除了它忽略大小写。

com/zetcode/ComparingStrings.java

package com.zetcode;
public class ComparingStrings {
    public static void main(String[] args) {
        String a = "book";
        String b = "Book";
        System.out.println(a.equals(b));
        System.out.println(a.equalsIgnoreCase(b));
    }
}

我们使用上述方法比较两个字符串。

String a = "book";
String b = "Book";

我们定义了两个要比较的字符串。

System.out.println(a.equals(b));

equals()方法返回false。两个字符串的第一个字符不同。

System.out.println(a.equalsIgnoreCase(b));

当我们忽略大小写时，字符串是相等的：equalsIgnoreCase()方法返回true。

$ java ComparingStrings.java
false
true

这是程序的输出。

如果我们正在将变量与字符串进行比较，则切记字符串应位于比较方法的左侧，这一点很重要。否则我们可能会得到NullPointerException。

com/zetcode/ComparingStrings2.java

import java.util.Random;
public class ComparingStrings2 {
    public static String readString() {
        Random r = new Random();
        boolean b = r.nextBoolean();
        if (b == true) {
            return "ZetCode";
        } else {
            return null;
        }
    }
    public static void main(String[] args) {
        String d = readString();
        if ("ZetCode".equals(d)) {
            System.out.println("Strings are equal");
        } else {
            System.out.println("Strings are not equal");
        }
    }
}

在代码示例中，我们正确地比较了字符串，避免了可能的NullPointerException。

public static String readString() {
    Random r = new Random();
    boolean b = r.nextBoolean();
    if (b == true) {
        return "ZetCode";
    } else {
        return null;
    }
}

readString()方法模拟方法调用可能导致空值的情况。例如，如果我们尝试从数据库中读取值，则可能会发生这种情况。

String d = readString();

d变量可以包含空值。

if ("ZetCode".equals(d)) {

上一行是比较两个字符串的正确方法，其中一个字符串是已知字面值。如果将d变量放在左侧，则如果d变量包含空值，则将导致NullPointerException。

equals()方法比较两个字符串的字符。 ==运算符测试引用是否相等。所有字符串字面值都将使用 Java 自动插入。它们被放置在字符串池中。这是在编译时发生的。如果两个变量包含两个相等的字符串字面值，则它们实际上引用字符串池中的同一字符串对象。

com/zetcode/ComparingStrings3.java

package com.zetcode;
public class ComparingStrings3 {
    public static void main(String[] args) {
        boolean a = "ZetCode" == "ZetCode";
        boolean b = "ZetCode" == new String("ZetCode");
        boolean c = "ZetCode" == "Zet" + "Code";
        boolean d = "ZetCode" == new String("ZetCode").intern();
        boolean e = "ZetCode" == " ZetCode ".trim();
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(e);
    }
}

在此代码示例中，我们将字符串对象与==运算符进行比较。

boolean a = "ZetCode" == "ZetCode";

这些字符串字面值是内部的。因此，身份比较运算符返回true。

boolean b = "ZetCode" == new String("ZetCode");

使用new运算符创建的字符串不会被保留。比较运算符导致错误的值。

boolean c = "ZetCode" == "Zet" + "Code";

字符串在编译时连接在一起。字符串字面值导致相同的对象。结果是正确的。

boolean d = "ZetCode" == new String("ZetCode").intern();

intern()对象将右侧的字符串对象放入池中。因此，d 变量为布尔值 true。

boolean e = "ZetCode" == " ZetCode ".trim();

在运行时调用trim()方法，生成一个不同的对象。 e变量具有布尔值false。

$ java ComparingStrings3.java
true
false
true
true
false

这是示例的输出。

Java 格式化字符串

我们可以同时使用System.out.printf()和System.out.format()方法来格式化 Java 中的字符串。它们的工作原理相同。这两种方法使用指定的格式字符串和参数将格式字符串写入输出流。如果参数多于格式说明符，则多余的参数将被忽略。

%[argument_index$][flags][width][.precision]conversion

常规，字符和数字类型的格式说明符具有此语法。

%[argument_index$][flags][width]conversion

这是用于表示日期和时间的类型的语法。

格式说明符以%字符开头，以 1 或 2 个字符转换结尾，该转换符指定要生成的格式化输出的种类。可选项目放在方括号之间。

arguments_index是一个十进制整数，指示参数在参数列表中的位置。标志是一组修改输出格式的字符。有效标志集取决于转换。宽度是一个非负的十进制整数，指示要写入输出的最小字符数。精度是通常用于限制字符数的非负十进制整数。具体行为取决于转换。所需的转换是一个字符，指示应如何格式化参数。

com/zetcode/Conversions.java

package com.zetcode;
public class Conversions {
    public static void main(String[] args) {
        System.out.format("There are %d %s.%n", 5, "pencils");
        System.out.printf("The rock weighs %f kilograms.%n", 5.345);
    }
}

在此程序中，我们格式化两个简单的句子。

System.out.format("There are %d %s.%n", 5, "pencils");

在此代码行中，我们有三个格式说明符。每个说明符均以%字符开头。 d说明符格式化整数值。 s说明符需要字符串值。 %n输出平台特定的线路终端器；它不需要参数。

System.out.printf("The rock weighs %f kilograms.%n", 5.345);

f将浮点值格式化为十进制值。 System.out.printf()与System.out.format()的工作相同。

$ java Conversions.java
There are 5 pencils.
The rock weighs 5.345000 kilograms.

This is the output of the program.

com/zetcode/IndexPosition.java

package com.zetcode;
import java.util.Calendar;
public class IndexPosition {
    public static void main(String[] args) {
        int x = 12;
        int y = 32;
        int z = 43;
        Calendar c = Calendar.getInstance();
        System.out.format("There are %d apples, %d oranges and "
                + "%d pears%n", x, y, z);
        System.out.format("There are %2$d apples, %3$d oranges and "
                + "%1$d pears%n", x, y, z);
        System.out.format("Year: %tY, Month: %<tm, Day: %<td%n", c);
    }
}

该示例使用参数索引来引用包含在参数列表中的变量。

System.out.format("There are %d apples, %d oranges and "
        + "%d pears%n", x, y, z);

如果不指定索引，则变量将自动与指定符匹配。 d说明符将整数值格式化为十进制值。

System.out.format("There are %2$d apples, %3$d oranges and "
        + "%1$d pears%n", x, y, z);

1$引用x变量，2$引用y变量，3$引用z变量。

System.out.format("Year: %tY, Month: %<tm, Day: %<td%n", c);

<标志使先前格式说明符的参数被重用。这三个说明符均引用c变量。 tY转换字符给出的年份格式至少为四位数字，必要时带有前导零。tm给出一个月份，格式为两位数字，必要时以前导零，而td给出月份中的某一天，格式为两位数字，必要时带有前导零。

$ java IndexPosition.java
There are 12 apples, 32 oranges and 43 pears
There are 32 apples, 43 oranges and 12 pears
Year: 2016, Month: 09, Day: 07

This is the output of the program.

标志以特定方式修改格式。有几个标志。例如，+标志要求输出为所有正数包括一个正号。

com/zetcode/Flags.java

package com.zetcode;
public class Flags {
    public static void main(String[] args) {
        System.out.format("%+d%n", 553);
        System.out.format("%010d%n", 553);
        System.out.format("%10d%n", 553);
        System.out.format("%-10d%n", 553);
        System.out.format("%d%n", -553);
        System.out.format("%(d%n", -553);
    }
}

该示例显示了一些字符串格式说明符的标志。

System.out.format("%010d%n", 553);

0标志将使输出填充前导零到最小字段宽度。我们的电话号码有三位数。最小宽度为 10。因此，输出中有 7 个前导零。

System.out.format("%10d%n", 553);

如果没有0标志，该数字将右对齐。

System.out.format("%-10d%n", 553);

-标志将使数字左对齐。

System.out.format("%d%n", -553);
System.out.format("%(d%n", -553);

默认情况下，负数带有减号。如果我们使用(标志，则负值将放在圆括号内。（这用于会计。）

$ java Flags.java
+553
0000000553
       553
553
-553
(553)

在这里，我们看到com.zetcode.Flags示例的输出。

width字段是要写入输出的最小字符数。不能与行分隔符一起使用。

com/zetcode/WidthSpecifier.java

package com.zetcode;
public class WidthSpecifier {
    public static void main(String[] args) {
        System.out.println(1);
        System.out.println(16);
        System.out.println(1655);
        System.out.println(16567);
        System.out.println(166701);
        System.out.format("%10d%n", 1);
        System.out.format("%10d%n", 16);
        System.out.format("%10d%n", 1655);
        System.out.format("%10d%n", 16567);
        System.out.format("%10d%n", 166701);
    }
}

首先，我们打印五个数字而不指定字段宽度。输出的宽度等于要显示的字符数。在第二种情况下，字段宽度为 10。5 个输出中的每个输出的最小长度为 10 个字符。数字右对齐。

System.out.format("%10d%n", 1);

数字 10 指出字符串输出必须至少包含十个字符。

$ java WidthSpecifier.java
1
16
1655
16567
166701
         1
        16
      1655
     16567
    166701

我们可以看到，在第二种情况下，数字是右对齐的。

对于不同的转换，精度字段具有不同的含义。对于常规参数类型，精度是要写入输出的最大字符数。

com/zetcode/PrecisionSpecifier.java

package com.zetcode;
public class PrecisionSpecifier {
    public static void main(String[] args) {
        System.out.format("%.3g%n", 0.0000006);
        System.out.format("%.3f%n", 54.34263);
        System.out.format("%.3s%n", "ZetCode");
    }
}

在三个不同的输出上演示了精度说明符。

System.out.format("%.3g%n", 0.0000006);

如果使用g转换，则精度是四舍五入后得到的幅度中的位数总数。

System.out.format("%.3f%n", 54.34263);

对于浮点值，精度是小数点分隔符后的位数。

System.out.format("%.3s%n", "ZetCode");

对于字符串，它是最大可打印字符数。七个字符中只有三个字符被打印到控制台。

$ java PrecisionSpecifier.java
6.00e-07
54.343
Zet

This is the example output.

下一个示例将格式化数字数据。

com/zetcode/FormatNumbers.java

package com.zetcode;
public class FormatNumbers {
    public static void main(String[] args) {
        System.out.format("%d%n", 12263);
        System.out.format("%o%n", 12263);
        System.out.format("%x%n", 12263);
        System.out.format("%e%n", 0.03452342263);
        System.out.format("%d%%%n", 45);
    }
}

该示例演示了数字的标准格式说明符。

System.out.format("%d%n", 12263);

d转换说明符会将整数值转换为十进制值。

System.out.format("%o%n", 12263);

o转换说明符会将数字格式化为八进制。

System.out.format("%x%n", 12263);

使用x说明符，结果被格式化为十六进制整数。

System.out.format("%e%n", 0.03452342263);

使用e指示符，以科学计数法打印数字。

System.out.format("%d%%%n", 45);

%%字符用于打印百分号。

$ java FormatNumbers.java
12263
27747
2fe7
3.452342e-02
45%

该程序以不同的格式打印数字。

最后，我们将格式化日期和时间数据。

com/zetcode/FormatDateTime.java

package com.zetcode;
import java.time.LocalDateTime;
public class FormatDateTime {
    public static void main(String[] args) {
        LocalDateTime ldt = LocalDateTime.now();
        System.out.format("%tF%n", ldt);
        System.out.format("%tD%n", ldt);
        System.out.format("%tT%n", ldt);
        System.out.format("%1$tA, %1$tb %1$tY%n", ldt);
        System.out.format("%1$td.%1$tm.%1$tY%n", ldt);
    }
}

该示例演示了日期的标准格式说明符。日期和时间格式字符串的转换部分以t字符开头。

System.out.format("%tF%n", c);

作为tF转换的结果，此行以完整的 ISO 8601 格式打印日期。

System.out.format("%1$td.%1$tm.%1$tY%n", c);

使用这些格式说明符，我们以斯洛伐克使用的格式打印日期。这些部分由点字符分隔，并且日期在月份之前，月份在年份之前。所有这三种格式说明符均引用c变量。

$ java FormatDateTime.java
2019-10-02
10/02/19
15:45:02
Wednesday, Oct 2019
02.10.2019

This is the output of the program.

Java 教程的这一部分更详细地介绍了字符串。