วิธีง่ายๆในการค้นหาว่ามีสองรายการที่แตกต่างกันมีองค์ประกอบที่เหมือนกันหรือไม่?

วิธีที่ง่ายที่สุดในการค้นหาคือถ้ารายการสองรายการมีองค์ประกอบเดียวกันในไลบรารี Java มาตรฐานหรือไม่

ไม่สำคัญว่าทั้งสองรายการจะเป็นอินสแตนซ์เดียวกันหรือไม่และไม่สำคัญว่าพารามิเตอร์ประเภทของรายการจะแตกต่างกันหรือไม่

เช่น

List list1
List<String> list2; 
// ... construct etc

list1.add("A");
list2.add("A"); 
// the function, given these two lists, should return true

อาจมีบางอย่างจ้องมองฉันในหน้าฉันรู้ :-)

แก้ไข: เพื่อชี้แจงฉันกำลังมองหาองค์ประกอบที่แน่นอนเดียวกันและจำนวนขององค์ประกอบในการสั่งซื้อ

หากคุณสนใจคำสั่งซื้อให้ใช้วิธีเท่ากับ:

list1.equals(list2)

จาก javadoc:

เปรียบเทียบวัตถุที่ระบุกับรายการนี้เพื่อความเท่าเทียมกัน ส่งคืนจริงถ้าและถ้าวัตถุที่ระบุเป็นรายการทั้งสองรายการมีขนาดเท่ากันและคู่ขององค์ประกอบที่เกี่ยวข้องในรายการทั้งสองนั้นเท่ากัน (สององค์ประกอบ e1 และ e2 มีค่าเท่ากันถ้า (e1 == null? e2 == ว่าง: e1.equals (e2))) ในคำอื่น ๆ รายการสองรายการจะถูกกำหนดให้เท่ากันหากมีองค์ประกอบเดียวกันในลำดับเดียวกัน . คำจำกัดความนี้ทำให้มั่นใจได้ว่าวิธีการที่เท่าเทียมกันทำงานอย่างถูกต้องในการใช้งานที่แตกต่างกันของรายการอินเตอร์เฟซ

หากคุณต้องการตรวจสอบความเป็นอิสระของคำสั่งซื้อคุณสามารถคัดลอกองค์ประกอบทั้งหมดไปยังชุดและใช้เท่ากับในชุดผลลัพธ์:

public static <T> boolean listEqualsIgnoreOrder(List<T> list1, List<T> list2) {
    return new HashSet<>(list1).equals(new HashSet<>(list2));
}

ข้อ จำกัด ของวิธีนี้คือไม่เพียง แต่ละเว้นคำสั่งเท่านั้น แต่ยังรวมถึงความถี่ขององค์ประกอบที่ซ้ำซ้อน ตัวอย่างเช่นหากlist1["A", "B", "A"] และlist2เป็น ["A", "B", "B"] Setวิธีการจะถือว่าพวกเขาเท่าเทียมกัน

หากคุณจำเป็นต้องมีความรู้สึกไวต่อการสั่งซื้อ แต่ละเอียดอ่อนต่อความถี่ของการทำซ้ำคุณสามารถ:

• เรียงลำดับรายการทั้งสอง (หรือสำเนา) ก่อนที่จะเปรียบเทียบพวกเขาเช่นเดียวกับที่ทำในคำตอบนี้กับคำถามอื่น
• หรือคัดลอกองค์ประกอบทั้งหมดไปที่Multiset

ฉันโพสต์สิ่งต่าง ๆ ในความคิดเห็นฉันคิดว่ามันรับประกันคำตอบของตัวเอง

ตามที่ทุกคนพูดที่นี่การใช้เท่ากับ () ขึ้นอยู่กับลำดับ หากคุณไม่สนใจคำสั่งซื้อคุณมี 3 ตัวเลือก

ตัวเลือกที่ 1

containsAll()ใช้ ตัวเลือกนี้ไม่เหมาะอย่างยิ่งในความคิดของฉันเพราะมันมีประสิทธิภาพกรณีที่เลวร้ายที่สุด O (n ^ 2)

ตัวเลือก 2

มีสองรูปแบบสำหรับสิ่งนี้:

2a)หากคุณไม่สนใจเกี่ยวกับการรักษาลำดับรายการของคุณ ... ใช้Collections.sort()ทั้งสองรายการ equals()จากนั้นใช้ นี่คือ O (nlogn) เพราะคุณทำสองประเภทแล้วเปรียบเทียบ O (n)

2b)หากคุณต้องการรักษาลำดับของรายการคุณสามารถคัดลอกทั้งสองรายการก่อน จากนั้นคุณสามารถใช้โซลูชัน2aทั้งในรายการที่คัดลอก อย่างไรก็ตามการทำเช่นนี้อาจไม่น่าสนใจหากการทำสำเนามีราคาแพงมาก

นี่นำไปสู่:

ตัวเลือก 3

หากความต้องการของคุณเหมือนกับภาค2bแต่การทำสำเนาแพงเกินไป คุณสามารถใช้ TreeSet เพื่อทำการเรียงลำดับสำหรับคุณ ดัมพ์แต่ละรายการเป็น TreeSet ของมันเอง มันจะถูกจัดเรียงในชุดและรายการเดิมจะยังคงอยู่ จากนั้นทำการequals()เปรียบเทียบทั้งสองTreeSetเอส TreeSetss สามารถสร้างขึ้นใน O (nlogn) เวลาและequals()เป็น O (n)

เลือก :-)

แก้ไข:ฉันเกือบลืมคำเตือนเดียวกับที่ Laurence Gonsalvesชี้ให้เห็น การใช้ TreeSet จะกำจัดรายการที่ซ้ำกัน หากคุณสนใจรายการที่ซ้ำกันคุณจะต้องมีชุดข้อมูลหลายชุดที่เรียงลำดับ

หากคุณกำลังใช้ (หรือมีความสุขที่จะใช้) คอลเลกชัน Apache Commons คุณสามารถใช้CollectionUtils.isEqualCollectionซึ่ง "คืนค่าจริงถ้า if คอลเลกชันที่กำหนดมีองค์ประกอบเดียวกันกับที่มีความสำคัญเหมือนกันทุกประการ"

ไปงานปาร์ตี้ช้ามาก แต่ต้องการเพิ่มการตรวจสอบความปลอดภัยแบบ null นี้:

Objects.equals(list1, list2)

ฉันรู้ว่านี่เป็นเธรดเก่า แต่ไม่มีคำตอบอื่นใดที่แก้ไขกรณีการใช้งานของฉันได้อย่างสมบูรณ์ (ฉันเดาว่า Multiset ของ Guava อาจทำแบบเดียวกัน แต่ไม่มีตัวอย่างที่นี่) โปรดแก้ตัวการจัดรูปแบบของฉัน ฉันยังใหม่ต่อการโพสต์ในการแลกเปลี่ยนสแต็ค นอกจากนี้แจ้งให้เราทราบหากมีข้อผิดพลาดใด ๆ

ให้บอกว่าคุณมีList<T>a และList<T>b และคุณต้องการตรวจสอบว่าพวกเขาจะเท่ากับเงื่อนไขต่อไปนี้:

1) O (n) เวลาทำงานที่คาดหวัง
2) ความเสมอภาคหมายถึง: สำหรับองค์ประกอบทั้งหมดใน a หรือ b จำนวนครั้งที่องค์ประกอบเกิดขึ้นใน a เท่ากับจำนวนครั้งที่องค์ประกอบเกิดขึ้นใน b ความเท่าเทียมกันขององค์ประกอบหมายถึง T.equals ()

private boolean listsAreEquivelent(List<? extends Object> a, List<? extends Object> b) {
    if(a==null) {
        if(b==null) {
            //Here 2 null lists are equivelent. You may want to change this.
            return true;
        } else {
            return false;
        }
    }
    if(b==null) {
        return false;
    }
    Map<Object, Integer> tempMap = new HashMap<>();
    for(Object element : a) {
        Integer currentCount = tempMap.get(element);
        if(currentCount == null) {
            tempMap.put(element, 1);
        } else {
            tempMap.put(element, currentCount+1);
        }
    }
    for(Object element : b) {
        Integer currentCount = tempMap.get(element);
        if(currentCount == null) {
            return false;
        } else {
            tempMap.put(element, currentCount-1);
        }
    }
    for(Integer count : tempMap.values()) {
        if(count != 0) {
            return false;
        }
    }
    return true;
}

เวลาทำงานคือ O (n) เพราะเรากำลังทำการแทรก O (2 * n) ลงใน hashmap และเลือก hashmap O (3 * n) ฉันยังไม่ได้ทดสอบรหัสนี้อย่างสมบูรณ์ดังนั้นโปรดระวัง :)

//Returns true:
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("B","A","A"));
listsAreEquivelent(null,null);
//Returns false:
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("B","A","B"));
listsAreEquivelent(Arrays.asList("A","A","B"),Arrays.asList("A","B"));
listsAreEquivelent(Arrays.asList("A","A","B"),null);

ลองใช้เวอร์ชั่นนี้ซึ่งไม่จำเป็นต้องมีคำสั่งเหมือนกัน แต่รองรับได้หลายค่า จะจับคู่ก็ต่อเมื่อแต่ละคนมีค่าเท่ากัน

public boolean arraysMatch(List<String> elements1, List<String> elements2) {
    // Optional quick test since size must match
    if (elements1.size() != elements2.size()) {
        return false;
    }
    List<String> work = newArrayList(elements2);
    for (String element : elements1) {
        if (!work.remove(element)) {
            return false;
        }
    }
    return work.isEmpty();
}

วิธีการที่เท่าเทียมกันในรายการจะทำเช่นนี้รายการจะถูกเรียงลำดับดังนั้นเพื่อให้เท่ากับสองรายการจะต้องมีองค์ประกอบเดียวกันในลำดับเดียวกัน

return list1.equals(list2);

วิธีแก้ปัญหาสำหรับกรณีที่รายการทั้งสองมีองค์ประกอบเดียวกัน แต่เรียงลำดับต่างกัน:

public boolean isDifferentLists(List<Integer> listOne, List<Integer> listTwo) {
    if(isNullLists(listOne, listTwo)) {
        return false;
    }

    if (hasDifferentSize(listOne, listTwo)) {
        return true;
    }

    List<Integer> listOneCopy = Lists.newArrayList(listOne);
    List<Integer> listTwoCopy = Lists.newArrayList(listTwo);
    listOneCopy.removeAll(listTwoCopy);

    return CollectionUtils.isNotEmpty(listOneCopy);
}

private boolean isNullLists(List<Integer> listOne, List<Integer> listTwo) {
    return listOne == null && listTwo == null;
}

private boolean hasDifferentSize(List<Integer> listOne, List<Integer> listTwo) {
    return (listOne == null && listTwo != null) || (listOne != null && listTwo == null) || (listOne.size() != listTwo.size());
}

คำตอบของทอมนั้นยอดเยี่ยมฉันเห็นด้วยอย่างยิ่งกับคำตอบของเขา!

ประเด็นที่น่าสนใจของคำถามนี้คือไม่ว่าคุณจะต้องการ Listประเภทของตัวเองและการเรียงลำดับโดยธรรมชาติ

ถ้าไม่ใช่คุณสามารถลดระดับIterableหรือCollectionทำให้คุณมีความยืดหยุ่นในการส่งผ่านโครงสร้างข้อมูลที่เรียงลำดับตามเวลาที่แทรกแทนที่จะเป็นเวลาที่คุณต้องการตรวจสอบ

หากคำสั่งไม่สำคัญ (และคุณไม่ได้มีองค์ประกอบที่ซ้ำกัน) Setพิจารณาการใช้

หากการสั่งซื้อมีความสำคัญ แต่ถูกกำหนดโดยเวลาที่ใส่ (และคุณไม่มีรายการที่ซ้ำกัน) ให้พิจารณาชุดLinkedHashSetที่คล้ายกับ TreeSet แต่เรียงลำดับตามเวลาที่แทรก (จะนับซ้ำกัน) นอกจากนี้ยังให้O(1)สิทธิ์การเข้าถึงที่O(log n)จำกัด ด้วย

รหัสตัวอย่าง:

public static '<'T'>' boolean isListDifferent(List'<'T'>' previousList,
        List'<'T'>' newList) {

    int sizePrevoisList = -1;
    int sizeNewList = -1;

    if (previousList != null && !previousList.isEmpty()) {
        sizePrevoisList = previousList.size();
    }
    if (newList != null && !newList.isEmpty()) {
        sizeNewList = newList.size();
    }

    if ((sizePrevoisList == -1) && (sizeNewList == -1)) {
        return false;
    }

    if (sizeNewList != sizePrevoisList) {
        return true;
    }

    List n_prevois = new ArrayList(previousList);
    List n_new = new ArrayList(newList);

    try {
        Collections.sort(n_prevois);
        Collections.sort(n_new);
    } catch (ClassCastException exp) {
        return true;
    }

    for (int i = 0; i < sizeNewList; i++) {
        Object obj_prevois = n_prevois.get(i);
        Object obj_new = n_new.get(i);
        if (obj_new.equals(obj_prevois)) {
            // Object are same
        } else {
            return true;
        }
    }

    return false;
}

นอกเหนือจากคำตอบของลอเรนซ์หากคุณต้องการทำให้เป็นโมฆะปลอดภัย:

private static <T> boolean listEqualsIgnoreOrder(List<T> list1, List<T> list2) {
    if (list1 == null)
        return list2==null;
    if (list2 == null)
        return list1 == null;
    return new HashSet<>(list1).equals(new HashSet<>(list2));
}

list1.equals(list2);

ถ้ารายการของคุณมีคลาส MyClass แบบกำหนดเองคลาสนี้ต้องแทนที่equalsฟังก์ชัน

 class MyClass
  {
  int field=0;
  @0verride
  public boolean equals(Object other)
        {
        if(this==other) return true;
        if(other==null || !(other instanceof MyClass)) return false;
        return this.field== MyClass.class.cast(other).field;
        }
  }

หมายเหตุ: หากคุณต้องการทดสอบเท่ากับ java.util.Set แทนที่จะเป็น a java.util.Listวัตถุของคุณจะต้องแทนที่hashCode ฟังก์ชัน

List.equals ()

http://java.sun.com/j2se/1.5/docs/api/java/util/List.html#equals(java.lang.Object)

คุณสามารถใช้ไลบรารี org.apache.commons.collections ของ Apache ได้ที่: http://commons.apache.org/collections/apidocs/org/apache/commons/collections/ListUtils.html

public static boolean isEqualList(java.util.Collection list1,
                              java.util.Collection list2)

ตรวจสอบว่ารายการทั้งสองไม่ใช่โมฆะ หากขนาดแตกต่างกันรายการเหล่านี้จะไม่เท่ากัน สร้างแผนที่ที่ประกอบด้วยองค์ประกอบรายการเป็นปุ่มและรายการซ้ำเป็นค่าและเปรียบเทียบแผนที่

สมมติฐานถ้าทั้งสองรายการเป็นโมฆะฉันถือว่าพวกเขาเท่ากัน

private boolean compareLists(List<?> l1, List<?> l2) {
    if (l1 == null && l2 == null) {
        return true;
    } else if (l1 == null || l2 == null) {
        return false;
    }

    if (l1.size() != l2.size()) {
        return false;
    }

    Map<?, Integer> m1 = toMap(l1);
    Map<?, Integer> m2 = toMap(l2);

    return m1.equals(m2);
}

private Map<Object, Integer> toMap(List<?> list) {
    //Effective size, not to resize in the future.
    int mapSize = (int) (list.size() / 0.75 + 1);
    Map<Object, Integer> map = new HashMap<>(mapSize);

    for (Object o : list) {
        Integer count = map.get(o);
        if (count == null) {
            map.put(o, 1);
        } else {
            map.put(o, ++count);
        }
    }

    System.out.println(map);
    return map;
}

โปรดทราบว่าควรกำหนดวิธีการเท่ากับอย่างถูกต้องสำหรับวัตถุเหล่านี้ https://stackoverflow.com/a/24814634/4587961

ขึ้นอยู่กับว่าคุณใช้คลาส List List อะไร AbstractCollection คลาสนามธรรมมีวิธีที่เรียกว่า containAll (Collection) ที่ใช้คอลเลกชันอื่น (List เป็นคอลเลกชัน) และ:

ผลตอบแทนจริงถ้าคอลเลกชันนี้มีองค์ประกอบทั้งหมดในคอลเลกชันที่ระบุ

ดังนั้นหากมีการส่ง ArrayList ในคุณสามารถเรียกใช้เมธอดนี้เพื่อดูว่าเหมือนกันหรือไม่

       List foo = new ArrayList();
    List bar = new ArrayList();
    String str = "foobar";

    foo.add(str);
    bar.add(str);

    foo.containsAll(bar);

เหตุผลสำหรับ containAll () เป็นเพราะมันวนซ้ำผ่านรายการแรกที่ค้นหาการจับคู่ในรายการที่สอง ดังนั้นหากพวกเขาออกคำสั่งเท่ากับ () จะไม่หยิบมันขึ้นมา

แก้ไข: ฉันแค่ต้องการแสดงความคิดเห็นที่นี่เกี่ยวกับเวลาทำงานตัดจำหน่ายในการดำเนินการตัวเลือกต่าง ๆ ที่นำเสนอ เวลาทำงานสำคัญหรือไม่ แน่ใจ มันเป็นสิ่งเดียวที่คุณควรพิจารณา? เลขที่

ค่าใช้จ่ายในการคัดลอกทุกองค์ประกอบจากรายการของคุณลงในรายการอื่นต้องใช้เวลาและมันยังใช้หน่วยความจำที่ดี (เพิ่มประสิทธิภาพหน่วยความจำที่คุณใช้เป็นสองเท่า)

ดังนั้นหากหน่วยความจำใน JVM ของคุณไม่ได้เป็นข้อกังวล (ซึ่งโดยทั่วไปควรเป็น) คุณก็ยังต้องพิจารณาเวลาที่ใช้ในการคัดลอกทุกองค์ประกอบจากสองรายการไปยัง TreeSets สองชุด โปรดจำไว้ว่ามันกำลังเรียงลำดับทุกองค์ประกอบเมื่อมันเข้ามา

คำแนะนำสุดท้ายของฉัน? คุณต้องพิจารณาชุดข้อมูลของคุณและจำนวนองค์ประกอบที่คุณมีในชุดข้อมูลของคุณและขนาดวัตถุแต่ละชิ้นในชุดข้อมูลของคุณก่อนที่คุณจะตัดสินใจได้ดี เล่นกับพวกเขาสร้างหนึ่งวิธีและดูว่าอันไหนเร็วกว่า มันเป็นการออกกำลังกายที่ดี