Java Bandingkan Dua Daftar

Saya punya dua daftar (bukan daftar java, Anda bisa mengatakan dua kolom)

Sebagai contoh

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

Saya ingin metode yang mengembalikan berapa banyak elemen yang sama. Untuk contoh ini seharusnya 3 dan harus mengembalikan nilai yang sama dari daftar dan nilai yang berbeda juga.

Haruskah saya menggunakan hashmap jika ya lalu metode apa untuk mendapatkan hasil saya?

Tolong bantu

PS: Itu bukan tugas sekolah :) Jadi kalau dibimbing saja sudah cukup

EDIT

Ini adalah dua versi. Satu penggunaan ArrayListdan penggunaan lainnyaHashSet

Bandingkan mereka dan buat versi Anda sendiri dari ini, sampai Anda mendapatkan yang Anda butuhkan.

Ini seharusnya cukup untuk menutupi:

PS: Itu bukan tugas sekolah :) Jadi kalau dibimbing saja sudah cukup

bagian dari pertanyaan Anda.

melanjutkan dengan jawaban asli:

Anda dapat menggunakan a java.util.Collection dan / atau java.util.ArrayListuntuk itu.

The retainAll Metode melakukan berikut ini:

Mempertahankan hanya elemen dalam koleksi ini yang terdapat dalam koleksi yang ditentukan

lihat contoh ini:

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

Untuk bagian kedua (nilai serupa) Anda dapat menggunakan metode removeAll :

Menghapus semua elemen koleksi ini yang juga terdapat dalam koleksi yang ditentukan.

Versi kedua ini memberi Anda juga nilai yang serupa dan pegangan yang berulang (dengan membuangnya).

Kali ini Collectionbisa menjadi Setbukan a List(perbedaannya adalah, Set tidak mengizinkan nilai berulang)

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

Keluaran:

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

Jika tidak melakukan apa yang Anda butuhkan, itu memberi Anda awal yang baik sehingga Anda dapat menangani dari sini.

Pertanyaan untuk pembaca: Bagaimana Anda akan memasukkan semua nilai yang diulang?

Anda dapat mencoba intersection()dan subtract()metode dari CollectionUtils.

intersection()metode memberi Anda koleksi yang berisi elemen umum dan subtract()metode memberi Anda semua yang tidak umum.

Mereka juga harus menjaga elemen serupa

Apakah ini benar-benar daftar (diurutkan, dengan duplikat), atau apakah mereka set (tidak berurutan, tidak ada duplikat)?

Karena jika yang terakhir, maka Anda dapat menggunakan, katakanlah, a java.util.HashSet<E>dan melakukan ini dalam waktu linier yang diharapkan dengan menggunakan kemudahan 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]"

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

Jika Anda mencari cara praktis untuk menguji persamaan dua koleksi, Anda dapat menggunakan org.apache.commons.collections.CollectionUtils.isEqualCollection, yang membandingkan dua koleksi terlepas dari urutannya.

Dari semua pendekatan, menurut saya menggunakan org.apache.commons.collections.CollectionUtils#isEqualCollectionadalah pendekatan terbaik. Inilah alasannya -

• Saya tidak perlu mendeklarasikan daftar tambahan / menetapkan sendiri
• Saya tidak mengubah daftar input
• Sangat efisien. Ia memeriksa kesetaraan dalam kompleksitas O (N).

Jika tidak memungkinkan untuk memiliki apache.commons.collectionsketergantungan, saya akan merekomendasikan untuk menerapkan algoritme berikut ini untuk memeriksa kesetaraan daftar karena efisiensinya.

Solusi sederhana: -

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

Keluaran: -

similiar [b, c]
different [f]

Dengan asumsi hash1danhash2

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.

Saya menemukan contoh yang sangat mendasar dari Perbandingan daftar di Perbandingan Daftar Contoh ini memverifikasi ukuran terlebih dahulu dan kemudian memeriksa ketersediaan elemen tertentu dari satu daftar di daftar lainnya.

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