---
title: SumDouble
weight: 6
---

Below are some modifications to the code for deeper understanding of basic language constructions primarily data types. It is always advised to try completing them by yourself before reading the solution. Modifications progress in difficulty from easy to hard.

# Task

- Input data is 64-bytes floating point numbers.
- Class should be named `SumDouble`.

## Solution

This modification is fairly easy. All we need to do is to replace all integers with floating point numbers.

> [!NOTE]
> Here we can see all of the benefits of using `Character.isWhitespace()`, because if we had had for example a set of digits and check if the character is in that set we would need to add `.` (point) to that set to count floating point numbers as well.

So here's the updated code

```java
// SumDouble.java

public class SumDouble {

    public static void main(String[] args) {
        double sum = 0; // int -> double
        for (String argument : args) {
            StringBuilder number = new StringBuilder();
            for (char c : argument.toCharArray()) {
                if (!Character.isWhitespace(c)) {
                    number.append(c);
                } else {
                    if (!number.isEmpty()) {
                        sum += Double.parseDouble(number.toString()); // Integer.parseInt -> Double.parseDouble())
                    }
                    number = new StringBuilder();
                }
            }

            if (!number.isEmpty()) {
                sum += Double.parseDouble(number.toString()); // Integer.parseInt() -> Double.parseDouble()
            }
        }

        System.out.println(sum);
    }
}
```

This code will work fine and pass all the tests, but can we improve it?

We can see repeating part of code here

```java
if (!number.isEmpty()) {
    sum += Double.parseDouble(number.toString()); // Integer.parseInt() -> Double.parseDouble()
}
```

And if we want to change it, we would need to do so in 2 places. That's considered bad practice. You can read about ***DRY*** principle [here](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself).

So let's extract this code to its own method called `parseNumber`. 

```java
static double parseNumber(StringBuilder number) {
    return number.isEmpty() ? 0.0 : Double.parseDouble(number.toString());
}
```

It's a `static` method, because we can't call a non-static method from a static context which is `main` method. If we didn't have `static` keyword in `parseNumber` method we would have gotten an error.

```bash
$ javac SumDouble.java
SumDouble.java:13: error: non-static method parseNumber(StringBuilder) cannot be referenced from a static context
                    sum += parseNumber(number); // method call
                           ^
SumDouble.java:18: error: non-static method parseNumber(StringBuilder) cannot be referenced from a static context
            sum += parseNumber(number); // method call
                   ^
2 errors
```

Also we need to discuss the ternary operator. It is a shortened form of `if`-statement. Its structure looks like this

```java
(/* condition */) ? (/* do if true */) : (/* do if false */) 
```

First argument states a condition. If the condition is `true`, then the second block gets executed. If the condition if `false`, then the third block gets executed. It will work the same as

```java
if (/* condition */) {
    /* do if true */
} else {
    /* do if false */
}
```

So here's the updated code

```java
// SumDouble.java

public class SumDouble {

    public static void main(String[] args) {
        double sum = 0;
        for (String argument : args) {
            StringBuilder number = new StringBuilder();
            for (char c : argument.toCharArray()) {
                if (!Character.isWhitespace(c)) {
                    number.append(c);
                } else {
                    sum += parseNumber(number); // method call
                    number = new StringBuilder();
                }
            }

            sum += parseNumber(number); // method call
        }

        System.out.println(sum);
    }

    static double parseNumber(StringBuilder number) {
        return number.isEmpty() ? 0.0 : Double.parseDouble(number.toString());
    }
}
```