Thread: Do Class Casts Work With Arrays?

You'll get a runtime exception if you try and cast an array of Object to an array of Player. That's why Collection provides the toArray(T[]) method as well. Try

return validPlayers.toArray(new Player[0]);

Originally Posted by snowguy13

Okay. Hm... That organization strikes me as odd...

It is odd, it creates an object which is never used to prompt the method call to instantiate one just like it, only the right size. You can also write:

return validPlayers.toArray(new Player[validPlayers.size()]);

... although if you're writing a lot of methods that take one collection of objects and returns a smaller collection of objects filtered from it, you could consider using the collections (Collection, Set, List etc) interface instead.

Another alternative might be to return an Iterator which *doesn't* create a new collection (or array), but returns objects from the original collection skipping those that fail the filter. Here's an example, just for the sake of typing some Java:

package com.javaprogrammingforums.domyhomework;
 
import java.util.*;
 
public class IteratorFilter
{
  public static void main(String args[])
  {
    List<Integer> ints = new ArrayList<Integer>();
    for (int i = 0; i < 10; i++)
      ints.add(new Integer(i));
    OddIterator odds = new OddIterator(ints);
    while (odds.hasNext())
      System.out.println(odds.next());
  }
 
  static class OddIterator extends ProxyIterator<Integer>
  {
    public OddIterator(Collection<Integer> theIntegers)
    { super(theIntegers); }
    protected boolean isValid(Integer value)
    { return value % 2 == 1; } // odd?
  }
 
  static abstract class ProxyIterator<V> implements Iterator<V>
  {
    private final Iterator<V> backingIterator;
    private V next = null;
    protected ProxyIterator(Collection<V> collection)
    { backingIterator = collection.iterator(); }
    protected abstract boolean isValid(V value);
    public void remove()
    { throw new UnsupportedOperationException("No ProxyIterator.remove()"); }
    public boolean hasNext()
    {
      if (next != null)
        return true;
      while (backingIterator.hasNext())
      {
        next = backingIterator.next();
        if (isValid(next))
          return true;
      }
      next = null;
      return false;
    }
    public V next()
    {
      if (hasNext())
      {
        V wasNext = next;
        next = null;
        return wasNext;
      }
      // do whatever backing iterator does when finished
      // (throw a NoSuchElementException)
      return backingIterator.next();
    }
  }
}

ProxyIterator is a bit ugly / kludge-y, but it works as a filter on a collection of data without creating a new collection.

Originally Posted by Sean4u

It is odd

I agree.

You'd think that an ArrayList<Foo> would have commonsense enough to return a Foo[] when told to convert itself toArray(). But all knowledge of its Foo-ness is erased away at runtime. That's just how generics is (are?) in Java.

It's instructive to (try and) create such a method yourself in order to see what happens. Something along the lines of:

public class Foo<E> {
    private E data;
 
        // get() is fine...
    public E get() {return data;}
    public void set(E e) {data = e;}
 
        // ... but this one is not: "Cannot create a generic array of E"
    public E[] toArray() {return new E[]{data};}
}

Angelika Langer's excellent web site on generics has a discussion of what would go wrong.