处理arraylist的arraylist，每个都有不同的对象[关闭]

Question

我有这个，三个不同的数组列表：

ArrayList<type1> alista = new ArrayList<>();
ArrayList<type2> blistb = new ArrayList<>();
ArrayList<type3> clistc = new ArrayList<>();

然后我创建一个新的数组列表并将这 3 个数组列表放入其中：

ArrayList<Object> all_lists = new ArrayList<Object>();
all_lists.add(alista);
all_lists.add(blistb);
all_lists.add(clistc);

如何在 all_lists 中添加或删除对象：alista、blistb 和 clistc？我想在我的 main() 中的方法之间来回传递这个 all_lists。我知道这样做可能是错误的，但我想先让它发挥作用，然后再改进它。

例如，我如何从中获取 blistb，然后添加我创建的一种 type2，然后删除一种 type2（从 blistb 中）。然后将其放回（或创建新的 all_lists？）到 all_lists 中？

Answer 1

如果我理解正确，您希望能够传递所有数据并对列表进行更改。首先，我会将您的列表类型更改为 List 界面。这不是您的代码的功能，但如果您想在将来更改 List 实现，它会更容易，并且它还可以节省一些字符：

List<Type1> alista = new ArrayList<>();
List<Type2> blistb = new ArrayList<>();
List<Type3> clistc = new ArrayList<>();

我们将对 all_lists 做同样的事情，同时将其泛型类型更改为 List 以便以后更轻松：

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

（如果 Type1、Type2 和 Type3 有一些共同的祖先，它们都是从它们扩展而来的，则将上面的 Object 更改为该类型。）

要获取您的列表之一，例如 blistb，您需要知道它在 all_lists 中的位置：

List<Type2> blistbReference = allLists.get(1); // Index starts from 0

这可能很难维护和跟踪。还有一种风险是未来的一些代码更改会改变顺序，这会导致错误和令人头疼的问题。

处理列表的更好方法是将它们包装在数据对象中：

public class AllLists {
    private List<Type1> alista;
    private List<Type2> blistb;
    private List<Type3> clistc;

    public AllLists(List<Type1> alista, List<Type2> blistb, List<Type3> clistc) {
        this.alista = alista;
        this.blistb = blistb;
        this.clistc = clistc;
    }

    public List<Type1> getAlista() {
        return alista;
    }

    public List<Type1> getBlistb() {
        return blistb;
    }

    public List<Type1> getClistc() {
        return clistc;
    }
}
// ......

    AllLists allLists = new AllLists(alista, blistb, clistc);

您现在可以轻松地从 AllLists 对象中获取您的列表并随意修改它们。

Type2 t = new Type2;
allLists.getBlistb().add(t);

您不需要“放回列表”，因为 Java 是通过引用传递的。当您从 allLists 中获取 blistb 时，您将获得对同一列表对象的引用。对引用的任何更改都是对原始列表的更改。

我将类型和变量名更改为更加标准化。

Answer 2

您应该将all_lists 声明为List 的Lists；然后，您可以直接在特定索引的Lists 中添加和删除项目。

List<List> all_lists = new ArrayList<>();
all_lists.add(new ArrayList<A>(Arrays.asList(new A(1), new A(2), new A(3))));
all_lists.add(new ArrayList<B>(Arrays.asList(new B(4), new B(5))));
all_lists.add(new ArrayList<C>(Arrays.asList(new C(6))));
all_lists.get(1).add(new B(3));//add element to B List

Answer 3

您只需要跟踪哪个数组是哪个： 在：

ArrayList<Object> all_lists = new ArrayList<Object>();
all_lists.add(alista);
all_lists.add(blistb);
all_lists.add(clistc);

• all_lists.get(0) 是 alista
• all_lists.get(1) 是 blistb
• all_lists.get(2) 是 clistc

您可以从blistb 中删除该对象，方法是知道它在该列表中的哪个索引并像往常一样删除它。

all_lists.get(1).remove(2);

Answer 4

all_lists 应声明为ArrayList<ArrayList>（使用原始类型，这需要@SuppressWarnings("unchecked")）。

@SuppressWarnings("unchecked")
ArrayList<ArrayList> all_lists = new ArrayList<>();
all_lists.add(alista);
all_lists.add(blistb);
all_lists.add(clistc);

clistc.add(new type3());

all_lists.get(0).add(new type1()); // add type1 object to alista
all_lists.get(1).add(new type2()); // add type2 object to blistb
all_lists.get(2).remove(0); // remove the 1st element of clistc

但是，创建包装类而不是all_list 会是更好、更安全的面向对象的方法：

class ListWrapper {
    private List<type1> aListA;
    private List<type2> bListB;
    private List<type3> cListC;
// constructor(s), getters/setters

    public void addType1(type1 t1) {
        aListA.add(t1);
    }
// etc.
}