Mam dwa ArrayList
obiekty z trzema liczbami całkowitymi każdy. Chcę znaleźć sposób na zwrócenie wspólnych elementów obu list. Czy ktoś ma pomysł, jak mogę to osiągnąć?
98
Użyj Collection#retainAll()
.
listA.retainAll(listB);
// listA now contains only the elements which are also contained in listB.
Jeśli chcesz uniknąć wpływu na zmiany w programie listA
, musisz utworzyć nowy.
List<Integer> common = new ArrayList<Integer>(listA);
common.retainAll(listB);
// common now contains only the elements which are contained in listA and listB.
Collection#retainAll()
i komentarzami we fragmentach kodu, nie, tak nie jest. Zmiany są odzwierciedlane na liście, na której wywołujesz metodę.Możesz użyć operacji ustawiania przecięcia z plikiem
ArrayList
obiektami.Coś takiego:
List<Integer> l1 = new ArrayList<Integer>(); l1.add(1); l1.add(2); l1.add(3); List<Integer> l2= new ArrayList<Integer>(); l2.add(4); l2.add(2); l2.add(3); System.out.println("l1 == "+l1); System.out.println("l2 == "+l2); List<Integer> l3 = new ArrayList<Integer>(l2); l3.retainAll(l1); System.out.println("l3 == "+l3);
Teraz
l3
powinny mieć tylko wspólne elementy międzyl1
al2
.CONSOLE OUTPUT l1 == [1, 2, 3] l2 == [4, 2, 3] l3 == [2, 3]
źródło
l2
. Prawdopodobnie chciałeśList<Integer> l3 = new ArrayList<Integer>(l2);
zamiast tego powiedzieć .Po co odkrywać koło na nowo? Użyj wspólnych zbiorów :
źródło
retainAll()
na powtarzalnych elementach. Więc prawdopodobnie jeden jest poprawny, a drugi błędny, w zależności od tego, jak podejdziesz do problemu.Korzystanie z
Stream.filter()
metody Java 8 w połączeniu zList.contains()
:import static java.util.Arrays.asList; import static java.util.stream.Collectors.toList; /* ... */ List<Integer> list1 = asList(1, 2, 3, 4, 5); List<Integer> list2 = asList(1, 3, 5, 7, 9); List<Integer> common = list1.stream().filter(list2::contains).collect(toList());
źródło
List<String> lista =new ArrayList<String>(); List<String> listb =new ArrayList<String>(); lista.add("Isabella"); lista.add("Angelina"); lista.add("Pille"); lista.add("Hazem"); listb.add("Isabella"); listb.add("Angelina"); listb.add("Bianca"); // Create an aplusb list which will contain both list (list1 and list2) in which common element will occur twice List<String> listapluslistb =new ArrayList<String>(lista); listapluslistb.addAll(listb); // Create an aunionb set which will contain both list (list1 and list2) in which common element will occur once Set<String> listaunionlistb =new HashSet<String>(lista); listaunionlistb.addAll(listb); for(String s:listaunionlistb) { listapluslistb.remove(s); } System.out.println(listapluslistb);
źródło
List<Integer> listA = new ArrayList<>(); listA.add(1); listA.add(5); listA.add(3); listA.add(4); List<Integer> listB = new ArrayList<>(); listB.add(1); listB.add(5); listB.add(6); listB.add(7); System.out.println(listA.stream().filter(listB::contains).collect(Collectors.toList())); Java 1.8 Stream API Solutions
Produkcja [1, 5]
źródło
Możesz uzyskać wspólne elementy między dwiema listami za pomocą metody „retainAll”. Ta metoda usunie wszystkie niedopasowane elementy z listy, do której ma zastosowanie.
W tym przypadku z listy wszystkie elementy, których nie ma na liście 1, zostaną usunięte i pozostaną tylko te, które są wspólne między listą i listą1.
List<Integer> list = new ArrayList<>(); list.add(10); list.add(13); list.add(12); list.add(11); List<Integer> list1 = new ArrayList<>(); list1.add(10); list1.add(113); list1.add(112); list1.add(111); //before retainAll System.out.println(list); System.out.println(list1); //applying retainAll on list list.retainAll(list1); //After retainAll System.out.println("list::"+list); System.out.println("list1::"+list1);
Wynik:
[10, 13, 12, 11] [10, 113, 112, 111] list::[10] list1::[10, 113, 112, 111]
UWAGA: Po zastosowaniu retainAll na liście, lista zawiera wspólny element między list i list1.
źródło
public <T> List<T> getIntersectOfCollections(Collection<T> first, Collection<T> second) { return first.stream() .filter(second::contains) .collect(Collectors.toList()); }
źródło
rozważ dwie listy L1 i L2
Korzystając z Java8 możemy łatwo to sprawdzić
L1.stream().filter(L2::contains).collect(Collectors.toList())
źródło
// Create two collections: LinkedList<String> listA = new LinkedList<String>(); ArrayList<String> listB = new ArrayList<String>(); // Add some elements to listA: listA.add("A"); listA.add("B"); listA.add("C"); listA.add("D"); // Add some elements to listB: listB.add("A"); listB.add("B"); listB.add("C"); // use List<String> common = new ArrayList<String>(listA); // use common.retainAll common.retainAll(listB); System.out.println("The common collection is : " + common);
źródło
Jeśli chcesz to zrobić sam ...
List<Integer> commons = new ArrayList<Integer>(); for (Integer igr : group1) { if (group2.contains(igr)) { commons.add(igr); } } System.out.println("Common elements are :: -"); for (Integer igr : commons) { System.out.println(" "+igr); }
źródło
commons
zawiera wspólne elementy. Druga pętla for drukuje je na konsoli. Nie widzę, gdzie kod liczy elementy wspólne.Niektóre z powyższych odpowiedzi są podobne, ale nie takie same, więc zamieszczaj je jako nową odpowiedź.
Rozwiązanie:
1. Użyj HashSet do przechowywania elementów, które mają zostać usunięte
2. Dodaj wszystkie elementy listy1 do HashSet
3. iteruj list2 i usuń elementy z HashSet, które są obecne w list2 ==> które są obecne zarówno w list1, jak i list2
4 Teraz iteruj po HashSet i usuń elementy z listy1 (ponieważ dodaliśmy wszystkie elementy z listy1 do zestawu), w końcu lista1 ma wszystkie wspólne elementy
Uwaga: Możemy dodać wszystkie elementy listy2 iw trzeciej iteracji powinniśmy usunąć elementy z lista2.
Złożoność czasowa: O (n)
Złożoność przestrzeni: O (n)
Kod:
import com.sun.tools.javac.util.Assert; import org.apache.commons.collections4.CollectionUtils; List<Integer> list1 = new ArrayList<>(); list1.add(1); list1.add(2); list1.add(3); list1.add(4); list1.add(5); List<Integer> list2 = new ArrayList<>(); list2.add(1); list2.add(3); list2.add(5); list2.add(7); Set<Integer> toBeRemoveFromList1 = new HashSet<>(list1); System.out.println("list1:" + list1); System.out.println("list2:" + list2); for (Integer n : list2) { if (toBeRemoveFromList1.contains(n)) { toBeRemoveFromList1.remove(n); } } System.out.println("toBeRemoveFromList1:" + toBeRemoveFromList1); for (Integer n : toBeRemoveFromList1) { list1.remove(n); } System.out.println("list1:" + list1); System.out.println("collectionUtils:" + CollectionUtils.intersection(list1, list2)); Assert.check(CollectionUtils.intersection(list1, list2).containsAll(list1));
wynik:
źródło
Poniższy kod Usuń typowe elementy z listy
Pobierz wspólne elementy
źródło