Explanation

You should replace it with:

d[i] = Double.valueOf(d.length - i);

From its Javadoc:

Deprecated.

It is rarely appropriate to use this constructor. The static factory valueOf(double) is generally a better choice, as it is likely to yield significantly better space and time performance.

In general, valueOf is not forced to always return a new instance. It can utilize an internal cache and re-use values created before already, which makes it faster. For example if you create hundreds of 1.0.

Note

Is there a specific reason you are using a Double[] in the first place? If not, go for double[] instead. The primitives are much faster and have less memory overhead, compared to their object wrapper.

Then your code is just:

double[] d = new double[10];
for (int i = 0; i < d.length; i++)
    d[i] = d.length - i;

By the way, you should prefer to never omitt the curly braces. Even if your loop is just one line. This is a very common source for bugs that are hard to find.

Also, your variable naming is not very good. What is d? Try to give it a name that reflects what it actually means. Like ages if it stores person ages, for example. If you do not have something specific, maybe use values. That is already better than just d. Especially since it is plural, so it is clear that it is an array of multiple values.

double[] values = new double[10];
for (int i = 0; i < values.length; i++) {
    values[i] = values.length - i;
}

One returns Double; the other, double.

The differences between primitive Java types and their wrapper counterparts are discussed, for example, here.

I've tried with you expression (as I don't know origin of c1, c2, c12 and N I hardcoded theirs values). So hardcoded values look like this:

double c1 = 0.1;
double c2 = 0.2;
double c12 = 0.3;
double N = 0.4;

And I've got likelihood=NaN.

As mentioned in comments above, pay attention to input. First problematic expressions are (you can get overflow here due to division of extra little or big numbers):

double p = c2 / N;
double p1 = c12 / c1;
double p2 = (c2 - c12) / (N - c1);

Then you calculate logarithms. Actually in my case (with hardcoded values listed above) I got NaN in Math.log(1 - p1) expression (as it tries to calculate decimal logarithm of negative number - p1 < 1 when c1 > c2 - very probable case).

Generally speaking, you can get not only overflow (in extremal cases) but NaN as well (even for "sane-looking" input).

The suggestion is to split you long expression into small Java-expressions. And verify each value that can cause NaN or overflow before calculation and throw exceptions manually. This will help to localize the cause of problem when you get invalid input.

Double parameter can be null when double can't.

You are taking the ASCII value of each character e.g. '1' => 49 and pushing it on to the stack.

Most likely what you want is to use a Scanner to read numbers converted from the text you input.

This is array initializer syntax, and it can only be used on the right-hand-side when declaring a variable of array type. Example:

int[] x = {1,2,3,4};
String[] y = {"a","b","c"};

If you're not on the RHS of a variable declaration, use an array constructor instead:

int[] x;
x = new int[]{1,2,3,4};
String[] y;
y = new String[]{"a","b","c"};

These declarations have the exact same effect: a new array is allocated and constructed with the specified contents.

In your case, it might actually be clearer (less repetitive, but a bit less concise) to specify the table programmatically:

double[][] m = new double[4][4];

for(int i=0; i<4; i++) {
    for(int j=0; j<4; j++) {
        m[i][j] = i*j;
    }
}

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).

If you don't mind using a 3rd party library, commons-lang has the ArrayUtils type with various methods for manipulation.

Double[] doubles;
...
double[] d = ArrayUtils.toPrimitive(doubles);

There is also the complementary method

doubles = ArrayUtils.toObject(d);

Edit: To answer the rest of the question. There will be some overhead to doing this, but unless the array is really big you shouldn't worry about it. Test it first to see if it is a problem before refactoring.

Implementing the method you had actually asked about would give something like this.

double[] getDoubles(int columnIndex) {
    return ArrayUtils.toPrimitive(data[columnIndex]);
}

Try this:

List<Double> list = Arrays.asList(1.38, 2.56, 4.3);

which returns a fixed size list.

If you need an expandable list, pass this result to the ArrayList constructor:

List<Double> list = new ArrayList<>(Arrays.asList(1.38, 2.56, 4.3));

You can try BigDecimal for this purpose

Double toBeTruncated = new Double("3.5789055");

Double truncatedDouble = BigDecimal.valueOf(toBeTruncated)
    .setScale(3, RoundingMode.HALF_UP)
    .doubleValue();

The problem is that you compare top to array.length but then you assign array[++top], the index is greater by one. When top is array.length - 1 it's still less than array.length, therefore else branch is chosen, but ++top is out of bounds.

double overflows to Infinity and -Infinity, it doesn't wrap around. BigDecimal doesn't overflow, period, it is only limited by the amount of memory in your computer. See: How to get biggest BigDecimal value

The only difference between + and .addExact is that it attempts to detect if overflow has occurred and throws an Exception instead of wraps. Here's the source code:

public static int addExact(int x, int y) {
    int r = x + y;
    // HD 2-12 Overflow iff both arguments have the opposite sign of the result
    if (((x ^ r) & (y ^ r)) < 0) {
        throw new ArithmeticException("integer overflow");
    }
    return r;
}

If you want to check that an overflow has occurred, in one sense it's simpler to do it with double anyway because you can simply check for Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY; in the case of int and long, it's a slightly more complicated matter because it isn't always one fixed value, but in another, these could be inputs (e.g. Infinity + 10 = Infinity and you probably don't want to throw an exception in this case).

For all these reasons (and we haven't even mentioned NaN yet), this is probably why such an addExact method doesn't exist in the JDK. Of course, you can always add your own implementation to a utility class in your own application.

String.format("%1$,.2f", myDouble);

String.format automatically uses the default locale.

The only possibilities you have are:

• Type cast the double into an int if you want to store your number as an integer:

  int a = (int)26.4   // so a will be 26
  

  (you will obviously lose precision this way)

• Store the number as a double to keep the precision:

  double a = 26.4
  

You can use Double.parseDouble() to convert a String to a double:

String text = "12.34"; // example String
double value = Double.parseDouble(text);

For your case it looks like you want:

double total = Double.parseDouble(jlbTotal.getText());
double price = Double.parseDouble(jlbPrice.getText());