# double

## Java/Scala: Why you shouldn’t use double or float values for currency

As a brief note, here are a couple of examples about why you shouldn’t use double or float values for currency, courtesy of Joshua Bloch’s Effective Java book:

scala>1.03 - .42val res0: Double = 0.6100000000000001 scala>1.00 - 9 * 0.10val res1: Double = 0.09999999999999998

## Scala String.format error: overloaded method value format with alternatives

I was writing some Scala code like this today:

```
val sb = new StringBuilder
for (b: Byte <- mdOut.digest) {
val hexString: String = String.format("%02x", b)
sb.append(hexString)
}
sb.toString
```

and encountered this error message:

## A Java method to round a float value to the nearest one-half value

As a quick note, here’s a Java method that will round a `float`

to the nearest half value, such as 1.0, 1.5, 2.0, 2.5, etc.:

/** * converts as follows: * 1.1 -> 1.0 * 1.3 -> 1.5 * 2.1 -> 2.0 * 2.25 -> 2.5 */ public static float roundToHalf(float f) { return Math.round(f * 2) / 2.0f; }

The comments show how this function converts the example `float`

values to their nearest half value, so I won’t add any more details here. I don’t remember the origin of this algorithm — I just found it in some old code, thought it was clever, and thought I’d share it here.

## Scala: When the sum of a list is a very large number

As a brief note, I knew that the `sum`

function I wrote in my book on Scala and functional programming would return a wrong value if the sum of the integers in a list was greater than `Int.MaxValue`

, and I was curious how the built-in `sum`

method on lists handled the same problem. It turns out that it works in the same way.

So, if you need to sum a list of integers that may exceed `Int.MaxValue`

, you might need to write a sum function that calculates and returns the sum as a `Long`

. (The same is true for `Float`

and `Double`

.)

## Scala for Java devs: Everything in Scala is an object

The new scala-lang.org docs website looks great. It’s also a reminder to me that I probably didn’t stress enough in the Scala Cookbook that *everything* in Scala is an object, including numbers. (Hopefully I made it clear that functions are objects.) This Scala REPL example shows some of the methods that are available on Scala integers (`Int`

type).

## How to handle very large numbers in Scala (BigInt, BigDecimal)

This is an excerpt from the Scala Cookbook (partially modified for the internet). This is Recipe 2.6, “Handling Very Large Numbers in Scala.”

## Problem

You’re writing a Scala application and need to use very large integer or decimal numbers.

## Solution

Use the Scala `BigInt`

and `BigDecimal`

classes. You can create a `BigInt`

:

## Scala: How to parse a number from a String

This is an excerpt from the Scala Cookbook (partially modified for the internet). This is Recipe 2.1, “Parsing a Number from a String.”

## Problem

You want to convert a `String`

to one of Scala’s numeric types (`Byte`

, `Double`

, `Int`

, `Float`

, `Long`

, `Short`

).

## Java int, double, float, and mixed-type arithmetic rules

### Table of Contents

Java FAQ: What are the *rules* about Java arithmetic (multiplication, division) involving mixed data types?

While working on a math problem in Java just a little while ago, I realized that I wasn’t comfortable with the Java mixed-type division rules. That is, I wondered if the result of this equation:

3 / 2

the same as the result of this equation:

3 / 2.0

or this equation:

3.0 / 2.0

## Java: How to round a float or double to an integer

Java math FAQ: How do I round a float or double to an integer in Java?

Solution: Use `Math.round()`

to round a `float`

(or `double`

) to the nearest integer (`int`

) in Java.

You can see how this works in the examples that follow, where the result is shown in the comment after each line: