在 Java 中存储不同类型对象的有序列表的最佳方法？

Question

我有几个用于创建对象的类。 这些对象每个都有必须运行的代码，具体取决于插入顺序。

它们需要按顺序存储 - 并按存储顺序召回。

1. 对象A
2. 对象B
3. 对象A
4. 对象A
5. 对象C
6. 对象D

我不确定在 Java 中处理这个问题的正确方法是否是通用列表并在运行时检查输入。

List<Object> list = new ArrayList<Object>();

我还考虑过将每个对象类型存储在它们自己的类型列表中，父对象以正确的顺序从列表中读取。 然而，这似乎比仅仅处理运行时检查对象类型要复杂得多。

处理这个问题的正确“Java”方法是什么？

Answer 1

如果对象不共享一个共同的祖先：

这些类不相关。 他们没有共同的祖先。

然后你可以做的是创建另一个类作为包装器：

1. T类型的对象。
2. 一个Consumer<T>对象，用作对需要调用的代码的引用。

例如：

    class Invocable<T> {
        private final T target;
        private final Consumer<T> invocation;

        public Invocable(T target, Consumer<T> invocation) {
            this.target = target;
            this.invocation = invocation;
        }

        public void runInvocation() {
            invocation.accept(target);
        }
    }

然后创建另一个管理List<Invocable>的类，如下所示：

class RunnableList {

    private List<Invocable<?>> invocables = new ArrayList<Invocable<?>>();

    public <T> void add(T target, Consumer<T> invocation) {
        invocables.add(new Invocable<T>(target, invocation));
    }

    public void run() {
        invocables.forEach(Invocable::runInvocation);
    }
}   

就是这样！ 只需使用add(T target, Consumer<T> invocation)方法将任何对象添加到RunnableList中，当您完成添加所有对象（引用要调用的相应代码）时，只需在RunnableList上调用run 。

以下是一个完整的工作示例，尝试一下以了解这个想法：

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class RunnableList {

    private List<Invocable<?>> invocables = new ArrayList<Invocable<?>>();

    public <T> void add(T target, Consumer<T> invocation) {
        invocables.add(new Invocable<T>(target, invocation));
    }

    public void run() {
        invocables.forEach(Invocable::runInvocation);
    }

    static class Invocable<T> {
        private final T target;
        private final Consumer<T> invocation;

        public Invocable(T target, Consumer<T> invocation) {
            this.target = target;
            this.invocation = invocation;
        }

        public void runInvocation() {
            invocation.accept(target);
        }
    }

    // TEST

    public static void main(String[] args) {
        RunnableList runnableList = new RunnableList();
        runnableList.add(new ClassA(), o -> o.run1("hello from A1"));
        runnableList.add(new ClassB(), o -> o.run1("hello from B1"));
        runnableList.add(new ClassC(), o -> o.run1("hello from C1"));

        runnableList.add(new ClassA(), ClassA::run2);
        runnableList.add(new ClassB(), ClassB::run2);
        runnableList.add(new ClassC(), ClassC::run2);
        runnableList.run();
    }

    static class ClassA {
        public void run1(String msg) {
            System.out.println("A.run1: " + msg);
        }
        public void run2() { System.out.println("A.run2"); }
    }
    static class ClassB {
        public void run1(String msg) {
            System.out.println("B.run1: " + msg);
        }
        public void run2() { System.out.println("B.run2"); }
    }
    static class ClassC {
        public void run1(String msg) {
            System.out.println("C.run1: " + msg);
        }
        public void run2() { System.out.println("C.run2"); }
    }
}

GitHub 上的完整代码

希望这可以帮助。