Java Confrontare due elenchi

Question

Ho due liste (non elenchi Java, si può dire due colonne)

Per esempio

**List 1**   **Lists 2** 
    milan     hafil 
    dingo     iga 
    iga     dingo 
    elpha     binga 
    hafil     mike 
    meat     dingo 
    milan 
    elpha 
    meat 
    iga     
    neeta.peeta  

Vorrei un metodo che restituisce il numero di elementi sono gli stessi. Per questo esempio dovrebbe essere 3 e dovrebbe restituirmi valori simili sia di elenco che di valori diversi.

Devo usare hashmap se sì, allora quale metodo ottenere il mio risultato?

Si prega di aiutare

PS: Non è un compito scolastico :) Quindi, se mi guidi sarà sufficiente

Answer 1

EDIT

Qui ci sono due versioni. Un utilizzando ArrayList e altro utilizzando HashSet

confrontarli e creare la propria versione da questo, fino ad ottenere quello che ti serve.

Questo dovrebbe essere sufficiente a coprire il:

PS: Non è un compito scolastico :) Quindi, se mi guidi sarà sufficiente

parte della tua domanda .

continuare con la risposta originale:

È possibile utilizzare un java.util.Collection e/o java.util.ArrayList per questo.

Il metodo retainAll esegue le seguenti operazioni:

conserva solo gli elementi di questa raccolta che sono contenuti nell'insieme specificato

see questo esempio:

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); 
    } 
} 

EDIT

per la seconda parte (valori simili) è possibile utilizzare il metodo removeAll:

rimuove tutti gli elementi di questa collezione che sono anche contenuti nella raccolta specificata.

Questa seconda versione fornisce anche i valori e le maniglie simili ripetuti (scartandoli).

Questa volta il Collection potrebbe essere un Set invece di un List (valori la differenza è, il set non consente ripetute)

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); 
     } 
} 

uscita:

$ java Repeated 
One:[milan, iga, dingo, iga, elpha, iga, hafil, iga, meat, iga, neeta.peeta, iga] 

Two:[hafil, iga, binga, mike, dingo, dingo, dingo] 

Similar:[dingo, iga, hafil] 

Different:[mike, binga, milan, meat, elpha, neeta.peeta] 

Se esso doesn' Fare esattamente ciò che ti serve, ti dà un buon inizio in modo da poter gestire da qui.

Domanda per il lettore: come includere tutti i valori ripetuti?

Answer 2

Supponendo hash1 e hash2

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. 

Answer 3

Sono questi davvero lists (ordinato, con duplicati) o sono sets (non ordinati, non duplicati)?

Perché se è quest'ultimo, è possibile utilizzare, ad esempio, un java.util.HashSet<E> e farlo nel tempo lineare previsto utilizzando il conveniente retainAll.

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]" 

Answer 4

È possibile provare i metodi intersection() e subtract() da CollectionUtils.

intersection() metodo fornisce una raccolta contenente elementi comuni e il metodo subtract() fornisce tutti quelli non comuni.

Essi dovrebbero anche prendersi cura di simili elementi

Answer 5

ho trovato un esempio molto semplice di confronto Lista a List Compare Questo esempio verifica le dimensioni e poi controlla la disponibilità del particolare elemento di una lista in un altro.

Answer 6

utilizzando 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(); 
} 

Answer 7

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)); 
    }