Question

让我说我有两个列表（或矢量），我想要一个包含另一个的所有其他元素，即使第二个可以在以后获得更多元素，它们必须添加到第一个自动。例如：

ArrayList<String> l1 = Arrays.asList("1","2"),l2 =Arrays.asList("3","4");
"missing treatement"
System.out.println(l2);
System.out.println(l1);

显示器：

[3 4]

[1 2 3 4]

如果我添加到l2

list2.add("5); 
System.out.println(l2);
System.out.println(l1);

我明白了：

[3 4 5]

[1 2 3 4 5]

l1不仅可以包含自己的元素和l2的元素，还可以包含l3和l4。。以及我修改（添加或删除）元素的任何时候 li i>1

l1

也是如此

Answer 1

你想要的东西间接存在于Java中，但它位于JavaFX方面。具体来说，您想要使用可观察的FXCollections

使用FXCollections.observableList(List<E> list)方法应该返回传递给函数的列表的可观察包装。

现在为两个列表执行此操作

然后，为了让一个人观察另一个，你可能不得不切换到绑定的JavaFX世界的另一部分，即你可以使用以下方法将两个列表相互绑定：

Bindings.bindContentBidirectional(ObservableList<E> list1, ObservableList<E> list2)

在这里，您将两个可观察列表都传递给它，现在两者之间都有绑定。所以当一个更新时，另一个也会更新，反之亦然

示例程序显示这个（注意我没有使用 Bindings.bindContentBidirectional(ObservableList<E> list1, ObservableList<E> list2) 因为它急切地绑定并且如果不小心就有可能清空两个列表 ）：

package com.example;

import javafx.beans.binding.Bindings;
import javafx.beans.property.ListProperty;
import javafx.beans.property.SimpleListProperty;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.util.Pair;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {

    /**
     * @param observed The list you wish to observe
     * @param <T> Any type
     * @return A pair of lists. The first one is the observer list and second is the observed list
     */
    public static <T> Pair<List<T>, List<T>> observe(List<T> observed) {
        ObservableList<T> fxObserved = FXCollections.observableArrayList(observed);
        ListProperty<T> observerProperty = new SimpleListProperty<>(fxObserved);
        return new Pair<>(observerProperty, fxObserved);
    }

    public static void main(String[] args) {
        List<Integer> observed = IntStream.range(1, 11).boxed().collect(Collectors.toList());
        List<Integer> observer = new ArrayList<>();

        System.out.println("Before binding:");

        System.out.println(String.format("Observed list contains: %s", String.join(", ", observed.stream()
                .map(value -> value.toString())
                .collect(Collectors.toList()))));

        System.out.println(String.format("Observer list contains: %s", String.join(", ", observer.stream()
                .map(value -> value.toString())
                .collect(Collectors.toList()))));

        // make the list observable
        Pair<List<Integer>, List<Integer>> observingList = observe(observed);
        observer = observingList.getKey();
        observed = observingList.getValue();

        System.out.println("\n\nAfter binding:");

        System.out.println(String.format("Observed list contains: %s", String.join(", ", observed.stream()
                .map(value -> value.toString())
                .collect(Collectors.toList()))));

        System.out.println(String.format("Observer list contains: %s", String.join(", ", observer.stream()
                .map(value -> value.toString())
                .collect(Collectors.toList()))));

        observer.add(34);
        observed.add(45);

        System.out.println("\n\nAfter adding 34 and 45 to the lists:");
        System.out.println(String.format("Observed list contains: %s", String.join(", ", observed.stream()
                .map(value -> value.toString())
                .collect(Collectors.toList()))));

        System.out.println(String.format("Observer list contains: %s", String.join(", ", observer.stream()
                .map(value -> value.toString())
                .collect(Collectors.toList()))));
    }
}

输出：

Before binding:
Observed list contains: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Observer list contains: 


After binding:
Observed list contains: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Observer list contains: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10


After adding 34 and 45 to the lists:
Observed list contains: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 34, 45
Observer list contains: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 34, 45

Answer 2

引用arraylist的地址为

ArrayList<String> first = new ArrayList<String>();
ArrayList<String> second = first;

通过分配second = first，只有一个具有两个引用的arraylist。参考文献是相同的。因此，当您使用first或second拨打电话时，将对引用的arraylist执行调用。

如

second.add("a");
System.out.println(first.size());
System.out.println(second.size());

将显示1和

first.clear();
System.out.println(second.size());
System.out.println(first.size());

因为您已清除了arraylist，所以会显示0。

如果想要使用不同的内存地址，则可以这样做，

ArrayList<String> first = new ArrayList<String>();
ArrayList<String> second = new ArrayList<String>();;

并且在添加时具有执行以下操作的功能。

public void addFirst(String data){
     first.add(data);
     System.arraycopy( first, 0, second, 0, first.length );
}

public void addSecond(String data){
     second.add(data);
     System.arraycopy( second, 0, first, 0, second.length );
}

Answer 3

Agh，我正在研究类似于jgr208的答案，然后发现他打败了我。它使用别名调用。我不确定在没有创建某种包装类或自定义集合类的情况下，有一种明确的方法可以完全按照您的要求进行操作。

我想补充一点，我很难想到一个情况（虽然我确定可能存在），你想要有两个相同数据的副本，你必须保留同步。正如在jgr208的回答中一样，将数据存储在一个地方更好，两个引用该数据。这样更有效，并且不太可能产生错误。这是我的代码：

    List<String> list1, list2;
    Vector<String> vector1, vector2;

    list1 = new ArrayList<String>();
    vector1 = new Vector<String>();

    list1.add("First one");
    list1.add("Second one");

    vector1.add("First one");
    vector1.add("2nd one");

    list2 = list1;

    list2.add("Which list will this be in??");

    vector2 = vector1;

    vector2.add("Oh my goodness!");

    System.out.println(list1);
    System.out.println(list2);
    System.out.println(vector1);
    System.out.println(vector2);

结果是：

     [First one, Second one, Which list will this be in??]
     [First one, Second one, Which list will this be in??]
     [First one, 2nd one, Oh my goodness!]
     [First one, 2nd one, Oh my goodness!]

如何在JAVA中将元素添加到另一个列表（或向量）时自动添加元素

3 个答案: