Problem
You want to format numbers or currency to control decimal places and commas, typi‐
cally for printed output.
Solution
For basic number formatting, use the f string interpolator shown in Recipe 1.4, “Sub‐
stituting Variables into Strings”:
scala> val pi = scala.math.Pi pi: Double = 3.141592653589793 scala> println(f"$pi%1.5f") 3.14159
A few more examples demonstrate the technique:
scala> f"$pi%1.5f"
res0: String = 3.14159 scala> f"$pi%1.2f"
res1: String = 3.14 scala> f"$pi%06.2f"
res2: String = 003.14
If you’re using a version of Scala prior to 2.10, or prefer the explicit use of the format method, you can write the code like this instead:
scala> "%06.2f".format(pi) res3: String = 003.14
A simple way to add commas is to use the getIntegerInstance method of the java.text.NumberFormat class:
scala> val formatter = java.text.NumberFormat.getIntegerInstance formatter: java.text.NumberFormat = java.text.DecimalFormat@674dc scala> formatter.format(10000)
res0: String = 10,000
scala> formatter.format(1000000) res1: String = 1,000,000
You can also set a locale with the getIntegerInstance method:
scala> val locale = new java.util.Locale("de", "DE") locale: java.util.Locale = de_DE
scala> val formatter = java.text.NumberFormat.getIntegerInstance(locale) formatter: java.text.NumberFormat = java.text.DecimalFormat@674dc scala> formatter.format(1000000)
res2: String = 1.000.000
You can handle floating-point values with a formatter returned by getInstance:
scala> val formatter = java.text.NumberFormat.getInstance
formatter: java.text.NumberFormat = java.text.DecimalFormat@674dc scala> formatter.format(10000.33)
res0: String = 10,000.33
For currency output, use the getCurrencyInstance formatter:
scala> val formatter = java.text.NumberFormat.getCurrencyInstance formatter: java.text.NumberFormat = java.text.DecimalFormat@67500 scala> println(formatter.format(123.456789))
$123.46
scala> println(formatter.format(1234.56789))
$1,234.57
scala> println(formatter.format(12345.6789))
$12,345.68
scala> println(formatter.format(123456.789))
$123,456.79
This approach handles international currency:
scala> import java.util.{Currency, Locale}
import java.util.{Currency, Locale}
scala> val de = Currency.getInstance(new Locale("de", "DE")) de: java.util.Currency = EUR
scala> formatter.setCurrency(de)
scala> println(formatter.format(123456.789)) EUR123,456.79
Discussion
This recipe falls back to the Java approach for printing currency and other formatted numeric fields, though of course the currency solution depends on how you handle currency in your applications. In my work as a consultant, I’ve seen most companies handle currency using the Java BigDecimal class, and others create their own custom currency classes, which are typically wrappers around BigDecimal.
See Also
• My printf cheat sheet.
• The Joda Money library is a Java library for handling currency, and is currently at version 0.8.
• JSR 354: Money and Currency API, is also being developed in the Java Community Process. See jcp.org for more information.
CHAPTER 3
Control Structures
Introduction
The control structures in Scala start off similar to their Java counterparts, and then diverge in some wonderful ways. For instance, Scala’s if/then/else structure is similar to Java, but can also be used to return a value. As a result, though Java has a special syntax for a ternary operator, in Scala you just use a normal if statement to achieve the ternary effect:
val x = if (a) y else z
The try/catch/finally structure is similar to Java, though Scala uses pattern matching in the catch clause. This differs from Java, but because it’s consistent with other uses of pattern matching in Scala, it’s easy to remember.
When you get to the for loop, things really start to get interesting. Its basic use is similar to Java, but with the addition of guards and other conveniences, the Scala for loop rapidly departs from its Java counterpart. For instance, in Scala you could write two for loops as follows to read every line in a file and then operate on each character in each line:
for (line <- source.getLines) { for {
char <- line if char.isLetter
} // char algorithm here ...
}
But with Scala’s for loop mojo, you can write this code even more concisely:
for {
line <- source.getLines char <- line
if char.isLetter
The rabbit hole goes even deeper, because a Scala for comprehension lets you easily apply an algorithm to one collection to generate a new collection:
scala> val nieces = List("emily", "hannah", "mercedes", "porsche") nieces: List[String] = List(emily, hannah, mercedes, porsche) scala> for (n <- nieces) yield n.capitalize
res0: List[String] = List(Emily, Hannah, Mercedes, Porsche)
Similarly, in its most basic use, a Scala match expression can look like a Java switch statement, but because you can match any object, extract information from matched objects, add guards to case statements, return values, and more, match expressions are a major feature of the Scala language.