Java So sánh Hai Lists

Question

Tôi có hai danh sách (không phải danh sách java, bạn có thể nói hai cột)

Ví dụ

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

Tôi muốn một phương thức trả về có bao nhiêu yếu tố này là giống nhau. Đối với ví dụ này, nó phải là 3 và nó sẽ trả lại cho tôi các giá trị tương tự của cả danh sách và các giá trị khác nhau.

Tôi có nên sử dụng hashmap nếu có thì phương pháp nào để nhận kết quả của tôi?

Xin giúp

PS: Nó không phải là một trường chuyển nhượng :) Vì vậy, nếu bạn chỉ cần hướng dẫn cho tôi nó sẽ đủ

Answer 1

EDIT

Dưới đây là hai phiên bản. Một sử dụng ArrayList và khác sử dụng HashSet

Hãy so sánh chúng và tạo phiên bản riêng của bạn từ này, cho đến khi bạn có được những gì bạn cần.

này nên là đủ để trang trải các:

PS: Nó không phải là một trường chuyển nhượng :) Vì vậy, nếu bạn chỉ cần hướng dẫn cho tôi nó sẽ đủ

một phần của câu hỏi của bạn .

tiếp tục với câu trả lời ban đầu:

Bạn có thể sử dụng một java.util.Collection và/hoặc java.util.ArrayList cho điều đó.

Phương pháp retainAll nào sau đây:

chỉ giữ lại các yếu tố trong bộ sưu tập này được chứa trong bộ sưu tập quy định

xem mẫu này:

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

Đối với phần thứ hai (giá trị tương tự), bạn có thể sử dụng các phương pháp removeAll:

Loại bỏ tất cả các yếu tố của bộ sưu tập này cũng được chứa trong bộ sưu tập xác định.

Phiên bản thứ hai này cung cấp cho bạn các giá trị và xử lý tương tự lặp lại (bằng cách loại bỏ chúng).

Lần này Collection có thể là một Set thay vì một List (giá trị chênh lệch là, Set không cho phép lặp lại)

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

Output:

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

Nếu nó doesn' t làm chính xác những gì bạn cần, nó mang lại cho bạn một khởi đầu tốt để bạn có thể xử lý từ đây.

Câu hỏi dành cho người đọc: Bạn sẽ bao gồm tất cả các giá trị lặp lại như thế nào?

Answer 2

Giả sử hash1 và 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

Là những thực sự lists (được đặt hàng, với các bản sao), hoặc là họ sets (không có thứ tự, không trùng lặp)?

Bởi vì nếu đó là sau này, sau đó bạn có thể sử dụng, giả sử, java.util.HashSet<E> và thực hiện việc này trong thời gian tuyến tính mong muốn bằng cách sử dụng số retainAll thuận tiện.

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

Bạn có thể thử các phương thức intersection() và subtract() từ CollectionUtils.

intersection() phương pháp cung cấp cho bạn bộ sưu tập có chứa các phần tử phổ biến và phương pháp subtract() cung cấp cho bạn tất cả những thứ không phổ biến.

Họ cũng nên chăm sóc của các yếu tố tương tự

Answer 5

Tôi tìm thấy một ví dụ rất cơ bản của Danh sách so sánh tại List Compare dụ này xác nhận kích thước đầu tiên và sau đó kiểm tra sự sẵn có của các yếu tố đặc thù của một danh sách trong một.

Answer 6

Sử dụng 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)); 
    }