本章概要
- 格式化输出
- 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()
(如上例)、OutputStream
和 File
。
格式化修饰符
在插入数据时,如果想要优化空格与对齐,你需要更精细复杂的格式修饰符。以下是其通用语法:
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
对象,其转换结果是对应的 true
或 false
。但是,对其他类型的参数,只要该参数不为 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
数组的形式返回。