Question

有两个arraylists：

ArrayList<Integer[]> arr1 = new ArrayList<Integer[]>();
ArrayList<Integer[]> arr2 = new ArrayList<Integer[]>();
arr1.add(new Integer[]{1,2,3});
arr1.add(new Integer[]{1,2,2});
arr1.add(new Integer[]{1,2,3});
arr1.add(new Integer[]{1,1,1});
arr1.add(new Integer[]{1,1,1});

arr2.add(new Integer[]{1,2,3});
arr2.add(new Integer[]{1,2,2});

如何删除arr1中显示的arr2中的arr1中不具有唯一性的行？例如。在此示例中，我只需删除{1,2,3}，因为它在arr1中出现多次。我想到的唯一解决方案是使用4个FOR循环，但它似乎是非常低效的解决方案。

修改＃1 结果arr1: {1,2,3},{1,2,2},{1,1,1},{1,1,1}

Answer 1

排序列表1.从[1]开始循环列表1。如果存在重复的(a[i] == a[i-1])，请在列表2中查找该数组。如果存在，请删除a[i]。

请注意，在Java中，您无法在循环时修改列表，因此在完成循环后，您实际上需要保留要从列表1中删除的单独的数组列表。

这将导致从列表1中删除所有重复项。

Answer 2

如果您可以使用List代替数组，那么您可以执行以下操作：

List<List<Integer>> arr1 = new ArrayList<List<Integer>>();        
List<List<Integer>> arr2 = new ArrayList<List<Integer>>();

arr1.add(Arrays.asList(new Integer[]{1, 2, 3}));
arr1.add(Arrays.asList(new Integer[]{1, 2, 3}));
arr1.add(Arrays.asList(new Integer[]{1, 2, 2}));
arr1.add(Arrays.asList(new Integer[]{1, 2, 3}));
arr1.add(Arrays.asList(new Integer[]{1, 1, 1}));
arr1.add(Arrays.asList(new Integer[]{1, 1, 1}));

arr2.add(Arrays.asList(new Integer[]{1, 2, 3}));
arr2.add(Arrays.asList(new Integer[]{1, 2, 2}));

System.out.println(arr1);
System.out.println(arr2);

Set<List<Integer>> set1 = new HashSet<List<Integer>>();        
Iterator<List<Integer>> it = arr1.iterator(); 

while(it.hasNext()) {
    List<Integer> curr = it.next();
    if(!set1.add(curr) && arr2.contains(curr)) {
        it.remove();
    }
}

System.out.println(arr1);

输出：

[[1, 2, 3], [1, 2, 3], [1, 2, 2], [1, 2, 3], [1, 1, 1], [1, 1, 1]]
[[1, 2, 3], [1, 2, 2]]
[[1, 2, 3], [1, 2, 2], [1, 1, 1], [1, 1, 1]]

Answer 3

使用Set来删除非唯一身份用户。然后，您可以使用removeAll和retainAll。使用Integer[]（或int[]）的包装类，可以使用Arrays.equals。

public class IntArray implements Comparable<IntArray> {
    Integer[] items;

    public IntArray() {
        this.items = new Integer[0];
    }

    public IntArray(int... items) {
        this.items = items;
    }
    ...
}

Answer 4

使用list将是这样的：

Loop through 2 
For every element A, loop through 1 and delete element B if it matches A.

如果你只是将被删除的元素保留为null并且只清除最后删除所留下的空白点，而不是一直尝试移动元素，这将减少移位量（O（n）操作）并将整个时间从O(n^2*m^2)改为O(n*m)。

如果您可以使用sorted List1，则可以在O（logn）中查找和删除，则总复杂度将为mlogn

如果您可以使用HashMap，这将允许您在O（1）中查找和删除，您可以进一步将时间复杂度降低到基本O(m)，然后您可以使用一个循环来浏览列表2并从集合1中删除所有相同的元素。

Loop through List 1
     Add element to HashMap:Element -> Count (the count is here to preserve duplicates)
     If already exist in HashMap, Count++
Loop through List 2 
     For every element A, set B.get(A) = 0
Iterate through the HashMap
     For every entry, add the entry to the List *Count* times (rebuild list)

如果您是真的这样做，那么每一步都有辅助方法，使用它们。

从ArrayList＃1中删除出现在另一个ArrayList＃2中的行，并且在ArrayList＃1中是非唯一的

4 个答案: