Use `setRoundingMode`

, set the `RoundingMode`

explicitly to handle your issue with the half-even round, then use the format pattern for your required output.

Example:

```
DecimalFormat df = new DecimalFormat("#.####");
df.setRoundingMode(RoundingMode.CEILING);
for (Number n : Arrays.asList(12, 123.12345, 0.23, 0.1, 2341234.212431324)) {
Double d = n.doubleValue();
System.out.println(df.format(d));
}
```

gives the output:

```
12
123.1235
0.23
0.1
2341234.2125
```

**EDIT**: The original answer does not address the accuracy of the double values. That is fine if you don't care much whether it rounds up or down. But if you want accurate rounding, then you need to take the expected accuracy of the values into account. Floating point values have a binary representation internally. That means that a value like 2.7735 does not actually have that exact value internally. It can be slightly larger or slightly smaller. If the internal value is slightly smaller, then it will not round up to 2.7740. To remedy that situation, you need to be aware of the accuracy of the values that you are working with, and add or subtract that value before rounding. For example, when you know that your values are accurate up to 6 digits, then to round half-way values up, add that accuracy to the value:

```
Double d = n.doubleValue() + 1e-6;
```

To round down, subtract the accuracy.

**(StartA <= EndB) and (EndA >= StartB)**

*Proof:*

Let ConditionA Mean that DateRange A Completely After DateRange B

```
_ |---- DateRange A ------|
|---Date Range B -----| _
```

(True if `StartA > EndB`

)

Let ConditionB Mean that DateRange A is Completely Before DateRange B

```
|---- DateRange A -----| _
_ |---Date Range B ----|
```

(True if `EndA < StartB`

)

Then Overlap exists if Neither A Nor B is true -

(If one range is neither completely after the other,

nor completely before the other,
then they must overlap.)

Now one of De Morgan's laws says that:

`Not (A Or B)`

<=> `Not A And Not B`

Which translates to: `(StartA <= EndB) and (EndA >= StartB)`

NOTE: This includes conditions where the edges overlap exactly. If you wish to exclude that,

change the `>=`

operators to `>`

, and `<=`

to `<`

NOTE2. Thanks to @Baodad, see this blog, the actual overlap is least of:

{ `endA-startA`

, `endA - startB`

, `endB-startA`

, `endB - startB`

}

`(StartA <= EndB) and (EndA >= StartB)`

`(StartA <= EndB) and (StartB <= EndA)`

NOTE3. Thanks to @tomosius, a shorter version reads:

`DateRangesOverlap = max(start1, start2) < min(end1, end2)`

This is actually a syntactical shortcut for what is a longer implementation, which includes extra checks to verify that the start dates are on or before the endDates. Deriving this from above:

If start and end dates can be out of order, i.e., if it is possible that `startA > endA`

or `startB > endB`

, then you also have to check that they are in order, so that means you have to add two additional validity rules:

`(StartA <= EndB) and (StartB <= EndA) and (StartA <= EndA) and (StartB <= EndB)`

or:

`(StartA <= EndB) and (StartA <= EndA) and (StartB <= EndA) and (StartB <= EndB)`

or,

`(StartA <= Min(EndA, EndB) and (StartB <= Min(EndA, EndB))`

or:

`(Max(StartA, StartB) <= Min(EndA, EndB)`

But to implement `Min()`

and `Max()`

, you have to code, (using C ternary for terseness),:

`(StartA > StartB? Start A: StartB) <= (EndA < EndB? EndA: EndB)`

## Best Solution

Beware that fractions like these cannot be accurately represented in floating point.