AhmadLang / Java, How To Program, 2004

6{

7public static void main( String args[] )

8{

9// get current date and time

10Calendar dateTime = Calendar.getInstance();

12// printing with conversion characters for date/time compositions

13System.out.printf( "%tc\n", dateTime );

14System.out.printf( "%tF\n", dateTime );

15System.out.printf( "%tD\n", dateTime );

16System.out.printf( "%tr\n", dateTime );

17System.out.printf( "%tT\n", dateTime );

19// printing with conversion characters for date

20System.out.printf( "%1$tA, %1$tB %1$td, %1$tY\n", dateTime );

21System.out.printf( "%1$TA, %1$TB %1$Td, %1$TY\n", dateTime );

22System.out.printf( "%1$ta, %1$tb %1$te, %1$ty\n", dateTime );

24// printing with conversion characters for time

25System.out.printf( "%1$tH:%1$tM:%1$tS\n", dateTime );

26System.out.printf( "%1$tZ %1$tI:%1$tM:%1$tS %tP", dateTime );

27} // end main

28} // end class DateTimeTest

Tue Jun 29 11:17:21 GMT-05:00 2004 2004-06-29 06/29/04

11:17:21 AM 11:17:21

Tuesday, June 29, 2004

TUESDAY, JUNE 29, 2004 Tue, Jun 29, 04 11:17:21

GMT-05:00 11:17:21 AM

[Page 1335]

28.8. Other Conversion Characters

The remaining conversion characters are b, B, h, H, % and n. These are described in Fig. 28.10.

Lines 910 of Fig. 28.11 use %b to print the value of boolean values false and TRue. Line 11 associates a String to %b, which returns true because it is not null. Line 12 associates a null object to %B, which displays FALSE because test is null. Lines 1314 use %h to print the string representations of the hash code values for strings "hello" and "Hello". These values could be used to store or locate the strings in a Hashtable or HashMap (both discussed in Chapter 19, Collections). Note that the hash code values for these two strings differ because one string starts with a lowercase letter and the other starts with an uppercase letter. Line 15 uses %H to print null in uppercase letters. The last two printf statements (lines 1617) use %% to print the % character in a string and %n to print a platformspecific line separator.

Figure 28.11. Using the b, B, h, H, % and n conversion characters.

4public class OtherConversion

5{

6public static void main( String args[] )

7{

8Object test = null;

9System.out.printf( "%b\n", false );

10System.out.printf( "%b\n", true );

11System.out.printf( "%b\n", "Test" );

12System.out.printf( "%B\n", test );

13System.out.printf( "Hashcode of \"hello\" is %h\n", "hello" );

14System.out.printf( "Hashcode of \"Hello\" is %h\n", "Hello" );

15System.out.printf( "Hashcode of null is %H\n", test );

16System.out.printf( "Printing a %% in a format string\n" );

17System.out.printf( "Printing a new line %nnext line starts here" );

18} // end main

19} // end class OtherConversion

false true true FALSE

Hashcode of "hello" is 5e918d2 Hashcode of "Hello" is 42628b2 Hashcode of null is NULL Printing a % in a format string Printing a new line

next line starts here

Common Programming Error 28.2

Trying to print a literal percent character using % rather than %% in the format string might cause a difficult-to-detect logic error. When % appears in a format string, it must be followed by a conversion character in the string. The single percent could accidentally be followed by a legitimate conversion character, thus causing a logic error.

Method printf also provides the ability to specify the precision with which data is printed. Precision has different meanings for different types. When used with floating-point conversion characters e and f, the precision is the number of digits that appear after the decimal point. When used with conversion character g, the precision is the maximum number of significant digits to be printed. When used with conversion character s, the precision is the maximum number of characters to be written from the string. To use precision, place between the percent sign and the conversion specifier a decimal point (.) followed by an integer representing the precision. Figure 28.13 demonstrates the use of precision in format strings. Note that when a floating-point value is printed with a precision smaller than the original number of decimal places in the value, the value is rounded. Also note that the format specifier %.3g indicates that the total number of digits used to display the floating-point value is 3. Because the value has three digits to the left of the decimal point, the value is rounded to the ones position.

[Page 1337]

Figure 28.13. Using precision for floating-point numbers and strings.

(This item is displayed on page 1338 in the print version)

1 // Fig. 28.13: PrecisionTest.java

2 // Using precision for floating-point numbers and strings.

3public class PrecisionTest

4{

5 public static void main( String args[] )

6{

7double f = 123.94536;

8String s = "Happy Birthday";

10System.out.printf( "Using precision for floating-point numbers\n" );

11System.out.printf( "\t%.3f\n\t%.3e\n\t%.3g\n\n", f, f, f );

12

13System.out.printf( "Using precision for strings\n" );

14System.out.printf( "\t%.11s\n", s );

15} // end main

16} // end class PrecisionTest

Using precision for floating-point numbers 123.945

1.239e+02

124

Using precision for strings Happy Birth

The field width and the precision can be combined by placing the field width, followed by a decimal point, followed by a precision between the percent sign and the conversion character, as in the statement

printf( "%9.3f", 123.456789 );

which displays 123.457 with three digits to the right of the decimal point right justified in a nine-digit fieldthis number will be preceded in its field by two blanks.

[Page 1337 (continued)]

28.10. Using Flags in the printf Format String

Various flags may be used with method printf to supplement its output formatting capabilities. Seven flags are available for use in format strings (Fig. 28.14).

[Page 1338]

To use a flag in a format string, place the flag immediately to the right of the percent sign. Several flags may be used in the same format specifier. Figure 28.15 demonstrates right justification and left justification of a string, an integer, a character and a floating-point number. Note that line 9 serves as a counting mechanism for the screen output.

Figure 28.15. Right justifying and left justifying values.

(This item is displayed on page 1339 in the print version)

4public class MinusFlagTest

5{

6public static void main( String args[] )

7{

8System.out.println( "Columns:" );

9System.out.println( "0123456789012345678901234567890123456789\n" );

10System.out.printf( "%10s%10d%10c%10f\n\n", "hello", 7, 'a', 1.23 );

11System.out.printf(

12"%-10s%-10d%-10c%-10f\n", "hello", 7, 'a', 1.23 );

13} // end main

14} // end class MinusFlagTest

Columns:

0123456789012345678901234567890123456789

[Page 1339]

Figure 28.16 prints a positive number and a negative number, each with and without the + flag. Note that the minus sign is displayed in both cases, but the plus sign is displayed only when the + flag is used.

Figure 28.16. Printing numbers with and without the + flag.

4public class PlusFlagTest

5{

6 public static void main( String args[] )

7{

8System.out.printf( "%d\t%d\n", 786, -786 );

9System.out.printf( "%+d\t%+d\n", 786, -786 );

10} // end main

11} // end class PlusFlagTest

786 -786

+786 -786

Figure 28.17 prefixes a space to the positive number with the space flag. This is useful for aligning positive and negative numbers with the same number of digits. Note that the value -547 is not preceded by a space in the output because of its minus sign. Figure 28.18 uses the # flag to prefix 0 to the octal value and 0x to the hexadecimal value.

Figure 28.17. Using the space flag to print a space before non-negative values.

(This item is displayed on page 1340 in the print version)

4public class SpaceFlagTest

5{

9} // end main

10} // end class SpaceFlagTest

547 -547

Figure 28.18. Using the # flag with conversion characters o and x.

(This item is displayed on page 1340 in the print version)

4public class PoundFlagTest

5{

10System.out.printf( "%#o\n", c );

11System.out.printf( "%#x\n", c );

12} // end main

13} // end class PoundFlagTest

037

0x1f

[Page 1340]

Figure 28.19 combines the + flag, the 0 flag and the space flag to print 452 in a field of width 9 with a + sign and leading zeros, next prints 452 in a field of width 9 using only the 0 flag, then prints 452 in a field of width 9 using only the space flag.

Figure 28.19. Printing with the 0 (zero) flag fills in leading zeros.

(This item is displayed on pages 1340 - 1341 in the print version)

4public class ZeroFlagTest

5{

6 public static void main( String args[] )

7{

8System.out.printf( "%+09d\n", 452 );

9System.out.printf( "%09d\n", 452 );

10System.out.printf( "% 9d\n", 452 );

11} // end main

12} // end class ZeroFlagTest

+00000452

000000452

452

Figure 28.20 use the comma (,) flag to display a decimal and a floating-point number with the thousands separator.Figure 28.21 encloses negative numbers in parentheses using the ( flag. Note that the value 50 is not enclosed in parentheses in the output because it is a positive number.

Figure 28.20. Using the comma (,) flag to display number with thousands separator.

(This item is displayed on page 1341 in the print version)

4public class CommaFlagTest

5{

6 public static void main( String args[] )

7{

8System.out.printf( "%,d\n", 58625 );

9System.out.printf( "%,.2f", 58625.21 );

10System.out.printf( "%,.2f", 12345678.9 );

11} // end main

12} // end class CommaFlagTest

58,625

58,625.21

12,345,678.90

Figure 28.21. Using the ( flag to place parentheses around negative numbers.

(This item is displayed on page 1341 in the print version)

4public class ParenthesesFlagTest

5{

6 public static void main( String args[] )

7{

8System.out.printf( "%(d\n", 50 );

9System.out.printf( "%(d\n", -50 );

10System.out.printf( "%(.1e\n", -50.0 );

11} // end main

12} // end class ParenthesesFlagTest

50

(50)

(5.0e+01)