Java 字符串 · ZetCode 中文系列教程

# Java 字符串原文：http://zetcode.com/lang/java/strings/ 在 Java 教程的这一部分中，我们将更详细地处理字符串数据。字符串是计算机语言中非常重要的数据类型。这就是为什么我们将一整章专门讨论 Java 中的字符串的原因。 ## Java 字符串定义在 Java 中，字符串是 Unicode 字符序列。字符串是对象。有两个用于处理字符串的基本类： * `String` * `StringBuilder` `String`是不可变的字符序列。 `StringBuilder`是可变的字符序列。（还有一个`StringBuffer`类，可以由多个线程使用。如果不处理线程，则可以使用`StringBuilder`。）字符串字面值源代码中用双引号引起来的一系列字符。例如，`"Java"`是字符串字面值。每当 Java 编译器在代码中遇到字符串字面值时，它都会使用其值创建一个`String`对象。 ```java String lang = "Java"; // same as String lang = new String("Java"); ``` 字符串字面值被许多编程语言使用。这是一个既定的约定，还可以节省键入内容。 ## Java 初始化字符串有多种创建字符串的方法，它们都是不可变的和可变的。我们将展示其中的一些。 `com/zetcode/StringInit.java` ```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`对象的几种方法。 ```java String lang = "Java"; ``` 最常见的方法是根据字符串字面值创建字符串对象。 ```java String ide = new String("NetBeans"); ``` 在这一行中，我们使用构建对象的常用方法创建一个字符串，即使用`new`关键字。 ```java String db = new String(cdb); ``` 在这里，我们从字符数组创建一个字符串对象。 ```java StringBuilder sb1 = new StringBuilder(lang); ``` 从`String`创建一个`StringBuilder`对象。 ```java StringBuilder sb2 = new StringBuilder(); sb2.append("Fields"); sb2.append(" of "); sb2.append("glory"); ``` 我们创建一个空的`StringBuilder`对象。我们将三个字符串附加到对象中。 ```java $ java StringInit.java Java NetBeans MySQL Java Fields of glory ``` 运行示例可得出此结果。 ## Java 字符串是对象字符串是对象；它们不是原始数据类型。字符串是`String`或`StringBuilder`类的实例。由于它们是对象，因此有多种方法可用于完成各种工作。 `com/zetcode/StringObjects.java` ```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"); } } ``` 在此程序中，我们演示了字符串是对象。对象必须具有一个类名，一个父类，并且还必须具有一些可以调用的方法。 ```java String lang = "Java"; ``` 创建`String`类型的对象。 ```java String bclass = lang.getClass().toString(); ``` 我们确定`lang`变量所引用的对象的类名称。 ```java String sup = lang.getClass().getSuperclass().toString(); ``` 接收到我们对象的父类。所有对象都有至少一个父对象-`Object`。 ```java if (lang.isEmpty()) { System.out.println("The string is empty"); } else { System.out.println("The string is not empty"); } ``` 对象具有各种方法。有用的字符串方法之一是`isEmpty()`方法，它确定字符串是否为空。 ```java int l = lang.length(); ``` `length()`方法返回字符串的大小。 ```java $ 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` ```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); } } ``` 这两个对象都有替换字符串中字符的方法。 ```java String name = "Jane"; String name2 = name.replace('J', 'K'); String name3 = name2.replace('n', 't'); ``` 在`String`上调用`replace()`方法将导致返回新的修改后的字符串。原始字符串不变。 ```java sb.setCharAt(0, 'K'); sb.setCharAt(2, 't'); ``` `StringBuilder`的`setCharAt()`方法将用新字符替换给定索引处的字符。原始字符串被修改。 ```java $ java MutableImmutable.java Jane Kate Jane Kate ``` 这是`com.zetcode.MutableImmutable`示例的输出。 ## Java 连接字符串可以使用+运算符或`concat()`方法添加不可变的字符串。它们将形成一个新字符串，该字符串是所有连接字符串的链。可变字符串具有`append()`方法，该方法可以从任意数量的其他字符串中构建一个字符串。 `com/zetcode/ConcatenateStrings.java` ```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); } } ``` 该示例通过添加字符串来创建三个句子。 ```java System.out.println("Return" + " of " + "the king."); ``` 通过使用+运算符形成一个新的字符串。 ```java System.out.println("Return".concat(" of ").concat("the king.")); ``` `concat()`方法返回一个字符串，该字符串表示此对象的字符及其后的字符串参数的字符的连接。 ```java StringBuilder sb = new StringBuilder(); sb.append("Return"); sb.append(" of "); sb.append("the king."); ``` 通过三次调用`append()`方法来创建`StringBuilder`类型的可变对象。 ```java $ java ConcatenateStrings.java Return of the king. Return of the king. Return of the king. ``` 这是示例输出。 ## Java 字符串的引号在某些情况下，例如使用直接语音，必须对内引号进行转义。 `com/zetcode/Quotes.java` ```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 $ 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` ```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 $ 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` ```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` ```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); } } } ``` 在第一个示例中，我们将使用不可变的字符串。 ```java char[] crs = {'Z', 'e', 't', 'C', 'o', 'd', 'e' }; String s = new String(crs); ``` 由字符数组构成一个新的不可变字符串。 ```java char c1 = s.charAt(0); char c2 = s.charAt(s.length()-1); ``` 使用`charAt()`方法，我们获得字符串的第一个和最后一个`char`值。 ```java int i1 = s.indexOf('e'); int i2 = s.lastIndexOf('e'); ``` 使用`indexOf()`和`lastIndexOf()`方法，我们得到字符'e'的第一个和最后一个出现。 ```java System.out.println(s.contains("t")); ``` 使用`contains()`方法，我们检查字符串是否包含`t`字符。该方法返回一个布尔值。 ```java char[] elements = s.toCharArray(); for (char el : elements) { System.out.println(el); } ``` `toCharArray()`方法从字符串创建一个字符数组。我们遍历数组并打印每个字符。 ```java $ 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` ```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); } } ``` 形成可变的字符串。我们通过删除，附加，插入和替换字符来修改字符串的内容。 ```java sb.deleteCharAt(sb.length()-1); ``` 这行删除最后一个字符。 ```java sb.append('s'); ``` 删除的字符将附加回字符串。 ```java sb.insert(0, 'T'); sb.insert(1, 'h'); sb.insert(2, 'e'); sb.insert(3, ' '); ``` 我们在字符串的开头插入四个字符。 ```java sb.setCharAt(4, 'm'); ``` 最后，我们在索引 4 处替换一个字符。 ```java $ java StringBuilderElements.java Misty mountains Misty mountain Misty mountains The Misty mountains The misty mountains ``` 从输出中，我们可以看到可变字符串是如何变化的。 ## 回文示例回文是一个单词，数字，短语或其他字符序列，它们的向前和向后读取相同，例如女士或赛车。有很多方法可以检查字符串是否是回文。以下示例是可能的解决方案之一。 `com/zetcode/Palindrome.java` ```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()`方法。 ```java private static boolean isPalindrome(String original) { char[] data = original.toCharArray(); ... ``` 我们将字符串转换为字符数组。 ```java 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 $ java Palindrome.java true true false ``` 这是输出。 ## Java 子字符串 `substring()`方法返回字符串的一部分。起始索引是包含的，结束索引是排斥的。起始索引从零开始。 `com/zetcode/Substrings.java` ```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()`方法创建两个子字符串。 ```java System.out.println(str.substring(0, 4)); ``` 在这里，我们得到`"book"`子字符串。零是指字符串的第一个字符。 ```java System.out.println(str.substring(4, str.length())); ``` 在此打印`"case"`子字符串。 ```java $ java Substrings.java book case ``` 这是输出。 ## Java 分割字符串 `split()`方法将字符串分割成几部分；它使用定界正则表达式作为参数。 `com/zetcode/Splitting.java` ```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); } } } ``` 该示例将句子拆分为单词。 ```java String s = "Today is a beautiful day."; ``` 这是一个句子。单词之间用空格隔开。 ```java String[] words = s.split(" "); ``` 使用`split()`方法，我们将句子切成单词。空格字符用作分隔符。该方法返回一个字符串数组。 ```java for (String word : words) { System.out.println(word); } ``` 我们遍历数组并打印其内容。 ```java $ java Splitting.java Today is a beautiful day. ``` 这是输出。 ## Java 删除字符串字符当我们将字符串拆分为单词时，某些单词的开头或结尾字符为逗号或点号。在下一个示例中，我们显示如何删除此类字符。 `com/zetcode/RemovingChars.java` ```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; } } ``` 该示例将字符串拆分为单词，并删除潜在的逗号，点，问号或双引号。 ```java String str = "Did you go there? We did, but we had a \"great\" service there."; ``` 在此字符串中，我们有一个问号，逗号，引号和附加在单词上的圆点。 ```java private static String removeChars(String part) { ``` 在此自定义方法内，我们从单词中删除了这些字符。 ```java if (part.endsWith(".") || part.endsWith("?") || part.endsWith(",")) { word = part.substring(0, part.length()-1); } ``` 在此`if`语句中，我们删除结尾字符。我们使用`endsWith()`方法来标识要删除的字符。 `substring()`方法返回不包含字符的字符串的一部分。 ```java if (part.startsWith("\"") && part.endsWith("\"")) { word = part.substring(1, part.length()-1); } ``` 同样，我们删除起始字符。起始字符通过`startsWith()`方法检查。 ```java $ java RemovingChars.java Did you go there We did but we had a great service there ``` 这是示例的输出。字符已成功删除。 ## Java 连接字符串从 Java8 开始，我们有了`join()`方法来连接字符串。请参阅 [StringJoiner 教程](/articles/java8stringjoiner/)，以了解有关在 Java 中连接字符串的更多信息。 `com/zetcode/Joining.java` ```java package com.zetcode; public class Joining { public static void main(String[] args) { String joined = String.join(" ", "Today", "is", "Sunday"); System.out.println(joined); } } ``` 在示例中，我们将三个字符串合并为一个最终字符串。 ```java String joined = String.join(" ", "Today", "is", "Sunday"); ``` `join()`方法的第一个参数是定界符，它将分隔最终字符串中的每个字符串。其余参数是要连接的字符串。 ## Java 比较字符串比较字符串有两种基本方法。 `equals()`方法比较两个字符串的内容，并返回一个布尔值，指示字符串是否相等。 `equalsIgnoreCase()`做相同的事情，除了它忽略大小写。 `com/zetcode/ComparingStrings.java` ```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)); } } ``` 我们使用上述方法比较两个字符串。 ```java String a = "book"; String b = "Book"; ``` 我们定义了两个要比较的字符串。 ```java System.out.println(a.equals(b)); ``` `equals()`方法返回`false`。两个字符串的第一个字符不同。 ```java System.out.println(a.equalsIgnoreCase(b)); ``` 当我们忽略大小写时，字符串是相等的：`equalsIgnoreCase()`方法返回`true`。 ```java $ java ComparingStrings.java false true ``` 这是程序的输出。如果我们正在将变量与字符串进行比较，则切记字符串应位于比较方法的左侧，这一点很重要。否则我们可能会得到`NullPointerException`。 `com/zetcode/ComparingStrings2.java` ```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`。 ```java public static String readString() { Random r = new Random(); boolean b = r.nextBoolean(); if (b == true) { return "ZetCode"; } else { return null; } } ``` `readString()`方法模拟方法调用可能导致空值的情况。例如，如果我们尝试从数据库中读取值，则可能会发生这种情况。 ```java String d = readString(); ``` `d`变量可以包含空值。 ```java if ("ZetCode".equals(d)) { ``` 上一行是比较两个字符串的正确方法，其中一个字符串是已知字面值。如果将`d`变量放在左侧，则如果`d`变量包含空值，则将导致`NullPointerException`。 `equals()`方法比较两个字符串的字符。 `==`运算符测试引用是否相等。所有字符串字面值都将使用 Java 自动插入。它们被放置在字符串池中。这是在编译时发生的。如果两个变量包含两个相等的字符串字面值，则它们实际上引用字符串池中的同一字符串对象。 `com/zetcode/ComparingStrings3.java` ```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); } } ``` 在此代码示例中，我们将字符串对象与`==`运算符进行比较。 ```java boolean a = "ZetCode" == "ZetCode"; ``` 这些字符串字面值是内部的。因此，身份比较运算符返回`true`。 ```java boolean b = "ZetCode" == new String("ZetCode"); ``` 使用`new`运算符创建的字符串不会被保留。比较运算符导致错误的值。 ```java boolean c = "ZetCode" == "Zet" + "Code"; ``` 字符串在编译时连接在一起。字符串字面值导致相同的对象。结果是正确的。 ```java boolean d = "ZetCode" == new String("ZetCode").intern(); ``` `intern()`对象将右侧的字符串对象放入池中。因此，d 变量为布尔值 true。 ```java boolean e = "ZetCode" == " ZetCode ".trim(); ``` 在运行时调用`trim()`方法，生成一个不同的对象。 `e`变量具有布尔值`false`。 ```java $ java ComparingStrings3.java true false true true false ``` 这是示例的输出。 ## Java 格式化字符串我们可以同时使用`System.out.printf()`和`System.out.format()`方法来格式化 Java 中的字符串。它们的工作原理相同。这两种方法使用指定的格式字符串和参数将格式字符串写入输出流。如果参数多于格式说明符，则多余的参数将被忽略。 ```java %[argument_index$][flags][width][.precision]conversion ``` 常规，字符和数字类型的格式说明符具有此语法。 ```java %[argument_index$][flags][width]conversion ``` 这是用于表示日期和时间的类型的语法。格式说明符以`%`字符开头，以 1 或 2 个字符转换结尾，该转换符指定要生成的格式化输出的种类。可选项目放在方括号之间。 `arguments_index`是一个十进制整数，指示参数在参数列表中的位置。标志是一组修改输出格式的字符。有效标志集取决于转换。宽度是一个非负的十进制整数，指示要写入输出的最小字符数。精度是通常用于限制字符数的非负十进制整数。具体行为取决于转换。所需的转换是一个字符，指示应如何格式化参数。 `com/zetcode/Conversions.java` ```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); } } ``` 在此程序中，我们格式化两个简单的句子。 ```java System.out.format("There are %d %s.%n", 5, "pencils"); ``` 在此代码行中，我们有三个格式说明符。每个说明符均以`%`字符开头。 `d`说明符格式化整数值。 `s`说明符需要字符串值。 `%n`输出平台特定的线路终端器；它不需要参数。 ```java System.out.printf("The rock weighs %f kilograms.%n", 5.345); ``` `f`将浮点值格式化为十进制值。 `System.out.printf()`与`System.out.format()`的工作相同。 ```java $ java Conversions.java There are 5 pencils. The rock weighs 5.345000 kilograms. ``` This is the output of the program. `com/zetcode/IndexPosition.java` ```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); } } ``` 该示例使用参数索引来引用包含在参数列表中的变量。 ```java System.out.format("There are %d apples, %d oranges and " + "%d pears%n", x, y, z); ``` 如果不指定索引，则变量将自动与指定符匹配。 `d`说明符将整数值格式化为十进制值。 ```java 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`变量。 ```java System.out.format("Year: %tY, Month: %<tm, Day: %<td%n", c); ``` `<`标志使先前格式说明符的参数被重用。这三个说明符均引用`c`变量。 `tY`转换字符给出的年份格式至少为四位数字，必要时带有前导零。`tm`给出一个月份，格式为两位数字，必要时以前导零，而`td`给出月份中的某一天，格式为两位数字，必要时带有前导零。 ```java $ 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` ```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); } } ``` 该示例显示了一些字符串格式说明符的标志。 ```java System.out.format("%010d%n", 553); ``` `0`标志将使输出填充前导零到最小字段宽度。我们的电话号码有三位数。最小宽度为 10。因此，输出中有 7 个前导零。 ```java System.out.format("%10d%n", 553); ``` 如果没有`0`标志，该数字将右对齐。 ```java System.out.format("%-10d%n", 553); ``` `-`标志将使数字左对齐。 ```java System.out.format("%d%n", -553); System.out.format("%(d%n", -553); ``` 默认情况下，负数带有减号。如果我们使用`(`标志，则负值将放在圆括号内。（这用于会计。） ```java $ java Flags.java +553 0000000553 553 553 -553 (553) ``` 在这里，我们看到`com.zetcode.Flags`示例的输出。 `width`字段是要写入输出的最小字符数。不能与行分隔符一起使用。 `com/zetcode/WidthSpecifier.java` ```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 个字符。数字右对齐。 ```java System.out.format("%10d%n", 1); ``` 数字 10 指出字符串输出必须至少包含十个字符。 ```java $ java WidthSpecifier.java 1 16 1655 16567 166701 1 16 1655 16567 166701 ``` 我们可以看到，在第二种情况下，数字是右对齐的。对于不同的转换，精度字段具有不同的含义。对于常规参数类型，精度是要写入输出的最大字符数。 `com/zetcode/PrecisionSpecifier.java` ```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"); } } ``` 在三个不同的输出上演示了精度说明符。 ```java System.out.format("%.3g%n", 0.0000006); ``` 如果使用`g`转换，则精度是四舍五入后得到的幅度中的位数总数。 ```java System.out.format("%.3f%n", 54.34263); ``` 对于浮点值，精度是小数点分隔符后的位数。 ```java System.out.format("%.3s%n", "ZetCode"); ``` 对于字符串，它是最大可打印字符数。七个字符中只有三个字符被打印到控制台。 ```java $ java PrecisionSpecifier.java 6.00e-07 54.343 Zet ``` This is the example output. 下一个示例将格式化数字数据。 `com/zetcode/FormatNumbers.java` ```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); } } ``` 该示例演示了数字的标准格式说明符。 ```java System.out.format("%d%n", 12263); ``` `d`转换说明符会将整数值转换为十进制值。 ```java System.out.format("%o%n", 12263); ``` `o`转换说明符会将数字格式化为八进制。 ```java System.out.format("%x%n", 12263); ``` 使用`x`说明符，结果被格式化为十六进制整数。 ```java System.out.format("%e%n", 0.03452342263); ``` 使用`e`指示符，以科学计数法打印数字。 ```java System.out.format("%d%%%n", 45); ``` `%%`字符用于打印百分号。 ```java $ java FormatNumbers.java 12263 27747 2fe7 3.452342e-02 45% ``` 该程序以不同的格式打印数字。最后，我们将格式化日期和时间数据。 `com/zetcode/FormatDateTime.java` ```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`字符开头。 ```java System.out.format("%tF%n", c); ``` 作为`tF`转换的结果，此行以完整的 ISO 8601 格式打印日期。 ```java System.out.format("%1$td.%1$tm.%1$tY%n", c); ``` 使用这些格式说明符，我们以斯洛伐克使用的格式打印日期。这些部分由点字符分隔，并且日期在月份之前，月份在年份之前。所有这三种格式说明符均引用`c`变量。 ```java $ 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 教程的这一部分更详细地介绍了字符串。