十八、字符串(2)

本章概要

  • 格式化输出
    • printf()
    • Systen.out.format()
    • Formatter 类
    • 格式化修饰符
    • Formatter 转换
    • String.format()
      • 一个十六进制转储(dump)工具

格式化输出

在长久的等待之后,Java SE5 终于推出了 C 语言中 printf() 风格的格式化输出这一功能。这不仅使得控制输出的代码更加简单,同时也给与Java开发者对于输出格式与排列更强大的控制能力。

printf()

C 语言的 printf() 并不像 Java 那样连接字符串,它使用一个简单的格式化字符串,加上要插入其中的值,然后将其格式化输出。 printf() 并不使用重载的 + 操作符(C语言没有重载)来连接引号内的字符串或字符串变量,而是使用特殊的占位符来表示数据将来的位置。而且它还将插入格式化字符串的参数,以逗号分隔,排成一行。例如:

c 复制代码
System.out.printf("Row 1: [%d %f]%n", x, y);

这一行代码在运行的时候,首先将 x 的值插入到 %d_ 的位置,然后将 y 的值插入到 %f 的位置。这些占位符叫做_格式修饰符_,它们不仅指明了插入数据的位置,同时还指明了将会插入什么类型的变量,以及如何格式化。在这个例子中 %d 表示 x 是一个整数,%f 表示 y 是一个浮点数(float 或者 double)。

System.out.format()

Java SE5 引入了 format() 方法,可用于 PrintStream 或者 PrintWriter 对象,其中也包括 System.out 对象。format() 方法模仿了 C 语言的 printf()。如果你比较怀旧的话,也可以使用 printf()。以下是一个简单的示例:

java 复制代码
public class SimpleFormat {
    public static void main(String[] args) {
        int x = 5;
        double y = 5.332542;
        // The old way: 
        System.out.println("Row 1: [" + x + " " + y + "]");
        // The new way:     
        System.out.format("Row 1: [%d %f]%n", x, y);
        // or     
        System.out.printf("Row 1: [%d %f]%n", x, y);
    }
} 

可以看到,format()printf() 是等价的,它们只需要一个简单的格式化字符串,加上一串参数即可,每个参数对应一个格式修饰符。

String 类也有一个 static format() 方法,可以格式化字符串。

Formatter

在 Java 中,所有的格式化功能都是由 java.util.Formatter 类处理的。可以将 Formatter 看做一个翻译器,它将你的格式化字符串与数据翻译成需要的结果。当你创建一个 Formatter 对象时,需要向其构造器传递一些信息,告诉它最终的结果将向哪里输出:

java 复制代码
import java.io.*;
import java.util.*;

public class Turtle {
    private String name;
    private Formatter f;

    public Turtle(String name, Formatter f) {
        this.name = name;
        this.f = f;
    }

    public void move(int x, int y) {
        f.format("%s The Turtle is at (%d,%d)%n",
                name, x, y);
    }

    public static void main(String[] args) {
        PrintStream outAlias = System.out;
        Turtle tommy = new Turtle("Tommy",
                new Formatter(System.out));
        Turtle terry = new Turtle("Terry",
                new Formatter(outAlias));
        tommy.move(0, 0);
        terry.move(4, 8);
        tommy.move(3, 4);
        terry.move(2, 5);
        tommy.move(3, 3);
        terry.move(3, 3);
    }
}

格式化修饰符 %s 表明这里需要 String 参数。

所有的 tommy 都将输出到 System.out,而所有的 terry 则都输出到 System.out 的一个别名中。Formatter 的重载构造器支持输出到多个路径,不过最常用的还是 PrintStream()(如上例)、OutputStreamFile

格式化修饰符

在插入数据时,如果想要优化空格与对齐,你需要更精细复杂的格式修饰符。以下是其通用语法:

java 复制代码
%[argument_index$][flags][width][.precision]conversion

最常见的应用是控制一个字段的最小长度,这可以通过指定 width 来实现。Formatter对象通过在必要时添加空格,来确保一个字段至少达到设定长度。默认情况下,数据是右对齐的,不过可以通过使用 - 标志来改变对齐方向。

width 相对的是 precision ,用于指定最大长度。width 可以应用于各种类型的数据转换,并且其行为方式都一样。precision 则不然,当应用于不同类型的数据转换时,precision 的意义也不同。在将 precision 应用于 String 时,它表示打印 string 时输出字符的最大数量。而在将 precision 应用于浮点数时,它表示小数部分要显示出来的位数(默认是 6 位小数),如果小数位数过多则舍入,太少则在尾部补零。由于整数没有小数部分,所以 precision 无法应用于整数,如果你对整数应用 precision,则会触发异常。

下面的程序应用格式修饰符来打印一个购物收据。这是 Builder 设计模式的一个简单实现,即先创建一个初始对象,然后逐渐添加新东西,最后调用 build() 方法完成构建:

java 复制代码
import java.util.*;

public class ReceiptBuilder {
    private double total = 0;
    private Formatter f = new Formatter(new StringBuilder());

    public ReceiptBuilder() {
        f.format("%-15s %5s %10s%n", "Item", "Qty", "Price");
        f.format("%-15s %5s %10s%n", "----", "---", "-----");
    }

    public void add(String name, int qty, double price) {
        f.format("%-15.15s %5d %10.2f%n", name, qty, price);
        total += price * qty;
    }

    public String build() {
        f.format("%-15s %5s %10.2f%n", "Tax", "",total * 0.06);
        f.format("%-15s %5s %10s%n", "", "", "-----");
        f.format("%-15s %5s %10.2f%n", "Total", "",total * 1.06);
        return f.toString();
    }

    public static void main(String[] args) {
        ReceiptBuilder receiptBuilder = new ReceiptBuilder();
        receiptBuilder.add("Jack's Magic Beans", 4, 4.25);
        receiptBuilder.add("Princess Peas", 3, 5.1);
        receiptBuilder.add("Three Bears Porridge", 1, 14.29);
        System.out.println(receiptBuilder.build());
    }
}

通过传入一个 StringBuilder 对象到 Formatter 的构造器,我们指定了一个容器来构建目标 String。你也可以通过不同的构造器参数,把结果输出到标准输出,甚至是一个文件里。

正如你所见,通过相当简洁的语法,Formatter 提供了对空格与对齐的强大控制能力。在该程序中,为了恰当地控制间隔,格式化字符串被重复利用了多遍。

Formatter 转换

下面的表格展示了最常用的类型转换:

类型 含义
d 整型(十进制)
c Unicode字符
b Boolean值
s String
f 浮点数(十进制)
e 浮点数(科学计数)
x 整型(十六进制)
h 散列码(十六进制)
% 字面值"%"

下面的程序演示了这些转换是如何工作的:

java 复制代码
import java.math.*;
import java.util.*;

public class Conversion {
    public static void main(String[] args) {
        Formatter f = new Formatter(System.out);

        char u = 'a';
        System.out.println("u = 'a'");
        f.format("s: %s%n", u);
        // f.format("d: %d%n", u);     
        f.format("c: %c%n", u);
        f.format("b: %b%n", u);
        // f.format("f: %f%n", u);     
        // f.format("e: %e%n", u);     
        // f.format("x: %x%n", u);     
        f.format("h: %h%n", u);

        int v = 121;
        System.out.println("v = 121");
        f.format("d: %d%n", v);
        f.format("c: %c%n", v);
        f.format("b: %b%n", v);
        f.format("s: %s%n", v);
        // f.format("f: %f%n", v);     
        // f.format("e: %e%n", v);     
        f.format("x: %x%n", v);
        f.format("h: %h%n", v);

        BigInteger w = new BigInteger("50000000000000");
        System.out.println(
                "w = new BigInteger(\"50000000000000\")");
        f.format("d: %d%n", w);
        // f.format("c: %c%n", w);     
        f.format("b: %b%n", w);
        f.format("s: %s%n", w);
        // f.format("f: %f%n", w);     
        // f.format("e: %e%n", w);     
        f.format("x: %x%n", w);
        f.format("h: %h%n", w);

        double x = 179.543;
        System.out.println("x = 179.543");
        // f.format("d: %d%n", x);     
        // f.format("c: %c%n", x);     
        f.format("b: %b%n", x);
        f.format("s: %s%n", x);
        f.format("f: %f%n", x);
        f.format("e: %e%n", x);
        // f.format("x: %x%n", x);     
        f.format("h: %h%n", x);

        Conversion y = new Conversion();
        System.out.println("y = new Conversion()");

        // f.format("d: %d%n", y);     
        // f.format("c: %c%n", y);     
        f.format("b: %b%n", y);
        f.format("s: %s%n", y);
        // f.format("f: %f%n", y);     
        // f.format("e: %e%n", y);     
        // f.format("x: %x%n", y);     
        f.format("h: %h%n", y);

        boolean z = false;
        System.out.println("z = false");
        // f.format("d: %d%n", z);     
        // f.format("c: %c%n", z);     
        f.format("b: %b%n", z);
        f.format("s: %s%n", z);
        // f.format("f: %f%n", z);     
        // f.format("e: %e%n", z);     
        // f.format("x: %x%n", z);     
        f.format("h: %h%n", z);
    }
}

被注释的代码表示,针对相应类型的变量,这些转换是无效的。如果执行这些转换,则会触发异常。

注意,程序中的每个变量都用到了 b 转换。虽然它对各种类型都是合法的,但其行为却不一定与你想象的一致。对于 boolean 基本类型或 Boolean 对象,其转换结果是对应的 truefalse。但是,对其他类型的参数,只要该参数不为 null,其转换结果永远都是 true。即使是数字 0,转换结果依然为 true,而这在其他语言中(包括C),往往转换为 false。所以,将 b 应用于非布尔类型的对象时请格外小心。

还有许多不常用的类型转换与格式修饰符选项,你可以在 JDK 文档中的 Formatter 类部分找到它们。

String.format()

Java SE5 也参考了 C 中的 sprintf() 方法,以生成格式化的 String 对象。String.format() 是一个 static 方法,它接受与 Formatter.format() 方法一样的参数,但返回一个 String 对象。当你只需使用一次 format() 方法的时候,String.format() 用起来很方便。例如:

java 复制代码
public class DatabaseException extends Exception {
    public DatabaseException(int transactionID, int queryID, String message) {
        super(String.format("(t%d, q%d) %s", transactionID, queryID, message));
    }

    public static void main(String[] args) {
        try {
            throw new DatabaseException(3, 7, "Write failed");
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

其实在 String.format() 内部,它也是创建了一个 Formatter 对象,然后将你传入的参数转给 Formatter。不过,与其自己做这些事情,不如使用便捷的 String.format() 方法,何况这样的代码更清晰易读。

一个十六进制转储(dump)工具

在第二个例子中,我们把二进制文件转换为十六进制格式。下面的小工具使用了 String.format() 方法,以可读的十六进制格式将字节数组打印出来:

java 复制代码
import java.nio.file.*;

public class Hex {
    public static String format(byte[] data) {
        StringBuilder result = new StringBuilder();
        int n = 0;
        for (byte b : data) {
            if (n % 16 == 0) {
                result.append(String.format("%05X: ", n));
            }
            result.append(String.format("%02X ", b));
            n++;
            if (n % 16 == 0) {
                result.append("\n");
            }
        }
        result.append("\n");
        return result.toString();
    }

    public static void main(String[] args) throws Exception {
        if (args.length == 0)
        // Test by displaying this class file:
        {
            System.out.println(format(
                    Files.readAllBytes(Paths.get(
                            "D:\\onJava\\test\\src\\main\\java\\com\\example\\test\\Hex.class"))));
        } else {
            System.out.println(format(
                    Files.readAllBytes(Paths.get(args[0]))));
        }
    }
}

部分打印截图:

为了打开及读入二进制文件,我们用到了另一个工具 Files.readAllBytes(),这已经在 Files章节 介绍过了。这里的 readAllBytes() 方法将整个文件以 byte 数组的形式返回。

相关推荐
tangYi0_03 个月前
MCU调试技巧-串口打印
单片机·串口·调试技巧·printf·itm·semihosting·segger-rtt
雨中来客3 个月前
[C语言]自己实现sprintf,printf函数
c语言·stm32·单片机·printf·sprintf
L_EG8 个月前
【STM32】STM32F4中USART的使用方法和Printf的重定义(基于CubeMX和Keil)
c语言·stm32·嵌入式硬件·cubemx·串口·hal·printf
小林up1 年前
《C和指针》笔记6:gets/puts/scanf/printf/getchar函数用法
c语言·gets·printf·scanf·puts·getchar