Why is it not possible to cast float[] to double[] in Java?

Question

I'm using an API that returns two-dimensional float array as a result. I'd like to process this data using the flatMap method from the streaming API, but I need to pass arrays of doubles into its methods. I've tried to work it around by casting float[][] into double[][], but it didn't work, even with float[]. Here's a JShell session dump:

-> new float[] {1.02f, 4.32f, 65.4f}
  Expression value is: [F@2b98378d
    assigned to temporary variable $1 of type float[]

-> double[] arrayOfDoubles = (double[]) $1
  Error:
  incompatible types: float[] cannot be converted to double[]
  double[] arrayOfDoubles = (double[]) $1;

So, my question is: why can't we cast float[] into double[], when it's fairly legal to cast from float to double?

Think about what needs to happen during a cast and how each of the types are stored in memory. — Mysticial, Aug 07 '18 at 16:09

Patrick Parker · Answer 1 · 2018-08-07T16:48:44.177

6

If you were to look at the memory space inhabited by a float[] as if it were double[], then the offsets into the array would be all wrong. So you would be seeing part of float #1 and float #2 when you look at double #1. That's why you need conversion, not just casting.

Put another way, the Java Language Specification simply doesn't supply such a conversion in the form of casting related syntax.

Getting back to your original problem, here is an excellent tip from Brian Goetz:

DoubleStream ds = IntStream.range(0, floatArray.length)
                       .mapToDouble(i -> floatArray[i]);

And finally, here is your flatMap DoubleStream, via the above trick:

DoubleStream ds = Arrays.stream(float2dArray)
        .flatMapToDouble(floatArray -> IntStream.range(0, floatArray.length)
                .mapToDouble(i -> floatArray[i]));

edited Aug 07 '18 at 16:48

answered Aug 07 '18 at 16:14

Patrick Parker

4,863
4
19
51

any specific reason why IntStream.range with array accessors should be used over Arrays.stream? iirc, it had overloads for the primitive streams – Wietlol Aug 07 '18 at 16:43
@Wietlol you can stream the float[][] since each float[] is an Object, so it can use the overloaded method for Object[]. however you cannot stream the float[] because there is no overloaded method for that signature! See the linked answer of Brian (click his name above) for details on that part – Patrick Parker Aug 07 '18 at 16:53
ah, they just didnt add the Arrays.stream for float[], just int, long and double. makes sense... i mean to do the range then – Wietlol Aug 07 '18 at 16:55

Andy Turner · Answer 2 · 2018-08-07T16:29:54.663

Arrays are reference types, even arrays with primitive elements.

Casting reference types doesn't actually do anything to the underlying object: it merely tells the compiler "trust me, I know more type information than you: this reference to a Foo can be safely treated as a reference to a Bar".

Unless the compiler can prove that the cast is unsafe, it trusts you and lets you do it; it is on you, the programmer, to check that it is safe, or face ClassCastExceptions at runtime.

So, casting a float[] to a double[] doesn't change the underlying object, it merely changes what the compiler lets you do with it.

But once you can treat it like a double[], you can ask the JVM to assign a double to an element of that array. double doesn't fit in float, so there are two choices:

Check if the value is in range, and cast. But then you lose precision, in a way that will be potentially very hard to debug;
Or, stop you getting into the situation in the first place by preventing you assigning a float[] to a double[].

The second choice is simpler, and that is the choice they made.

Note that you can cast a float[] to a double[], by casting via Object:

float[] f = ...
double[] d = (double[]) (Object) f;

This will fail at runtime, however, unless f is null.

Why is it not possible to cast float[] to double[] in Java?

2 Answers2