# 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 教程的这一部分更详细地介绍了字符串。