Error while using generics and customized iterator

Question

Here's the indicted code :

import java.util.Iterator;

public class MyClass<T> implements Iterable<T> {

    private int n;
    private Object array[];

    public myClass( int size ){
        array = new Object[size];
        n=0;

    }

    @Override
    public Iterator<T> iterator(){
        return new MyClassIterator<T>(n,array); //Here's my error!
    }



    }
    class MyClassIterator<T> implements Iterator<T>{

    private int n;
    private T[] array;

    MyClassIterator( int n, T[] array ){

        this.n = n;
        this.array = array;

    }

    @Override 
    public T next(){
        return array[n++];
    }

    @Override
    public boolean hasNext(){

        return n==array.length;
    }

}

This code give me the error :

error: incompatible types: Object[] cannot be converted to T[] return new myClassIterator(n,array); where T is a type-variable: T extends Object declared in class myClass Note: Some messages have been simplified; recompile with -Xdiags:verbose to get full output 1 error

But after removing the <T> in the creation of the myClassIterator object in iterator() the error disappears and the code works without problems, now I'm asking why specify the generic type give me this error?

The "correct" code that works would be this :

@Override
public Iterator<T> iterator(){

    return new myClassIterator(n,array);     

}

Answer 1

You said:
But after removing the `in the creation of the myClassIterator object in iterator() the error disappears and the code works without problems

By removing the type parameter <T> you're using the raw type of MyClassIterator. The error disappears because

For backward compatibility, assigning a parameterized type to its raw type is allowed.

Using raw types, you essentially get pre-generics behavior

In such a case iterator() would return an MyClassIterator which returns elements of type Object.

This works because

if you assign a raw type to a parameterized type, you get a warning:

Thus you get a warning but not a compile-time error.

But why specify the generic type give me this error?

public Iterator<T> iterator() {
  return new MyClassIterator<T>(n, array); // Here's my error!
}

Here you're trying to pass in an array with component type Object to the constructor MyClassIterator(int n, T[] array). This constructor accepts an array of type T. Are the Objects instances of type T? This could be but doesn't have to. But to call this constructor it has to be.

How to fill this gap?
The field array needs to be declared with the component type T.

private T[] array;

But then array = new Object[size]; will not work because

You cannot create arrays of parameterized types.

How to solve this?
Either by passing the Class<T> into the constructor like @ohlec suggests.

Another option is to follow the example of Stream.toArray(IntFunction<T[]> generator):

public MyClass(int size, IntFunction<T[]> generator) {
  array = generator.apply(size);
  n = 0;
}

To create a MyClass<String> instance with n = 5 we call the constructor like that:

MyClass<String> strings = new MyClass<>(5, String[]::new);

In this case we're passing implicit the type argument String into the constructor.

Answer 2

The constructor of MyClassIterator<T> is declared as taking an array of T, but you're passing an array of Object. Since you've parameterized your outer class with T as well, it really looks like you want the array field to be an array of Ts

private T array[]

However, you then can only initialize the array if you pass the class to the constructor like so:

public myClass( int size, Class<T> clazz ){
    array = (T[]) Array.newInstance(clazz, size);
}