Mam dwie listy (nie listy java, możesz powiedzieć dwie kolumny)
Na przykład
**List 1** **Lists 2**
milan hafil
dingo iga
iga dingo
elpha binga
hafil mike
meat dingo
milan
elpha
meat
iga
neeta.peeta
Chciałbym metodę, która zwraca, ile elementów jest takich samych. W tym przykładzie powinno to być 3 i powinno zwrócić mi podobne wartości zarówno listy, jak i różne wartości.
Czy powinienem użyć hashmap, jeśli tak, to jaka metoda uzyskania wyniku?
Proszę pomóż
PS: To nie jest zadanie szkolne :) Więc jeśli mnie poprowadzisz, to wystarczy
java
list
comparison
hashmap
user238384
źródło
źródło
Odpowiedzi:
EDYTOWAĆ
Oto dwie wersje. Jeden używający
ArrayList
i inny używającyHashSet
Porównaj je i stwórz z tego własną wersję, aż uzyskasz to, czego potrzebujesz.
To powinno wystarczyć do pokrycia:
część twojego pytania.
kontynuując pierwotną odpowiedź:
Możesz użyć do tego a
java.util.Collection
i / lubjava.util.ArrayList
.Metoda retainAll wykonuje następujące czynności:
zobacz tę próbkę:
import java.util.Collection; import java.util.ArrayList; import java.util.Arrays; public class Repeated { public static void main( String [] args ) { Collection listOne = new ArrayList(Arrays.asList("milan","dingo", "elpha", "hafil", "meat", "iga", "neeta.peeta")); Collection listTwo = new ArrayList(Arrays.asList("hafil", "iga", "binga", "mike", "dingo")); listOne.retainAll( listTwo ); System.out.println( listOne ); } }
EDYTOWAĆ
W drugiej części (podobne wartości) możesz użyć metody removeAll :
Ta druga wersja podaje również podobne wartości i uchwyty powtórzone (odrzucając je).
Tym razem
Collection
może to być aSet
zamiast aList
(różnica polega na tym, że zestaw nie pozwala na powtarzanie wartości)import java.util.Collection; import java.util.HashSet; import java.util.Arrays; class Repeated { public static void main( String [] args ) { Collection<String> listOne = Arrays.asList("milan","iga", "dingo","iga", "elpha","iga", "hafil","iga", "meat","iga", "neeta.peeta","iga"); Collection<String> listTwo = Arrays.asList("hafil", "iga", "binga", "mike", "dingo","dingo","dingo"); Collection<String> similar = new HashSet<String>( listOne ); Collection<String> different = new HashSet<String>(); different.addAll( listOne ); different.addAll( listTwo ); similar.retainAll( listTwo ); different.removeAll( similar ); System.out.printf("One:%s%nTwo:%s%nSimilar:%s%nDifferent:%s%n", listOne, listTwo, similar, different); } }
Wynik:
Jeśli nie robi dokładnie tego, czego potrzebujesz, daje ci dobry początek, więc możesz sobie z tym poradzić.
Pytanie do czytelnika: Jak zawarłbyś wszystkie powtarzające się wartości?
źródło
listOne
, ale i tak +1!Można spróbować
intersection()
isubtract()
metody zCollectionUtils
.intersection()
metoda daje ci kolekcję zawierającą wspólne elementy, asubtract()
metoda daje ci wszystkie rzadkie.Powinni też zadbać o podobne elementy
źródło
Czy to naprawdę listy (uporządkowane, z duplikatami), czy też są to zestawy (nieuporządkowane, bez duplikatów)?
Bo jeśli jest to drugie, możesz użyć, powiedzmy,
java.util.HashSet<E>
ai zrobić to w oczekiwanym czasie liniowym, używając wygodnegoretainAll
.List<String> list1 = Arrays.asList( "milan", "milan", "iga", "dingo", "milan" ); List<String> list2 = Arrays.asList( "hafil", "milan", "dingo", "meat" ); // intersection as set Set<String> intersect = new HashSet<String>(list1); intersect.retainAll(list2); System.out.println(intersect.size()); // prints "2" System.out.println(intersect); // prints "[milan, dingo]" // intersection/union as list List<String> intersectList = new ArrayList<String>(); intersectList.addAll(list1); intersectList.addAll(list2); intersectList.retainAll(intersect); System.out.println(intersectList); // prints "[milan, milan, dingo, milan, milan, dingo]" // original lists are structurally unmodified System.out.println(list1); // prints "[milan, milan, iga, dingo, milan]" System.out.println(list2); // prints "[hafil, milan, dingo, meat]"
źródło
Korzystanie z java 8 removeIf
public int getSimilarItems(){ List<String> one = Arrays.asList("milan", "dingo", "elpha", "hafil", "meat", "iga", "neeta.peeta"); List<String> two = new ArrayList<>(Arrays.asList("hafil", "iga", "binga", "mike", "dingo")); //Cannot remove directly from array backed collection int initial = two.size(); two.removeIf(one::contains); return initial - two.size(); }
źródło
Jeśli szukasz wygodnego sposobu na przetestowanie równości dwóch kolekcji, możesz skorzystać z narzędzia
org.apache.commons.collections.CollectionUtils.isEqualCollection
, które porównuje dwie kolekcje niezależnie od kolejności.źródło
Ze wszystkich podejść uważam, że używanie
org.apache.commons.collections.CollectionUtils#isEqualCollection
jest najlepszym podejściem. Oto powody -Jeśli nie można mieć
apache.commons.collections
jako zależności, polecam zaimplementować algorytm, który następuje, aby sprawdzić równość listy ze względu na jej wydajność.źródło
Proste rozwiązanie: -
List<String> list = new ArrayList<String>(Arrays.asList("a", "b", "d", "c")); List<String> list2 = new ArrayList<String>(Arrays.asList("b", "f", "c")); list.retainAll(list2); list2.removeAll(list); System.out.println("similiar " + list); System.out.println("different " + list2);
Wynik :-
źródło
Zakładając
hash1
ihash2
List< String > sames = whatever List< String > diffs = whatever int count = 0; for( String key : hash1.keySet() ) { if( hash2.containsKey( key ) ) { sames.add( key ); } else { diffs.add( key ); } } //sames.size() contains the number of similar elements.
źródło
Znalazłem bardzo podstawowy przykład porównania list na stronie Porównanie list. Ten przykład najpierw weryfikuje rozmiar, a następnie sprawdza dostępność określonego elementu jednej listy na innej.
źródło
public static boolean compareList(List ls1, List ls2){ return ls1.containsAll(ls2) && ls1.size() == ls2.size() ? true :false; } public static void main(String[] args) { ArrayList<String> one = new ArrayList<String>(); one.add("one"); one.add("two"); one.add("six"); ArrayList<String> two = new ArrayList<String>(); two.add("one"); two.add("six"); two.add("two"); System.out.println("Output1 :: " + compareList(one, two)); two.add("ten"); System.out.println("Output2 :: " + compareList(one, two)); }
źródło
? true :false
jest potrzebny w Twoim fragmencie?