ใน Java มีSortedSetและSortedMapอินเตอร์เฟซ ทั้งคู่เป็นของเฟรมเวิร์ก Java Collectionsและจัดเตรียมวิธีการเรียงลำดับเพื่อเข้าถึงองค์ประกอบ

อย่างไรก็ตามในความเข้าใจของฉันไม่มีSortedListใน Java คุณสามารถใช้java.util.Collections.sort()เพื่อเรียงลำดับรายการ

ความคิดใดที่ว่าทำไมมันถูกออกแบบเช่นนั้น

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

ฉันจะสั่งซื้อตามลำดับของประโยชน์ตามที่ฉันเห็น:

1. พิจารณาใช้SetหรือBagคอลเล็กชันแทน

หมายเหตุ:ฉันใส่ตัวเลือกนี้ไว้ที่ด้านบนเพราะนี่คือสิ่งที่คุณต้องการทำอยู่แล้ว

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

นอกจากนี้หากคุณแน่ใจว่าคุณไม่จำเป็นต้องกังวลเกี่ยวกับ (หรือมี) องค์ประกอบที่ซ้ำกันคุณสามารถใช้TreeSet<T>แทน มันใช้SortedSetและNavigableSetอินเทอร์เฟซและทำงานตามที่คุณคาดหวังจากรายการ:

TreeSet<String> set = new TreeSet<String>();
set.add("lol");
set.add("cat");
// automatically sorts natural order when adding

for (String s : set) {
    System.out.println(s);
}
// Prints out "cat" and "lol"

Comparator<T>หากคุณไม่ต้องการสั่งซื้อธรรมชาติที่คุณสามารถใช้พารามิเตอร์สร้างที่ใช้

อีกวิธีหนึ่งคือคุณสามารถใช้Multisets (หรือที่เรียกว่ากระเป๋า )ซึ่งเป็นSetองค์ประกอบที่อนุญาตให้ใช้องค์ประกอบที่ซ้ำกันแทนและมีการใช้งานของบุคคลที่สาม สิ่งที่สะดุดตาที่สุดจากห้องสมุดของ Guavaคือ a TreeMultiset, มันทำงานได้ดีเหมือนTreeSetกัน

2. เรียงลำดับรายการของคุณด้วย Collections.sort()

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

คุณสามารถจัดเรียงรายการของคุณด้วยjava.util.Collections.sort()วิธีการ นี่คือตัวอย่างโค้ดเกี่ยวกับวิธีการ:

List<String> strings = new ArrayList<String>()
strings.add("lol");
strings.add("cat");

Collections.sort(strings);
for (String s : strings) {
    System.out.println(s);
}
// Prints out "cat" and "lol"

การใช้เครื่องมือเปรียบเทียบ

หนึ่งประโยชน์ที่ชัดเจนคือการที่คุณอาจจะใช้Comparatorในsortวิธีการ Java ยังมีการใช้งานบางอย่างสำหรับComparatorเช่นCollatorที่เป็นประโยชน์สำหรับสตริงการเรียงลำดับที่มีความสำคัญสถานที่ นี่คือตัวอย่างหนึ่ง:

Collator usCollator = Collator.getInstance(Locale.US);
usCollator.setStrength(Collator.PRIMARY); // ignores casing

Collections.sort(strings, usCollator);

การเรียงลำดับในสภาพแวดล้อมที่เกิดขึ้นพร้อมกัน

โปรดทราบว่าการใช้sortวิธีนี้ไม่เป็นมิตรในสภาพแวดล้อมที่เกิดขึ้นพร้อมกันเนื่องจากจะมีการจัดการอินสแตนซ์การรวบรวมและคุณควรพิจารณาใช้คอลเล็กชันที่ไม่เปลี่ยนรูปแทน นี่คือสิ่งที่ Guava จัดให้มีในOrderingชั้นเรียนและเป็นสายการบินเดียวที่เรียบง่าย:

List<string> sorted = Ordering.natural().sortedCopy(strings);

3. ตัดรายการของคุณด้วย java.util.PriorityQueue

แม้ว่าจะไม่มีรายการเรียงใน Java แต่มีคิวเรียงซึ่งอาจจะทำงานได้ดีสำหรับคุณ มันเป็นjava.util.PriorityQueueคลาส

Nico Haase เชื่อมโยงความคิดเห็นกับคำถามที่เกี่ยวข้องที่ตอบคำถามนี้ด้วย

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

Caveat บนตัวPriorityQueueวนซ้ำ

PriorityQueueการดำเนินการในชั้นเรียนIterable<E>และCollection<E>การเชื่อมต่อเพื่อที่จะสามารถซ้ำได้ตามปกติ อย่างไรก็ตาม iterator ไม่รับประกันว่าจะคืนองค์ประกอบในลำดับที่เรียง แต่ (ตามที่ Alderath ชี้ให้เห็นในความคิดเห็น) คุณต้องpoll()เข้าคิวจนกว่าจะว่างเปล่า

โปรดทราบว่าคุณสามารถแปลงรายการเป็นคิวลำดับความสำคัญผ่านConstructor ที่รับการรวบรวม :

List<String> strings = new ArrayList<String>()
strings.add("lol");
strings.add("cat");

PriorityQueue<String> sortedStrings = new PriorityQueue(strings);
while(!sortedStrings.isEmpty()) {
    System.out.println(sortedStrings.poll());
}
// Prints out "cat" and "lol"

4. เขียนSortedListชั้นเรียนของคุณเอง

หมายเหตุ:คุณไม่ควรทำเช่นนี้

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

1. มันทำลายสัญญาที่List<E>ส่วนต่อประสานนั้นมีเพราะaddวิธีการต่าง ๆ ควรทำให้แน่ใจว่าองค์ประกอบนั้นจะอยู่ในดัชนีที่ผู้ใช้ระบุ
2. ทำไมต้องคิดค้นล้อใหม่ คุณควรใช้ TreeSet หรือ Multisets แทนดังที่กล่าวไว้ในจุดแรกด้านบน

อย่างไรก็ตามหากคุณต้องการทำแบบฝึกหัดที่นี่เป็นตัวอย่างโค้ดเพื่อให้คุณเริ่มต้นใช้AbstractListคลาสนามธรรม:

public class SortedList<E> extends AbstractList<E> {

    private ArrayList<E> internalList = new ArrayList<E>();

    // Note that add(E e) in AbstractList is calling this one
    @Override 
    public void add(int position, E e) {
        internalList.add(e);
        Collections.sort(internalList, null);
    }

    @Override
    public E get(int i) {
        return internalList.get(i);
    }

    @Override
    public int size() {
        return internalList.size();
    }

}

โปรดทราบว่าหากคุณยังไม่ได้แทนที่วิธีที่คุณต้องการการใช้งานเริ่มต้นจากAbstractListจะโยนUnsupportedOperationExceptions

เนื่องจากแนวคิดของรายการไม่สอดคล้องกับแนวคิดของคอลเลกชันที่เรียงลำดับโดยอัตโนมัติ จุดของรายการคือว่าหลังจากเรียกlist.add(7, elem)โทรไปจะกลับมาlist.get(7) elemด้วยรายการที่จัดเรียงอัตโนมัติองค์ประกอบอาจสิ้นสุดลงในตำแหน่งที่กำหนดเอง

ตั้งแต่รายการทั้งหมดที่มีอยู่แล้ว "เรียง" โดยการสั่งซื้อรายการที่ถูกเพิ่ม (FIFO การสั่งซื้อ) คุณสามารถ "รีสอร์ท" java.util.Collections.sort()พวกเขามีคำสั่งซื้ออื่นรวมทั้งการสั่งซื้อตามธรรมชาติขององค์ประกอบโดยใช้

แก้ไข:

แสดงรายการเป็นโครงสร้างข้อมูลตามสิ่งที่น่าสนใจคือการเรียงลำดับรายการที่แทรก

ชุดไม่มีข้อมูลนั้น

Listหากคุณต้องการสั่งซื้อโดยการเพิ่มเวลาการใช้งาน หากคุณต้องการที่จะสั่งซื้อโดยเกณฑ์อื่น ๆ SortedSetการใช้งาน

ชุดและแผนที่เป็นโครงสร้างข้อมูลที่ไม่ใช่เชิงเส้น รายการคือโครงสร้างข้อมูลเชิงเส้น

โครงสร้างข้อมูลแบบต้นไม้SortedSetและSortedMapส่วนต่อประสานนั้นใช้งาน TreeSetและTreeMapตามลำดับโดยใช้อัลกอริธึมการนำต้นไม้สีแดงดำ ดังนั้นจึงมั่นใจได้ว่าไม่มีรายการที่ซ้ำกัน (หรือปุ่มในกรณีของMap)

• List ถูกเก็บรักษาไว้แล้วในการเก็บรวบรวมสั่งซื้อและโครงสร้างข้อมูลที่ใช้ดัชนีต้นไม้ไม่มีโครงสร้างข้อมูลตามดัชนี
• Tree โดยนิยามไม่สามารถมีรายการที่ซ้ำกัน
• ในListเราสามารถทำซ้ำได้ดังนั้นจึงไม่มีTreeList(เช่นไม่มีSortedList)
• รายการเก็บรักษาองค์ประกอบตามลำดับการแทรก java.util.Collections.sort()ดังนั้นถ้าเราต้องการที่จะเรียงลำดับรายชื่อที่เราต้องใช้ เรียงลำดับรายการตามลำดับจากน้อยไปหามากตามลำดับธรรมชาติขององค์ประกอบ

JavaFX SortedList

แม้ว่ามันจะเอาในขณะที่, Java 8 Listจึงมีการเรียงลำดับ http://docs.oracle.com/javase/8/javafx/api/javafx/collections/transformation/SortedList.html

อย่างที่คุณเห็นใน javadocs มันเป็นส่วนหนึ่งของคอลเลกชันJavaFX ที่ตั้งใจจะให้มุมมองที่เรียงลำดับใน ObservableList

อัปเดต: โปรดทราบว่าด้วย Java 11 ชุดเครื่องมือ JavaFX ได้ย้ายไปอยู่ด้านนอกของ JDK และตอนนี้เป็นห้องสมุดแยก JavaFX 11 มีให้ดาวน์โหลดในรูปแบบ SDK หรือจาก MavenCentral ดูhttps://openjfx.io

สำหรับผู้ใช้ใหม่ ณ เดือนเมษายน 2558 ตอนนี้ Android มีคลาสSortedListในไลบรารีการสนับสนุนซึ่งออกแบบมาเพื่อทำงานโดยRecyclerViewเฉพาะ นี่คือบล็อกโพสต์เกี่ยวกับมัน

อีกจุดหนึ่งคือความซับซ้อนของเวลาในการแทรก สำหรับการแทรกรายการหนึ่งคาดว่าจะมีความซับซ้อนของ O (1) แต่นี่ไม่สามารถรับประกันได้ด้วยรายการที่เรียงลำดับ

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

คิดว่ามันเช่นนี้Listอินเตอร์เฟซที่มีวิธีการเช่น,add(int index, E element) set(int index, E element)สัญญาคือเมื่อคุณเพิ่มองค์ประกอบที่ตำแหน่ง X คุณจะพบมันที่นั่นเว้นแต่ว่าคุณจะเพิ่มหรือลบองค์ประกอบก่อนหน้านั้น

หากการใช้งานรายการใด ๆ จะจัดเก็บองค์ประกอบตามลำดับอื่นนอกเหนือจากดัชนีวิธีการรายการด้านบนจะไม่สมเหตุสมผล

บรรทัดแรกใน List API บอกว่ามันเป็นคอลเลกชันที่ได้รับคำสั่ง (หรือเรียกว่าลำดับ) หากคุณเรียงลำดับรายการคุณไม่สามารถรักษาลำดับได้ดังนั้นจึงไม่มี TreeList ใน Java
API บอกว่ารายการ Java ได้รับแรงบันดาลใจจาก Sequence และดูคุณสมบัติลำดับที่http://en.wikipedia.org/wiki/Sequence_(mathematics )

ไม่ได้หมายความว่าคุณไม่สามารถเรียงลำดับรายการได้ แต่ Java เข้มงวดกับคำจำกัดความของเขาและไม่ได้จัดเตรียมรายการเรียงลำดับตามค่าเริ่มต้น

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

1. ใช้รายการเข้าถึงแบบสุ่มสำหรับที่เก็บข้อมูล (เช่นArrayList)
2. ตรวจสอบให้แน่ใจว่าเรียงลำดับอยู่เสมอ

จากนั้นเพื่อเพิ่มหรือลบองค์ประกอบที่คุณสามารถใช้Collections.binarySearchเพื่อรับดัชนีการแทรก / การลบ เนื่องจากรายการของคุณใช้การเข้าถึงแบบสุ่มคุณสามารถแก้ไขรายการได้อย่างมีประสิทธิภาพด้วยดัชนีที่กำหนด

ตัวอย่าง:

/**
 * @deprecated
 *      Only for demonstration purposes. Implementation is incomplete and does not 
 *      handle invalid arguments.
 */
@Deprecated
public class SortingList<E extends Comparable<E>> {
    private ArrayList<E> delegate;

    public SortingList() {
        delegate = new ArrayList<>();
    }

    public void add(E e) {
        int insertionIndex = Collections.binarySearch(delegate, e);

        // < 0 if element is not in the list, see Collections.binarySearch
        if (insertionIndex < 0) {
            insertionIndex = -(insertionIndex + 1);
        }
        else {
            // Insertion index is index of existing element, to add new element 
            // behind it increase index
            insertionIndex++;
        }

        delegate.add(insertionIndex, e);
    }

    public void remove(E e) {
        int index = Collections.binarySearch(delegate, e);
        delegate.remove(index);
    }

    public E get(int index) {
        return delegate.get(index);
    }
}

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