17

Whilst I was working on a project involving Java 8's new streams, I noticed that when I called Stream#toArray() on a stream, it return an Object[] instead of a T[]. Surprised as I was, I started digging into the source code of Java 8 and couldn't find any reason why they didn't implement Object[] toArray(); as T[] toArray();. Is there any reasoning behind this, or is it just an (in)consistency?

EDIT 1: I noticed in the answers that a lot of people said this would not be possible, but this code snippet compiles and return the expected result?

import java.util.Arrays;

public class Test<R> {

    private Object[] items;

    public Test(R[] items) {
        this.items = items;
    }

    public R[] toArray() {
        return (R[]) items;
    }

    public static void main(String[] args) {
        Test<Integer> integerTest = new Test<>(new Integer[]{
            1, 2, 3, 4
        });

        System.out.println(Arrays.toString(integerTest.toArray()));
    }

}
Improve this question
11
  • 3
    How would it know R? If you want specific types to be returned, pass a generator to the method. For example for a String array, do the following: streamString.toArray(String[]::new) Commented Oct 30, 2014 at 21:24
  • 1
    You wouldn't know to which type you should cast, because at runtime Java doesn't know the actual type, because of the type erasure (just as it stands in the answer of @Susei) Commented Oct 30, 2014 at 21:32
  • 1
    An Object[] is not necessarily a R[]. That cast is bound to fail at runtime. Commented Oct 30, 2014 at 21:35
  • 2
    Object does not extends R, so this will throw a RuntimeException Commented Oct 30, 2014 at 21:35
  • 1
    The cast to R[] should be your warning sign. This is an unchecked cast, and the compiler tells you so (but you probably just ignored this). items[] is not an array of R[], so the compiler is quite right to say that it can't verify this cast -- and it can't stop a client from casting the returned array to Object[], and then putting non-R values in it, which would subvert the supposed type-safety of saying "this is an array of R". Commented Apr 21, 2016 at 20:34

3 Answers 3

Reset to default
27

Try:

String[] = IntStream.range(0, 10).mapToObj(Object::toString).toArray(String[]::new);

The no-arg toArray() method will just return an Object[], but if you pass an array factory (which can be conveniently represented as an array constructor reference), you can get whatever (compatible) type you like.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Although this doesn't directly address OP's question, this is the answer I was searching for.
10

This is the same problem that List#toArray() has. Type erasure prevents us from knowing the type of array we should return. Consider the following

class Custom<T> {
    private T t;
    public Custom (T t) {this.t = t;}
    public T[] toArray() {return (T[]) new Object[] {t};} // if not Object[], what type?
}

Custom<String> custom = new Custom("hey");
String[] arr = custom.toArray(); // fails

An Object[] is not a String[] and therefore cannot be assigned to one, regardless of the cast. The same idea applies to Stream and List. Use the overloaded toArray(..) method.

Improve this answer

9 Comments

Look at my edit. Could you explain why this works then?
Your code is fine because items is actually an Integer[], not an Object[] that has been cast to something else.
@MartijnRiemers In your example, you are returning the array you already created (for which you know the type). A Stream (or a List) is not guaranteed to be backed by an array. It can be constructed by any other means. This means that a new array has to be created, but we can't know which type.
@MartijnRiemers The real (runtime) type of the ArrayList's underlying array is Object[].
@MartijnRiemers They made the decision to implement generics with type erasure. There's a lot of discussion online about whether this was a good choice or a bad one. You might want to look into them. It's currently impossible to do things like R.class when R is a type variable.
|
5

About the reason why toArray() returns Object[]: it is because of type erasure. Generic types lose their type parameters at runtime so Stream<Integer>, Stream<String> and Stream become the same types. Therefore there is no way to determine component type of array to create. Actually, one could analyze types of array's elements using reflection and then try to find their least upper bound, but this is too complicated and slow.

There is a way to get R[] array by using overloaded toArray(IntFunction<A[]> generator) method. This method gives the caller an opportunity to choose type of the array. See this SO question for code examples: How to Convert a Java 8 Stream to an Array?.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.