将集合<SomeClass>转换为集合<SomeSuperClass>

你不能这么做。您有一个收藏<SomeClass>并希望归还一份收藏品<超类>

不同的

威尔 Collection<? extends SomeSuperClass> 不做你想做的?

Java 8 现在提供了一种使用 lambdas :您可以使用 map() and collect()

public class A
{
    private Collection<SomeClass> myCollection;

    public Collection<SomeSuperClass> getCollection()
    {
        return myCollection.stream().map(x -> (SomeSuperClass) x).collect(Collectors.toList());
    }
}

您也可以使用其他 Collectors

如果创建正确类型的新集合,则可以使用旧集合填充它

public Collection<SomeSuperClass> getCollection()
{
    return new ArrayList<SomeSuperClass>(myCollection); 
}

How do you cast a List of supertypes to a List of subtypes?

Collection<SomeSuperType> variable =
                    (Collection<SomeSuperType>)(Collection<?>) collectionOfSomeType;

以“未经检查”的警告为代价。在相关问题上,由于缺乏类型安全性,有人对这个答案的“黑客性”表示担忧。然而,在这个问题的上下文中(即将子类型的集合转换为它们的父类型的集合),我看不到任何问题或可能的ClassCastExceptions。不管怎么说,效果都很好。

我不知道为什么;也许其他人可以解释这一点;但如果你这么做了:

public abstract class SomeSuperClass<E> {
    abstract public Collection<SomeSuperClass<E>> getCollection();
}

public class Someclass extends SomeSuperClass {
    @Override
    public Collection<Someclass> getCollection() {
        // TODO Auto-generated method stub
        return null;
    }
}

或许,你应该做些变通。

看一看:

public class HolderClass<E extends SomeSuperClass> {

    private final Collection<E> myClass;

    public HolderClass() {
        myClass = new ArrayList<E>();
    }

    public void putSomeClass(final E clazz) {
        myClass.add(clazz);
    }

    public Collection<E> getMyClasses() {
        return myClass;
    }

} 

你可以这样收集:

HolderClass<SomeSuperClass> holderClass = new HolderClass<SomeSuperClass>();
holderClass.putSomeClass(new SomeClass());
holderClass.putSomeClass(new SomeSuperClass());

现在,当您调用getMyClasses()时,您将得到一些超类的集合

是的,我们可以!

class A {@Override
public String toString()
{

  return "A";
} };
class B extends A {
  @Override
  public String toString()
  {      
    return "B";
  }
};
List<A> l1 = new ArrayList<A>();
l1.add(new A());
List<B> l2 = null;
l2 = (List<B>)(List<? extends A>)l1;
l2.add(new B());

System.out.println( Arrays.toString( l2.toArray() ) );

请测试一下

解决方案

static result 回来之前 结果 为了能够使用 @SuppressWarnings .

/**
 * Casts a {@link Collection} to a {@link Collection} of an ancestral element type.
 *
 * @param collection the {@link Collection} to down-cast.
 * @param <T>        the required ancestral element type.
 *
 * @return the same {@link Collection} where the element type is the given ancestral type.
 */
public static <T> Collection<T> downCast( Collection<? extends T> collection )
{
    @SuppressWarnings( "unchecked" ) Collection<T> result = (Collection<T>)collection;
    return result;
}

class Ancestor {}
class Descendant extends Ancestor {} 
Collection<Descendant> descendants;
Collection<Ancestor> ancestors = downCast( descendants );

也适用于泛型:

class Ancestor<T> {}
class Descendant<T> extends Ancestor<T> {} 
Collection<Descendant<T>> descendants;
Collection<Ancestor<T>> ancestors = downCast( descendants );

对于超类型。

http://msdn.microsoft.com/en-us/library/dd799517(VS.100).aspx