boolean containsAll(Collection<?> c) vs boolean addAll(Collection<? extends E> c); 的设计决策在收集框架中[重复]

Question

为什么 boolean containsAll(Collection c);每种类型 ? 都允许使用收集框架的方法。但是 boolean addAll(Collection c); 允许？扩展 E。所以，我写了一个程序来澄清。 这是我的程序

public class ContainAllTest {
    // take ServiceDto 
    ArrayList<ServiceDto> resultList = new ArrayList<ServiceDto>();

    void Test() {

        ServiceDto serviceDto = new ServiceDto();
        serviceDto.setName("test");
        resultList.add(serviceDto);
        // another arraylist that takes String 
        ArrayList<String> resultList1 = new ArrayList<String>();
        resultList1.add("test");
        // no error, goes for run time.Contain all checking is done for two generic type ServiceDto and String:
        resultList.containsAll(resultList1);
        // error shown at compile time,as addAll take ServiceDto as generic type but the generic type for resultList1 take String:
        resultList.addAll(resultList1);    
    }

所以，我的问题是我什么时候可以利用 resultList.containsAll(resultList1);当泛型类型不同时。在我的情况下是 String 和 ServiceDto。用 boolean containsAll(Collection c 替换 boolean containsAll(Collection c) 是否有问题)

Answer 1

我猜原因是containsAll（和contains、remove、removeAll）使用Object#equals 进行比较。

可以想象，您可以在 E 中有一个覆盖的 Object#equals 方法，该方法可以为某些不相关类的对象返回 true。并不是说这是一个好主意，但它可能是一个有效的实现。

Answer 2

这并不是为了节省 cpu 滴答声。泛型由编译器erased 替换为强制类型转换。

对于addAll 方法类型安全需要考虑。应该只允许用户将Collection<E> 或E 的某个子类添加到Collection<E>。

如果你查看AbstractCollection 的源代码，你会看到这个方法：

public boolean addAll(Collection<? extends E> c) {
    boolean modified = false;
    for (E e : c)
        if (add(e))
            modified = true;
    return modified;
}

编译后它会看起来像（某种东西）

public boolean addAll(Collection c) {
    boolean modified = false;
    for (Object e : c)
        if (add((E)e))
            modified = true;
    return modified;
}

即要添加的集合的每个元素都需要在添加之前从Object 转换为E。

对于containsAll 方法没关系。由于equals 方法被定义为equals(Object other)，您可以安全地使用任何其他Collection 调用它，并且没有ClassCastExceptions 的风险。通过避免使用泛型，编译器可以避免添加强制类型转换。

Answer 3

原因与add和contains方法相同。

add 接受集合的泛型类型的参数，因为只有这样的对象才能添加到集合中。这就是在集合中使用泛型的全部意义所在。

contains（以及集合框架中的其他方法，如remove 和Map.get）接受任何对象作为参数。至少有两个原因。

首先，正如 Tobias Brandt 所说，可能有完全独立类型的对象与集合中的对象“相等”（由它们的 equals 实现定义）。

其次，每个集合Collection<E> 都可以看作Collection<? extends D>，其中D 是E 的超类，甚至可以看作Collection<?>（与Collection<? extends Object> 相同）。如果你做这个向上转换，你不能再调用 add 方法，因为它的签名看起来像 add(?) 并且编译器禁止调用它，因为它永远不能确保类型安全（你不能调用它很好add 因为您可能会向集合中添加错误的类型）。但是，调用contains 可能仍然有用，而且这始终是类型安全的，那么为什么不应该允许呢？为了实现这一点，contains 方法需要有Object 作为参数类型，否则不能像add 那样调用。

addAll 和 containsAll 的签名遵循同样的原则。