Java supprimer les doublons de List<List<float[]>>

Question

Je tente de supprimer les enregistrements en double trouvés dans une List>. J'ai essayé d'utiliser une collection qui ne permet pas de doublons (HashList) mais je n'ai pas réussi à comprendre comment caster cela correctement. Pour parcourir tous mes éléments, je ferais.

List> tmp; 

for(int i=0; i

`

Je veux les supprimer de la liste à l'intérieur. Donc tous les éléments trouvés à tmp.get(0).get(à supprimer)

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

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

Je voudrais supprimer tmp.get(0).get(2)

Implémentation actuelle, qui fonctionne lorsqu'il n'y a qu'un seul doublon mais pas plusieurs doublons.

for(int i=0; i

`

Answer 1

Si j'ai bien compris, vous cherchez Set>.

Answer 2

Que diriez-vous de :

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

Pour faire la comparaison, essayez de convertir en BigDecimal via new BigDecimal(double, MathContext)

Mise à jour : Le test échoue. Il semble y avoir un problème avec la comparaison des tableaux dans un HashSet.

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

Mise à jour

Donc les tableaux fonctionnent différemment. Voici :

Cela utilise le Predicate de Guava et Iterables.any(). Cette solution est moins efficace que l'utilisation d'un Set car elle doit itérer sur la List à chaque fois mais cela fonctionne si la performance n'est pas un problème.

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

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

public static  List> ProcessList(List> old) {
    List mySet = new ArrayList();
    for (List innerList : old) {
        Iterator iterator = innerList.iterator();
        while (iterator.hasNext()) {
            T[] array = iterator.next();
            Predicate 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;
}

Ce test :

@Test
public void testListsFloat() {
    List> outter = new ArrayList();

    List 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 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 list : outter) {
        for (Float[] array : list) {
            System.out.println(Arrays.toString(array));
        }
    }
}

a donné cette sortie :

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

Answer 3

Vous pouvez utiliser LinkedHashSet pour ne pas avoir de doublons lors du remplissage. Bien que ce soit une implémentation de Set, vous pouvez l'envelopper dans une List si vous avez besoin des méthodes List.