Question

我正在尝试删除List<List<float[]>>中找到的重复记录。我试图使用一个不允许重复的集合（HashList），但我无法弄清楚如何正确地转换它。循环遍历我将执行的所有元素。

List<List<float[]>> tmp; 

for(int i=0; i<tmp.get(0).size();i++){
    System.out.println(java.util.Arrays.toString(tmp.get(0).get(i)));
}

我想从里面的列表中删除它们。所以在tmp.get（0）.get（这里要删除）

中找到所有元素

tmp.get(0).get(1) =[-70.89,42.12]

tmp.get(0).get(2) =[-70.89,42.12]

我想删除tmp.get（0）.get（2）

当前实现，只有1个重复但不重复多个时才有效。

for(int i=0; i<old.get(0).size();i++){
            if(i == old.get(0).size()-1){
                System.out.println("max size");
                return old;
            }
            else if(Arrays.toString(old.get(0).get(i)).equalsIgnoreCase(Arrays.toString(old.get(0).get(i+1)))){
                old.get(0).remove(i);
                i++;
            } else {
            i++;
            }

Answer 1

如果我理解正确，您正在寻找Set<List<float[]>>。

Answer 2

怎么样：

List<List<Float[]>> outterList;
Set<Float[]> mySet = new HashSet<Float[]>();
for (List<Float[]> innerList : outterList){
    Iterator<Float[]> iterator = innerList.iterator();
    while(iterator.hasNext()){
        Float[] array = iterator.next();
        boolean added = mySet.add(array);
        if (!added)
           iterator.remove();
    }
}

要进行比较，请尝试通过new BigDecimal(double, MathContext)

转换为BigDecimal

更新：测试失败。似乎是比较HashSet中的数组的问题。

@Test
public void testArrays() {
    Set<String[]> set = new HashSet<String[]>();
    set.add(new String[] { "12.3f", "33.4f" });
    Assert.assertFalse(set.add(new String[] { "12.3f", "33.4f" }));
}

<强>更新

因此数组的工作方式不同。你走了：

这使用了番石榴的Predicate和Iterables.any()。此解决方案的效率低于使用Set，因为它必须每次都迭代List，但如果性能不是问题，它确实有效。

private static <T> Predicate<T[]> equals(final T[] array) {
    return new Predicate<T[]>() {

        @Override
        public boolean apply(T[] arg0) {
            return Arrays.equals(array, arg0);
        }
    };
}

public static <T> List<List<T[]>> ProcessList(List<List<T[]>> old) {
    List<T[]> mySet = new ArrayList<T[]>();
    for (List<T[]> innerList : old) {
        Iterator<T[]> iterator = innerList.iterator();
        while (iterator.hasNext()) {
            T[] array = iterator.next();
            Predicate<T[]> contains = equals(array);

            if (Iterables.any(mySet, contains)) {
                iterator.remove();
            } else {
                mySet.add(array);
            }
        }
    }
    // for (int i = 0; i < old.get(0).size(); i++) {
    // System.out.println(java.util.Arrays.toString(old.get(0).get(i)));
    // }
    return old;
}

这个测试：

@Test
public void testListsFloat() {
    List<List<Float[]>> outter = new ArrayList();

    List<Float[]> inner1 = new ArrayList();
    inner1.add(new Float[] { 12.3f, 33.4f });
    inner1.add(new Float[] { 12.2f, 33.2f });
    inner1.add(new Float[] { 12.3f, 33.4f });

    List<Float[]> inner2 = new ArrayList();
    inner2.add(new Float[] { 12.1f, 33.1f });
    inner2.add(new Float[] { 12.2f, 33.2f });
    inner2.add(new Float[] { 12.3f, 33.4f });

    outter.add(inner1);
    outter.add(inner2);

    outter = ProcessList(outter);
    for (List<Float[]> list : outter) {
        for (Float[] array : list) {
            System.out.println(Arrays.toString(array));
        }
    }
}

产生了这个输出：

[12.3,33.4] [12.2,33.2] [12.1,33.1]

Answer 3

填写时，您可以使用LinkedHashSet没有重复项。虽然它是Set的实现，但如果您需要List方法，则可以将其包装为List。

Java从List <list <float []>＆gt; </list <float []>中删除重复项

3 个答案: