Java優先佇列PriorityQueue的各種開啟方式以及一些你不知道的細節

YLTFY1998發表於2021-01-24
Java佇列

目錄

Java優先佇列PriorityQueue的各種開啟方式以及一些你不知道的細節

未經作者允許，不可轉載，如有錯誤，歡迎指正o(￣▽￣)o

  • 首先我們知道用PriorityQueue這個類建立的物件是一個集合，然後呼叫api可以將一個個物件新增入集合，然後再通過api遍歷時，插入的元素就從小到大排序輸出，真的太神奇了！
  • 下面將介紹優先佇列的預設用法以及我想自己寫個類，然後扔到優先佇列中讓它也能從小到大排序怎麼做？從大到小嘞？又或者我又想用系統的類比如String，但是我想按字典序從大到小能做嗎？
  • 題外話：每插入一個就會自動排序，這麼強大的功能，效率一定不高吧？但如果你學過資料結構，想一下建堆的過程，以及堆排序中新增與調整堆的過程你就會發現，堆排序與優先佇列每次插入排序的功能是那麼契合~
  • 下面的講解我嘗試用一種循序漸進的方式講述我知道的優先佇列，有經驗的讀者可能會覺得很囉嗦，但我還是覺得這能幫助你梳理一下知識點

優先佇列的預設用法—從小到大排序

我們先新建一個優先佇列，然後扔四個字元進去，然後用迭代器Iterator或者for-each方式遍歷列印，或者直接用println()列印，結果並非從小到大，而是（層序遍歷的堆，總之不是你要的~），事實上只有通過優先佇列定義的api才能按從小到大取出元素，比如remove方法

此時如果你對：

  1. 為什麼能用for each形式可以列印集合有疑惑：這就要追根溯源到這個PriorityQueue類的來源，Java集合框架是一個大家族，它們由很多的介面定義了不同的功能，再由很多抽象類去逐步實現這些介面的功能，抽象類一代代繼承，最後得到如優先佇列這樣的最終實現類，而for each的遍歷方式是它的最上面的祖先Iterable介面中的一個方法，任何實現了Iterable介面的類都能用迭代器進行遍歷
  2. 為什麼能System.out.println(XX);直接列印一個XX物件有疑惑：事實上只有實現了toString方法的類，才能在呼叫這個方法的時候轉化成字串再列印

回到我們的程式

public class PriorityQueueTest {
    public static void main(String[] args) {
        //這裡String型別預設實現Comparable介面的 就是按字典序排序 從小大到
        //上面這個註釋你可能不太明白，看下去就會明白了~，現在無視它
        var pq = new PriorityQueue<String>();
        pq.add("B");
        pq.add("D");
        pq.add("A");
        pq.add("C");
        //通過迭代器和for each，以及println輸出的順序是（層序遍歷的堆）
        System.out.println(pq);
        for (String s : pq)
            System.out.print(s);
        System.out.println();
        Iterator iter = pq.iterator();
        while (iter.hasNext())
            System.out.print(iter.next());
        System.out.println();
        //isEmpty方法是AbstractCollection抽象類中的
        while (!pq.isEmpty())
            //remove方法按照優先佇列中定義的每次返回最小的元素，並刪去該值
            //本例的最小是字典序最小，但是這個最小的概念是可以通過使用者自己定義的
            //怎麼定義下面會講
            System.out.print(pq.remove());
        System.out.println();
        System.out.println(pq);
    }
}

輸出結果

[A, C, B, D]
ACBD
ACBD
//很顯然上三種列印的順序並非我們需要的（列印的是層序的堆），沒有實現從小到大排序
ABCD
[]

對String類用優先佇列從大到小排序

現在需要補充一個知識點：想要往優先佇列裡放入一個物件，它就預設會去排序調整它在集合中的位置，與Java集合框架中的其他實現類一樣，而一切涉及排序功能的實現類，我們放入集合中的元素都必須實現了Comparable介面，或者在呼叫構造器時提供了Comparator物件為引數，這句話接下來會用示例講解~

  • 先來看一下String物件的原始碼，它能直接放入PriorityQueue類是因為它實現了Comparable介面的唯一一個方法compareTo，定義了兩個String以何種規則進行比較大小
//這是類的宣告部分，可以看到實現了Comparable介面，而這個介面就只有一個compareTo的抽象方法
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence
//抽象方法的實現
public int compareTo(String anotherString) {
        byte v1[] = value;
        byte v2[] = anotherString.value;
        if (coder() == anotherString.coder()) {
            return isLatin1() ? StringLatin1.compareTo(v1, v2)
                              : StringUTF16.compareTo(v1, v2);
        }
        return isLatin1() ? StringLatin1.compareToUTF16(v1, v2)
                          : StringUTF16.compareToLatin1(v1, v2);
     }
  • 現在我們來實現將String類放入PriorityQueue，完成字典序從大到小排序，上面我們講了，要實現排序可以通過兩種方法，對放入PriorityQueue集合的類String實現介面（這是系統的類，final修飾，你想動你不給你機會動呀~，這裡我們採用第二種方法，自定義一個Comparator物件傳入構造器，你可以理解為第一種方式需要放入的類自帶了排序規則，第二種方式是優先佇列定義了排序規則，必須有規則才能實現排序）

程式：

public class PriorityQueueTest {
    public static void main(String[] args) {
        //例項化一個比較器物件
        MyComparator myComparator = new MyComparator();

        //這裡在優先佇列的構造方法中傳入比較器物件，設定排序規則
        var pq = new PriorityQueue<String>(myComparator);
        pq.add("B");
        pq.add("D");
        pq.add("A");
        pq.add("C");
        System.out.println(pq);
        //通過迭代器和for each輸出的順序是元素的層序的堆
        for (String s : pq)
            System.out.print(s);
        System.out.println();
        Iterator iter = pq.iterator();
        while (iter.hasNext())
            System.out.print(iter.next());
        System.out.println();
        //isEmpty方法是AbstractCollection抽象類中的
        while (!pq.isEmpty())
            //remove方法按照優先佇列中定義的每次返回最小的元素
            //但是我們做了點手腳，讓大小反轉了，Java依舊是輸出小的，但是我們重新定義了字典序大的就是小
            System.out.print(pq.remove());
        System.out.println();
        System.out.println(pq);
    }
}
//這個自定義的比較器為優先佇列設定新的大小規則，
class MyComparator implements Comparator<String> {
    //來一下正負反轉實現從大到小的優先佇列，意思是字典序大的字串更小
    @Override
    public int compare(String o1, String o2) {
        return -1 * o1.compareTo(o2);
    }
}

輸出：

[D, C, A, B]
DCAB
DCAB
//分割線，下面就實現了從大到小的列印了，當然Java依舊遵守從小到大列印，只是你改動了其中的規則
DCBA
[]

通過自定義比較器對自定義的類進行從小到大排序

程式：對水果類用優先佇列排序，價格低的優先（更小），價格相同字典序小的優先（更小）

public class PriorityQueueTest {
    public static void main(String[] args) {
        MyComparator myComparator = new MyComparator();
        var pq = new PriorityQueue<Fruit>(myComparator);
        Fruit fruit1 = new Fruit(10, "Banana");
        Fruit fruit2 = new Fruit(10, "Peach");
        Fruit fruit3 = new Fruit(20, "Apple");
        Fruit fruit4 = new Fruit(30, "Apple");
        pq.add(fruit1);
        pq.add(fruit2);
        pq.add(fruit3);
        pq.add(fruit4);
        System.out.println(pq);
        while (!pq.isEmpty())
            System.out.print(pq.remove() + " ");
        System.out.println("\n" + pq);
    }
}

class Fruit {
    private int price;
    private String name;

    @Override
    public String toString() {
        return "Fruit{" +
                "price=" + price +
                ", name='" + name + '\'' +
                '}';
    }

    public Fruit(int price, String name) {
        this.price = price;
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class MyComparator implements Comparator<Fruit> {

    @Override
    public int compare(Fruit o1, Fruit o2) {
        //價格相同就定義水果的名稱的字典序小的優先順序更高（或者說更小）
        if (o1.getPrice() == o2.getPrice())
            return o1.getName().compareTo(o2.getName());
        //價格不同就價格小的優先順序更高（更小），這裡是>，返回值正數表示這種情況下
            // 你定義左側比右側優先順序更低（更大）,而優先佇列永遠是“小”的先輸出
        else
            return o1.getPrice() > o2.getPrice() ? 1 : -1;
    }
}

輸出：

[Fruit{price=10, name='Banana'}, Fruit{price=10, name='Peach'}, Fruit{price=20, name='Apple'}, Fruit{price=30, name='Apple'}]
//分割線
Fruit{price=10, name='Banana'} Fruit{price=10, name='Peach'} Fruit{price=20, name='Apple'} Fruit{price=30, name='Apple'} 
[]

通過自定義的類實現Comparable介面進行從大到小排序

程式：對水果類用優先佇列排序，價格大的優先，價格相同，字典序大的優先

public class PriorityQueueTest {
    public static void main(String[] args) {
        var pq = new PriorityQueue<Fruit>();
        Fruit fruit1 = new Fruit(10, "Banana");
        Fruit fruit2 = new Fruit(10, "Peach");
        Fruit fruit3 = new Fruit(20, "Apple");
        Fruit fruit4 = new Fruit(30, "Apple");
        pq.add(fruit1);
        pq.add(fruit2);
        pq.add(fruit3);
        pq.add(fruit4);
        System.out.println(pq);
        while (!pq.isEmpty())
            System.out.print(pq.remove() + " ");
        System.out.println("\n" + pq);
    }
}

class Fruit implements Comparable<Fruit>{
    private int price;
    private String name;

    @Override
    public String toString() {
        return "Fruit{" +
                "price=" + price +
                ", name='" + name + '\'' +
                '}';
    }

    public Fruit(int price, String name) {
        this.price = price;
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int compareTo(Fruit o) {
        if (this.getPrice() == o.getPrice())
            return this.getName().compareTo(o.getName()) * -1;
        else
            return this.getPrice() > o.getPrice() ? -1 : 1;
    }
}

輸出：

[Fruit{price=30, name='Apple'}, Fruit{price=20, name='Apple'}, Fruit{price=10, name='Peach'}, Fruit{price=10, name='Banana'}]
//分割線
Fruit{price=30, name='Apple'} Fruit{price=20, name='Apple'} Fruit{price=10, name='Peach'} Fruit{price=10, name='Banana'} 
[]

用lambda表示式優化比較器的使用

補充一個知識點吧：對於那些只帶有一個抽象方法的介面，又被稱之為函式式介面，所有能用函式式介面物件的地方，都能用lambda表示式代替（寫起來快一點，有時還能解耦合？）

舉個上面的栗子，Comparator介面就是一個函式式介面，下面是它的介面的宣告，@後面的寫的很清楚了，告訴你它是一個函式式介面~，所以偶爾看看這些類的實現對我們學習Java會有很大幫助

@FunctionalInterface
public interface Comparator<T>

下面用lambda表示式對上面那個，通過構造Comparator比較器物件，實現水果按價格和字典序從小到大排序例子進行優化

程式：

public class PriorityQueueTest {
    public static void main(String[] args) {
        //通過lambda表示式建立比較器介面物件
        Comparator<Fruit> comparator = (o1, o2) -> {
            //價格相同就定義水果的名稱的字典序小的優先順序更高（或者說更小）
            if (o1.getPrice() == o2.getPrice())
                return o1.getName().compareTo(o2.getName());
                //價格不同就價格小的優先順序更高（更小），這裡是>，返回值正數表示這種情況下
                // 你定義左側比右側優先順序更低（更大）,而優先佇列永遠是“小”的先輸出
            else
                return o1.getPrice() > o2.getPrice() ? 1 : -1;
        };
        //這裡和之前的比較器用法相同，函式式介面完美相容lambda表示式
        var pq = new PriorityQueue<Fruit>(comparator);
        Fruit fruit3 = new Fruit(20, "Apple");
        Fruit fruit4 = new Fruit(30, "Apple");
        Fruit fruit1 = new Fruit(10, "Banana");
        Fruit fruit2 = new Fruit(10, "Peach");
        pq.add(fruit1);
        pq.add(fruit2);
        pq.add(fruit3);
        pq.add(fruit4);
        System.out.println(pq);
        while (!pq.isEmpty())
            System.out.print(pq.remove() + " ");
        System.out.println("\n" + pq);
    }
}

class Fruit {
    private int price;
    private String name;

    @Override
    public String toString() {
        return "Fruit{" +
                "price=" + price +
                ", name='" + name + '\'' +
                '}';
    }

    public Fruit(int price, String name) {
        this.price = price;
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

輸出：

[Fruit{price=10, name='Banana'}, Fruit{price=10, name='Peach'}, Fruit{price=20, name='Apple'}, Fruit{price=30, name='Apple'}]
//分割線
Fruit{price=10, name='Banana'} Fruit{price=10, name='Peach'} Fruit{price=20, name='Apple'} Fruit{price=30, name='Apple'} 
[]

相關文章