String Formatting in Scala with java.String.format
String formatting is a crucial skill in any programming language, enabling you to create dynamic and readable output. In Scala, leveraging Java’s String.format method provides a powerful and flexible way to achieve this. This tutorial will guide you through the core concepts and demonstrate various techniques for effective string formatting.
Understanding String.format
The String.format() method, inherited from Java, allows you to create formatted strings by substituting values into a format string. The format string contains literal text and format specifiers that indicate where and how values should be inserted.
The basic syntax is:
String.format(formatString, arg1, arg2, ...)
where:
formatString: The string containing literal text and format specifiers.arg1,arg2, …: The values to be inserted into the format string.
Basic Format Specifiers
Format specifiers begin with the % character, followed by one or more characters that define the data type and formatting options. Some common format specifiers include:
%s: For strings.%d: For integers (decimal).%f: For floating-point numbers.%b: For booleans.
Here’s a simple example:
val name = "Alice"
val age = 30
val formattedString = String.format("My name is %s and I am %d years old.", name, age)
println(formattedString) // Output: My name is Alice and I am 30 years old.
Controlling Formatting
You can further customize the output using flags, width, and precision within the format specifier.
- Flags: Modify the output alignment and sign display. Common flags include
-(left-justify),+(always show sign),0(pad with zeros), and - Width: Specifies the minimum number of characters to use for the output. If the value is shorter than the width, it will be padded with spaces (or zeros if the
0flag is used). - Precision: For floating-point numbers, specifies the number of digits after the decimal point. For strings, it limits the maximum number of characters to display.
Example:
val pi = 3.14159
val formattedPi = String.format("%.2f", pi) // Output: 3.14
println(formattedPi)
val message = "Hello, world!"
val truncatedMessage = String.format("%.5s", message) // Output: Hello
println(truncatedMessage)
Argument Indexing
While arguments are usually substituted in the order they appear in the String.format method call, you can explicitly specify the argument index using $. This is useful for reusing arguments or reordering the output.
The syntax is %n$s, where n is the index of the argument (starting from 1).
val aString = "world"
val aInt = 20
val formattedString = String.format("Line:%2$d. Value:%1$s. Result: Hello %1$s at line %2$d", aString, aInt)
println(formattedString) // Output: Line:20. Value:world. Result: Hello world at line 20
Scala Convenience – Implicit Conversions
Scala extends the Java String class with implicit conversions that allow you to use the format method directly on the string itself. This provides a more concise and idiomatic way to achieve string formatting:
val placeholder = "Hello %s, isn't %s cool?"
val formatted = placeholder.format("Ivan", "Scala")
println(formatted) // Output: Hello Ivan, isn't Scala cool?
This implicit conversion to WrappedString simplifies the syntax, making your code more readable.
Formatting Numbers
String.format provides various options for formatting numbers, including:
- Thousands Separators: Use the
,character to add commas as thousands separators.
val largeNumber = 1234567
val formattedNumber = String.format("%,d", largeNumber)
println(formattedNumber) // Output: 1,234,567
- Padding with Zeros: Use the
0flag to pad numbers with leading zeros.
val number = 5
val formattedNumber = String.format("%03d", number)
println(formattedNumber) // Output: 005