如何返回具有多种类型的对象

Question

让我们举个例子让它更容易。我构建了一个列表，构造函数采用integer 和List<Integer>。我的列表将包含给定列表的所有元素乘以integer。我的列表不存储新元素，而是动态计算它们：

class MyList extends AbstractList<Integer> implements RandomAccess {
    private final int multiplier;
    private final List<Integer> list;

    public MyList(int multiplier, List<Integer> list) {
        this.multiplier = multiplier;
        this.list = list;
    }

    @Override
    public Integer get(int index) {
        return list.get(index) * multiplier;
    }

    @Override
    public int size() {
        return list.size();
    }
}

然后我们可以用list = [0, 1, 2, 3]调用new MyList(3, list)来获取[0, 3, 6, 9]。

我想限制开发人员向MyList 构造函数提供一个列表，该列表也是RandomAccess，以确保他不会破坏性能。

我试图改变构造函数：

public <E extends List<Integer> & RandomAccess> MyList(int multiplier, E list)

MyList 不是问题，但现在我们不能在不使用 List<Integer> 和 RandomAccess 的实现的情况下调用构造函数，例如 ArrayList<Integer>。所以有这个列表的人：List<Integer> list = new ArrayList<>(); 不能做new MyList(3, list);（因为它是用List<Integer> 而不是ArrayList<Integer> 声明的）。

我的另一个解决方案是：

public MyList(int multiplier, List<Integer> list) {
        if(!(list instanceof RandomAccess)) {
            // Do something like log or throw exception
        }
        this.multiplier = multiplier;
        this.list = list;
    }

但是现在我无法在编译时检查列表是否实现了RandomAccess，我需要使用instanceof，我讨厌这样做。

我很确定有更好的方法，但它是什么？

Answer 1

您可以采用Collections.unmodifiableList 使用的解决方案。有一个静态方法，而不是一个公共构造函数，它返回两个实现之一，一个实现RandomAccess，另一个不实现。

这是Collections.unmodifiableList的代码。

public static <T> List<T> unmodifiableList(List<? extends T> list) {
    return (list instanceof RandomAccess ?
            new UnmodifiableRandomAccessList<>(list) :
            new UnmodifiableList<>(list));
}

我知道你说过你不喜欢使用instanceof。我也没有，但有时这是最好的选择。

注意使用构造函数的解决方案

public <E extends List<Integer> & RandomAccess> MyList(int multiplier, E list)

不仅丑陋，因为它迫使程序员强制转换（例如ArrayList），但它实际上不起作用。例如，如果list 是Collections$UnmodifiableRandomAccessList 的一个实例，则甚至不可能将其转换为同时实现List 和RandomAccess 的类型，因为Collections$UnmodifiableRandomAccessList 是私有的。

Answer 2

我建议使用instanceof。事实上，这正是RandomAccess 文档所建议的：

鼓励通用列表算法检查给定列表是否 在应用算法之前是这个接口的一个实例 如果将其应用于顺序，将提供较差的性能 访问列表，并在必要时更改其行为以保证 可接受的性能。

您的构造函数可能有两个实现。如果实现了RandomAccess，那么它将存储对List 的引用，否则它会创建一个新的ArrayList 并将所有元素复制到其中：

class MyList {
    private final int multiplier;
    private final List<Integer> list;

    public MyList(int multiplier, List<Integer> list) {
        this.multiplier = multiplier;
        if (list instanceof RandomAccess)
            this.list = list;
        else
            this.list = new ArrayList<>(list);
    }

    public int get(int index) {
        return multiplier * list.get(index);
    }
}

Answer 3

如果你的类需要一个随机访问列表，那么你的类应该处理这个问题，而不是把你的类的需求推给调用者。此外，在构造函数中做乘法会更简单——你必须在某个时候做，但尽早做意味着你可以扔掉很多代码：

class MyList extends ArrayList<Integer> {

    public MyList(int multiplier, List<Integer> list) {
        for (Integer i : list)
            add(i * multiplier);
    }
}

这就是你所需要的，并且它更安全：通过你的 immemtation，你的列表和调用者都有一个对列表的引用。如果在调用构造函数后调用更改了列表，则使用相乘列表的其他代码会意外地看到列表中的值发生变化。