Double.MAX_VALUE is the maximum value a double can represent (somewhere around 1.7*10^308).

This should end in some calculation problems, if you try to subtract the maximum possible value of a data type.

Even though when you are dealing with money you should never use floating point values especially while rounding this can cause problems (you will either have to much or less money in your system then).

Java's double type is a double-precision IEEE 754 floating-point number. This means there are 53 bits of precision in the mantissa, and hence the precision of the number is limited to about 16 significant figures in a decimal format.

Double.MAX_VALUE is approximately 1.798×10³⁰⁸, so the 16th significant figure has a magnitude on the order of 10^{308 - 16} = 10²⁹². We can confirm this using the Math.ulp method, which returns a double value's "unit of least precision":

> Double.MAX_VALUE
1.7976931348623157E308
> Math.ulp(Double.MAX_VALUE)
1.9958403095347198E292

This means if you do want to test for a value "close to" Double.MAX_VALUE, it only makes sense to do so within an epsilon of at least 2E292. Your epsilon of 0.00001 is far too small for there to be any values within that range other than Double.MAX_VALUE itself, so your test is equivalent to val == Double.MAX_VALUE.

The maximum finite value for a double is, in hexadecimal format, 0x1.fffffffffffffp1023, representing the product of a number just below 2 (1.ff… in hexadecimal notation) by 2¹⁰²³. When written this way, is is easy to see that it is made of the largest possible significand and the largest possible exponent, in a way very similar to the way you build the largest possible long in your question.

If you want a formula where all numbers are written in the decimal notation, here is one:

Double.MAX_VALUE = (2 - 1/2⁵²) * 2¹⁰²³

Or if you prefer a formula that makes it clear that Double.MAX_VALUE is an integer:

Double.MAX_VALUE = 2¹⁰²⁴ - 2⁹⁷¹

0B111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111 is an int literal, not double. Since it is bigger than Integer.MAX_VALUE, it doesn't compile.

If you want to get a double value from its binary representation, you should use Double.longBitsToDouble (and use a long literal instead of int):

double a = Double.longBitsToDouble(0B111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111L);

In the expression:

double randomDouble = Integer.MAX_VALUE + rand.nextInt((max - min) + 1);

the right hand side of the expression will first assign the sum to an integer, then this result will be cast to a double. Since adding anything to Integer.MAX_VALUE will result in overflow, you end up with a negative number, because the sign bit gets flipped as part of the overflow.

If you want a double, then just cast MAX_VALUE to double:

double randomDouble = (double)Integer.MAX_VALUE + (double)rand.nextInt((max - min) + 1);

Now in this case you get what you want, because you are adding a random number to a double, which is bearing the largest int value, which is not near the limit for what doubles can store.

Demo

java.lang.Math class provides a max method to find maximum of two double inputs. Here is the signature:

public static double max(double a,
         double b)

• The biggest integer value represented by double is : 2^53 , for details look here.

• And the biggest value can be represented with max digits after the point depends on the number itself, but the max number of digits (for example when representing 0.1) is 0.1000000000000000055511151231257827021181583404541015625 have a look at this answer.

• And the MAX_VALUE represents : (2-2^-52)·2^1023 (have a look at min and max values at this answer)

Method to do the checks yourself

public static double findMax(double[] data) {
    double max = Double.MIN_VALUE;
    for (double val : data) {
        if (val > max) {
            max = val;
        }
    }
    
    return max;
}

Using the Math utility

public static double findMax2(double[] data) {
    double max = Double.MIN_VALUE;
    for (double val : data) {
        max = Math.max(val, max);
    }
    
    return max;
}

Using streams

public static double findMax3(double[] data) {
    return Arrays.stream(data).max().getAsDouble();
}

Doing your own checks

public static double findMin(double[] data) {
    double min = Double.MAX_VALUE;
    for (double val : data) {
        if (val < min) {
            min = val;
        }
    }
    
    return min;
}

Using Math utility

public static double findMin2(double[] data) {
    double min = Double.MAX_VALUE;
    for (double val : data) {
        min = Math.min(val, min);
    }
    
    return min;
}

Using streams

public static double findMin3(double[] data) {
    return Arrays.stream(data).min().getAsDouble();
}

Try changing this:

double max = Double.MAX_VALUE;
double min = Double.MIN_VALUE;

to this:

double max = -Double.MAX_VALUE;
double min = Double.MAX_VALUE;

After all, if you start off thinking you've already seen MAX_VALUE as the highest, you're never going to see anything greater than that, are you?

EDIT: Note the use of -Double.MAX_VALUE here, instead of Double.MIN_VALUE. MIN_VALUE is the smallest positive number, whereas I assume you really want "the most strongly negative finite value".

You want the first value you read to replace both max and min. An alternative would be to use Double instead, to represent the "missing" value with null to start with:

Double max = null;
Double min = null;

if (max == null || mag > max)
{
    max = mag;
}
// Ditto for min

As a style issue, I'd also only compute the average after you've read the whole of the input - you're repeatedly overwriting the value for no reason. The only reason not to do this is to avoid having to think about the case where count is 0 (i.e. an empty file) but I'd personally handle that separately anyway - when you have no values, there simply isn't an average.

The number that you're looking for is 9,007,199,254,740,991 because 9,007,199,254,740,991 + 1 = 9,007,199,254,740,992 but 9,007,199,254,740,992 + 1 = 9,007,199,254,740,992.

I found this experimentally using the following snippet.

double a = 9.007199254E15;
while (a + 1 > a) {
    a += 1;
}
System.out.println(a);

Given the fact that you are using this value as a counter, and that the maximum value for longs is 2^63 - 1 = 9.22E18 (as Peter pointed out), there seems to be no reason not to use longs instead.

You can use ArrayList<Double> and than

    ArrayList<Double> alist=new ArrayList<Double>();
    //Add double values to this list

You can use Collections.max(alist) to get maximum value and Collections.min(alist) to get minimun value.

According to the Primitive Data Type docs:

Double
A 64-bit number that includes a decimal point. Doubles have a minimum value of -2^63 and a maximum value of (2^63)-1

So. (2^63)-1 gives 9223372036854775807 and -2^63 gives -9223372036854775808 if you have no decimal value.

The docs also say:

Note that scientific notation (e) for Doubles is not supported.

The docs for double.valueOf() say (my emphasis):

Returns a Double that contains the value of the specified String. As in Java, the String is interpreted as representing a signed decimal.

Given all this you would expect something like the following to throw an exception:

string maxDoubleString = '9323372036854775806';
Double maxDouble = double.valueof(maxDoubleString);
System.debug(maxDouble);

Yet you get:

21:22:17.040 (40038000)|VARIABLE_ASSIGNMENT|1|maxDoubleString|"9323372036854775806"
21:22:17.040 (40044000)|STATEMENT_EXECUTE|2
21:22:17.040 (40192000)|SYSTEM_METHOD_ENTRY|2|Double.valueOf(String)
21:22:17.040 (40225000)|HEAP_ALLOCATE|2|Bytes:12
21:22:17.040 (40236000)|SYSTEM_METHOD_EXIT|2|Double.valueOf(String)
21:22:17.040 (40254000)|VARIABLE_ASSIGNMENT|2|maxDouble|9.323372036854776E18
21:22:17.040 (40259000)|STATEMENT_EXECUTE|3
21:22:17.040 (40277000)|SYSTEM_METHOD_ENTRY|3|System.debug(ANY)
21:22:17.040 (40293000)|USER_DEBUG|3|DEBUG|9.323372036854776E18

And then you scratch your head for a bit and think that looks like scientific notation and more bits than would fit in a 64 bit signed double... Indeed, we've lost some decimal places to accommodate the notation.

So while you can't create a literal double using scientific notation you can create one outside the documented range using scientific notation and double.valueOf(). E.g.

Double myPlannedLottoWinnings = double.valueof('9.9E102');

Note that it is normally a bad idea to store currency values in a double due to the potential loss of precision.

At this stage my best guess for the maximum and minimum values would match those for Java.

The double docs for Java gives:

• MAX_VALUE as (2-2^-52)·2^1023
  Which a few minutes on the abacus gives as 1.797693134862315708145274237317e+308
• MIN_VALUE as 2-1074
  4.9406564584124654417656879286822e-324

What I can say is that:

• Double maxDouble = double.valueof('1.0E308');

  "VARIABLE_ASSIGNMENT|1|maxDouble|1.0E308"

• Double maxDouble = double.valueof('1.0E309');

  "VARIABLE_ASSIGNMENT|1|maxDouble|Infinity"

• Double maxDouble = double.valueof('1.7976931348623157e+308d');
  

  "VARIABLE_ASSIGNMENT|1|maxDouble|1.7976931348623157E308"

• Double maxDouble = double.valueof('1.7976931348623158e+308d');

  "VARIABLE_ASSIGNMENT|1|maxDouble|1.7976931348623157E308"
  No, that isn't a typo, two different inputs have produced the same result.

• Double maxDouble = double.valueof('1.7976931348623159e+308d');

  "VARIABLE_ASSIGNMENT|1|maxDouble|Infinity"

• Double minDouble = double.valueof('4.94065645841246544e-324d'); >"VARIABLE_ASSIGNMENT|1|minDouble|4.9E-324"

See also: Wikipedia for details about a "double-precision 64-bit IEEE 754 floating point".

The int range issue is because you have an int literal. Use a double literal by postfixing 'd':

public static void main(String[] args) {
    assignDoubleToInt(2147483646); // One less than the maximum value an int can hold
    assignDoubleToInt(2147483647); // The maximum value an int can hold
    assignDoubleToInt(2147483648d);// One greater than the maximum value an int can hold. Causes error and does not
                                  // run.
}

I believe your equality test should be <=, also: "if the value in d is not larger than the maximum value for an int" - so if it is EQUAL to the maximum value for an int, it's valid:

public static void assignDoubleToInt(double d) {
    int i = 0;
    if (d <= Integer.MAX_VALUE)
        i = (int) d;
    System.out.println(i);
}

See https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html

Double.MAX_VALUE is the biggest finite number that double can hold. (A very large positive number.)

Double.MIN_VALUE is the smallest positive number that double can hold. (A very small positive number.)

So -Double.MAX_VALUE is a very large negative number. That's a lower number than a very small positive number.

Contrarily, Integer.MIN_VALUE is the most negative number that an int can hold. It has a different meaning from the similarly named constant in Double.

The precision of double is not capable of representing the difference between Float.MAX_VALUE and Float.MAX_VALUE+1, so a rounded result is returned. That rounded result is Float.MAX_VALUE.

Float.MAX_VALUE is 2¹²⁸−2¹⁰⁴. (Note that this is 2¹²⁷+2¹²⁶+2¹²⁵+…+2¹⁰⁴. That is, it is the sum of all powers of two from 2¹²⁷ to 2¹⁰⁴. In binary, it has 24 one bits, which is the number of bits in the significand¹ of a float. Mathematically, it equals 2¹²⁸−2¹⁰⁴.)

When you add one to this, the mathematical result is of course 2¹²⁸−2¹⁰⁴+1. This is not representable in double, because the significand of a double is 53 bits, but from 2¹²⁷ to 1 is 129 bits. You cannot fit bits for both 2¹²⁷ and 1 inside the significand of a double. When a result is not representable, the nearest representable number is returned.

The representable number just below the mathematical result is 2¹²⁸−2¹⁰⁴, and the representable number just above the mathematical result is 2¹²⁸−2¹⁰⁴+2⁷⁵. (Note that from 2¹²⁷ to 2⁷⁵ is 52 bits, so 2⁷⁵ is the smallest power of 2 that bits in a 53-bit significand where the largest bit is being scaled to 2¹²⁷. Thus, we calculated this next number above 2¹²⁸−2¹⁰⁴ by adding the smallest amount to it that fits in the significand.) So we have two candidates:

• 2¹²⁸−2¹⁰⁴, which is 1 away from 2¹²⁸−2¹⁰⁴+1.
• 2¹²⁸−2¹⁰⁴+2⁷⁵, which is 2¹⁰⁴+2⁷⁵−1 away from 2¹²⁸−2¹⁰⁴+1.

The former is closer, so it is chosen to be the computed result. Thus, in double, adding one to 2¹²⁸−2¹⁰⁴ produces 2¹²⁸−2¹⁰⁴.

Footnote

¹ The representation of a binary floating-pont number has three parts: a sign s that is +1 or −1, a significand f that is a fixed-point number with a fixed number of bits, and an exponent e, such that the number represented is s • f • 2^e. The significand can be thought of just as an integer with a certain number of bits, but it is often scaled by adjusting the exponent so that the significand of normal floating-point numbers is in [1, 2). For example, 132 could be thought of as the significand 1000012 times 2² or as 1.000012 times 2⁷.

While others already have answered why Math.max is not variadic, they didn't answer why such a method is not created when variadic functions are introduced.

I even don't know it (there is an open bug-report) so I can only guess:

It is true that it is not implemented in Math, but if we look into Collections there is the following method:

public static <T extends Object & Comparable<? super T>> T max(
    Collection<? extends T> coll) {
  ...
}

While the type signature looks ugly (it needs to be flexible enough to handle covariance and contravariance), it can easily be used with Collections.max(Arrays.asList(-13, 12, 1337, 9)); After all the function is implemented, just in a different place.

Even better: This method can handle not only doubles, but all types implementing the Comparable interface.

Nevertheless neither your suggested solution, nor the solution in Collections is object oriented, they are just static methods. Luckily with JDK8 this will change:

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

int max(List<Integer> list) {
  Optional<Integer> opt = list.stream().max((a,b) -> a-b);
  return opt.orElse(Integer.MAX_VALUE);
}

max(Arrays.asList(-13, 12, 1337, 9)); // 1337
max(Arrays.asList()); // 2147483647

For the upcoming release the collection library is reworked in Project Lambda to be more object oriented. In the example above, Lambdas are used to provide an easy and readable way to determine the max element. The following would work too:

import static java.util.Comparators.naturalOrder;

Arrays.asList(-13, 12, 1337, 9)
  .stream()
  .max(naturalOrder())
  .ifPresent(System.out::println); // 1337

Instead of max one could also use the higher order function reduce:

Arrays.asList(-13, 12, 1337, 9)
  .stream()
  .reduce((a,b) -> a > b ? a : b)
  .ifPresent(System.out::println); // 1337

Another detail is the use of Optional. It is a type to simplify error handling due to composition of higher order functions as shown in the examples above.

The lambda proposal has several advantages that make it unnecessary to implement a variadic form of Math.max:

1. It is object oriented
2. It is polymorphic. This means it can be used with every type of collection (List, Set, Stream, Iterator etc.)
3. It is expressive and easy to understand
4. It allows on-the-fly parallelization. Just change .stream() to .parallelStream()