Programlarımızda kullanmak için eski bir yapı olsa da hayatımızın içerisinde aktif olarak bulunan Java Collections Framework yapısının altında Queue arayüzüne bağlı PriorityQueue yapısını ele almak ve bu yapıyı öğrenmek istiyorum.
Öğrenirken alacağım notları, öğrendiğim bilgileri sizlerle paylaşmak için Java PriorityQueue Nedir, Özellikleri ve Kullanımı gibi alt başlıklar oluşturarak paylaşımda bulunmak istiyorum. Eğer, Collections Framework kavramı hakkında bir fikriniz yoksa konuyu anlamanızda kolaylık sağlaması için daha önce paylaşmış olduğum “Java Collections Nedir” isimli blog içeriğime emrecelen.com.tr/java-collections-nedir/ bu bağlantıyı takip ederek ulaşabilirsiniz. Böylelikle bizi nelerin beklediğini ve PriorityQueue kavramını aklımızda daha rahat şekilde canlandırabiliriz. 👌🏻💪🏻
Java PriorityQueue Nedir?
Java PriorityQueue, normal kuyruk (Queue) yapısının aksine içerdiği elemanları kimi zaman belirlenen öncelik sırasına kimi zaman sahip olduğu doğal sırasına göre sıralama işlemi yapan bir kuyruk aracıdır.
Queue yapılarından bahsederken First in First Out (FIFO) yani ilk giren eleman ilk çıkar mantığı ile çalıştığını dile getirmiştim. Ama bazen bu kuyruk sistemlerinde bazı değerlerimizin sistemden çıkmasının, işlenmesinin oldukça önemli olduğu senaryolar olabilir. Bu tip durumlarda yine bir kuyruk sistemi olan PriorityQueue sistemini kullanabilir ve böylelikle çeşitli Comparator ve Iterator yapıları tanımlayabiliriz. 👍🏻👌🏻
Biliyorum, teorik olarak bu kavramı anlamamız, aklımızda şekillendirmemiz oldukça zor. Bunun için yaşantımızın içerisinden bir örnek kurarak “Java PriorityQueue Nedir” sorusuna tekrar bir cevap oluşturalım.
Hastanelerin poliklinik servislerine gittiğimiz zaman muayene olabilmek için bir sıra numarası alırız. Almış olduğumuz bu sıra numaralarına göre de Doktorlar bizleri odaya alırlar. Genelde bu işlem first in first out şeklinde çalışır. Fakat herhangi bir kronik bir rahatsızlığı olan, hamile olan ve yaşı belirli bir seviyenin üstünde veya altında olan kişiler için bu sıralamada öncelik sağlandığını görmüşünüzdür. Bu yapı güncel hayatımızda kullandığımız bir priorityqueue sistemidir. (Queue Sistemine Göre Sıralanırsa: 👨🏻⚕️🚪👩🏻🦰🧔🏻👵🏻 / PriorityQueue Sistemine Göre Sıralanırsa: 👨🏻⚕️🚪👵🏻👩🏻🦰🧔🏻)
Java PriorityQueue Özellikleri
Teorik olarak tanıdığımız priorityqueue sisteminin kurulurken sahip olduğu temel özelliklere birlikte göz atalım.👀
- Collections yapılarının genelinde olduğu gibi bu yapımızın da boyutu dinamik bir şekilde büyür.
- Default olarak oluşturulduğunda sahip olduğu ilk kapasite 11’dir, ancak bu kapasite değerini sahip olduğu bir constructor tanımlaması ile değiştirebiliriz.
- İçerisinde null bir değer saklayamaz.
- Özel sıralama sistemi kurmamıza imkan sağlar.
- Varsayılan tanımlama yapıldığında, sıralama için doğal düzen yapısını kullanır.
- Thread-Safe bir yapı değildir.
Java PriorityQueue Kullanımı
PriorityQueue Kullanımı, içerisinde barındırdığı constructor (kurucu) metotları sayesinde bir birinden farklı şekillerde tanımlanarak kullanılır. Fakat ben fazla karışıklık olmasını istemediğim ve ilk aşamada zorluk yaşamamız için klasik tanımlama yöntemini kullanmak istiyorum.
Bunun için uygulayacağım tanımlama aşamalarını aşağıda maddeler halinde inceleyebilirsiniz. 🕵🏻♂️👨🏻💻
- Programımızın nasıl bir yapı kullanacağımızı tanıması için sınıfımızın içerisine “PriorityQueue” yapısını import ederek işlemimize başlıyoruz.
import java.util.PriorityQueue; - Sınıfımıza gerekli tanımlama işlemini gerçekleştirdikten sonra non-generic veya generic yapı da iki adet tanımlama şeklinden birisini ve ekstra olarak constructor yapılarından faydalanarak farklı tanımlama işlemleri gerçekleştirebiliriz.
PriorityQueue queue = new PriorityQueue(); ///---> Non-Generic tanımlama sonucunda Object olarak her türlü veriyi kabul edebilir <---\\\ PriorityQueue <String> q = new PriorityQueue<>(); ///---> Generic yapısında hangi veri tipi bulunuyorsa o verileri alır <---\\\
Gerçekleştirmiş olduğumuz bu tanımlamadan sonra bazı metot yapılarını kullanabilir hale gelmiş olacağız. Kendinizi hazır hissediyorsanız bu metot yapılarını da yakından inceleyerek tanıyalım. 👨🏻🏫🔍👀
Java PriorityQueue Metotları
Sınıf yapımıza priorityqueue yapısını import ettikten sonra aşağıdaki metot yapılarını sıkıntısız bir şekilde kullanmaya başlayabiliriz.
- Add(parametre): Parametre olarak aldığı değeri kuyruk yapımızın içerisine ekler.
- Offer(parametre): Add metot yapısında olduğu gibi parametre olarak almış olduğu değeri kuyruk yapısına ekler.
- Peek(): Kuyruk yapımızın ilk değerinin çıktısını verir fakat kuyruktan bu değeri silmez. Kuyruk boş ise, null değerini döndürür.
- Poll(): Peek metot yapısı gibi kuyruğun içerisinde bulunan ilk değerin çıktısını verir ve kuyruktan bu değeri siler. Kuyruk boş ise, null olarak geriye değer döndürür.
- Remove(parametre): Parametre olarak almış olduğu değer kuyrukta bulunuyorsa o veriyi siler.
- Size(): Kuyruğun içerisinde bekleyen öğe sayısının çıktısını döndürür.
- Comparator(): PriorityQueue yapısının öğelerini sıralayacak comparatoru verir. Eğer kuyruk yapısı doğal sıralı ise null olarak değer döndürür.
- Iterator(): Kuyruk yapımızı tarayacak bir iterator oluşturur.
Yukarıda bahsetmiş olduğum metot yapılarını daha yakından görebilmek, işleyiş yapılarını tanımak için basit bir konsol örneği oluşturalım. 👨🏻💻
- PriorityQueue içerisinde bulunan metot yapılarını daha yakından tanıyabilmek için “Main” sınıfım içerisine generic bir priorityqueue tanımlaması gerçekleştirdim.
- Tanımlama işlemimden sonra kuyruk yapısına ekleme işleminin gerçekleştiği metotları kullanarak bazı verilerin eklenmesini gerçekleştirdim
- Daha sonra eklediğim bu veriler üzerinde yukarıdaki metot yapılarımı kullanmaya başladım.
- Her kullandığım metot sonucunda verilerimdeki değişikliğin ekrana çıktısı olarak dönmesini sağlayan tanımlamaları gerçekleştirdim.
Oluşturmuş olduğum bu yapının kod halini aşağıdaki kod editöründen inceleyebilirsiniz.
import java.util.Iterator;
import java.util.PriorityQueue;
public class Main {
public static void main(String[] args) {
///---> Generic PriorityQueue Tanımlaması <---\\\
PriorityQueue <Integer> queue = new PriorityQueue<>();
///---> Kuyruk İçerisine Bazı Veriler Ekleyelim <---\\\
queue.add(30);
queue.offer(20);
queue.add(10);
queue.offer(40);
///---> Diğer Metot Yapılarını Kullanmadan Önce Kuyruğumuzdaki Verilerin Görünüşüne Bakalım <---\\\
System.out.println(ayrac+"\n< PriorityQueue Metotları >\n"+ayrac);
System.out.print("-> Kuyruk İçerisindeki Değerler: ");
queue.forEach( i -> System.out.print("["+i+"]")); ///---> Collections yapılarının genelinde bulunan foreach tanımlaması <---\\\
System.out.println("\n"+ayrac);
Iterator <Integer> iterator = queue.iterator(); ///---> İterator Kullanımı <---\\\
System.out.print("-> Iterator Metot Kullanımı Sonucunda Değerler: ");
while(iterator.hasNext()){
System.out.print("["+iterator.next()+"]");
}
System.out.println("\n-> Size Metot Kullanımı: "+queue.size()+" öğe bulunuyor.");
System.out.println("-> Poll Metot Kullanımı ile İlk Değere Ulaşmak: "+queue.poll());
System.out.print("-> Yeni Kuyruk Yapısı: ");
queue.forEach(i -> System.out.print("["+i+"]"));
System.out.println("\n-> Peek Metot Kullanımı ile İlk Değere Ulaşmak: "+queue.peek());
System.out.print("-> Remove(40) Metot Kullanımı: ");
queue.remove(40);
queue.forEach(i -> System.out.print("["+i+"]"));
System.out.println("\n-> Contains(40) Metot Kullanımı: "+queue.contains(40)+"\n"+ayrac);
}
}
Kod Çıktısı:
Kullanabileceğimiz metot yapılarının çalışma şekilleri hakkında bir fikir sahibi olduğumuza göre artık biraz daha detaya inerek çeşitli örnek yapıları oluşturalım. 👷🏻♂️👨🏻💻
Java PriorityQueue Örnekleri
PriorityQueue (Öncelikli Kuyruk) yapısını daha iyi anlayabilmemiz ve projelerimizin içerisinde nasıl kullanabileceğimizi daha detaylı öğrenmek için sizlerle çeşitli priorityqueue (öncelikli kuyruk) örnekleri oluşturmak istiyorum.
Bunun için ilk örneğimizde verilerin belli bir kural sistemi doğrultusunda ekrana çıktı verecek bir sistem oluşturalım.
- İlk örneğimiz olacağı için fazla kompleks bir yapı içerisine girmeden “Main” sınıfımın içerisinde gerekli import işlemlerini gerçekleştirerek örneğimin temellerini attım.
- Bu temelin oluşmasından sonra sınıfıma PriorityQueue yapısını generic bir şekilde tanımladım.
- Tanımlama işlemimi kurarken kuyruk yapımın içerisinde yer alan constructor metotlarından faydalanarak eleman limitimi 10 ve sıralanma kuralını belirleyeceğim bir “Comparator” tanımlaması oluşturarak gerçekleştirdim.
- Tanımlama işlemim bittikten sonra oluşan kuyruk yapıma eleman eklemek için bir for yapısı oluşturarak verilerin eklenmesini sağladım.
- Eklenen değerlerin çıktısını kontrol etmek için bir for döngüsü daha tanımlayarak değerleri kontrol ettim.
Yukarıda gerçekleştirmiş olduğum işlemler sonucunda oluşan kod satırlarını aşağıdaki editör üzerinden inceleyebilirsiniz.
import java.util.Comparator;
import java.util.PriorityQueue;
public class Main {
public static void main(String[] args) {
///---> Generic Öncelikli Kuyruk Tanımlaması <---\\\
PriorityQueue <Integer> que = new PriorityQueue<>(10,
new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
if(o1==o2)
return 0;
else if(o1 > o2)
return 1;
else
return -1;
}
});
System.out.println(ayrac+"\n< Java PriorityQueue Örnekleri #1 >\n"+ayrac);
System.out.print("-> Verilerin Eklenme Sırası: ");
///---> Verilerin Eklenmesi <---\\\
for(int i=0; i < 10; i++){
que.offer(10-i); ///---> 10 9 8 7 .... 1 şeklinde verilerin eklenmesini sağladık <---\\\
System.out.print("["+(10-i)+"]");
}
System.out.print("\n-> Comparator Yapısına Göre Sıralanması: ");
for(int i=0; i < 10; i++){
System.out.print("["+que.poll()+"]");
}
System.out.println("\n"+ayrac);
}
}
Kod Çıktısı:
Belirlemiş olduğum sıralama kuralına göre çalışan kuyruk yapım önce küçük değerlerin daha sonra büyük değerlerin çıkmasını sağlayan bir duruma büründü. İsterseniz bu yapıyı biraz daha geliştirerek nasıl farklı yapılar oluşturabileceğimizi görelim.
- Örneğim üzerinde öğrenci kayıtlarını tutacak bir kuyruk sistemi oluşturmak istedim. Bu yapıma çeşitli verilerin eklenmesini ve kuyruk içerisinde sıralanmasını sağlayacak “StudentDetails” isminde bir sınıf oluşturarak işlemime başladım.
- Bu sınıf yapım oluşturacağım PriorityQueue sisteminde belirli bir koşula göre sıralanmasını istediğim için sınıf yapıma Comprable yapısını implement ediyorum.
- Implement işleminden sonra gelen “compareTo” ismindeki metot yapımın içeriğini oluşturuyorum.
- Daha sonra öğrencilerimin çeşitli bilgilerini kayıt altına alacağım değişkenler ve bu değişkenlere değer atamasının gerçekleşeceği bir Constructor metot yapısı tanımlıyorum.
- Tüm bu işlemlerden sonra öğrenci bilgilerimin nasıl bir kalıba göre yazılacağını belirttiğim “toString” metodumu oluşturuyorum.
- Genel tanımlama işlemimi bitirdikten sonra “Main” sınıfıma gelerek öğrencilerin kayıtlarını oluşturuyorum ve kuyruk yapıma eklenmesini sağlıyorum.
- Ekleme işlemi bittikten sonra öğrencilerimin kuyruk içerisinde nasıl listelendiğini görmek için bir while döngüsü oluşturarak işlemimi bitiriyorum.
Gerçekleştirdiğim bu işlemlerden sonra “StudentDetails” ismindeki sınıf yapım aşağıdaki halini almış oluyor.
public class StudentDetails implements Comparable<StudentDetails>{
private int studentNo,firstEx,lastEx;
private double avg;
private String studentName;
public StudentDetails(int studentNo, String studentName, int firstEx, int lastEx){
this.studentNo = studentNo;
this.studentName = studentName;
this.firstEx = firstEx;
this.lastEx = lastEx;
avg = (firstEx * 0.4) + (lastEx * 0.6);
}
public String toString(){
return studentNo+"\t\t\t"+studentName+"\t\t\t"+firstEx+"\t\t\t"+lastEx+"\t\t\t"+avg;
}
///---> Ortalaması 60'dan Yukarı Olan Öğrencileri İlk Çıkartıyor <---\\\
@Override
public int compareTo(StudentDetails o) {
if(o.avg > 60)
return 1;
else
return -1;
}
}
Bu basit iki işlemin ardından “Main” sınıf yapım da aşağıdaki haline kavuşmuş oluyor.
import java.util.Iterator;
import java.util.PriorityQueue;
public class Main {
public static void main(String[] args) {
///---> Değişken Tanımlanması <---\\\
String ayrac = new String(new char[15]).replace("\0","-");
///---> Öğrenci Eklemesi Gerçekleştirelim <---\\\
StudentDetails omer = new StudentDetails(183006030,"Ömer",63,80);
StudentDetails mert = new StudentDetails(183006012,"Mert",49,57);
StudentDetails mustafa = new StudentDetails(183006045,"Mustafa",84,62);
StudentDetails emre = new StudentDetails(183006014,"Emre",48,92);
///---> PriorityQueue Tanımlaması <---\\\
PriorityQueue <StudentDetails> pQue = new PriorityQueue<>();
///---> Öğrenci Verilerinin Kuyruğa Kayıt Edilmesi <---\\\
pQue.add(omer);
pQue.add(mert);
pQue.add(mustafa);
pQue.add(emre);
Iterator iterator = pQue.iterator();
///---> Ekrana Yazdırma İşlemi <---\\\
System.out.println(ayrac+"\n< Java PriorityQueue Örnekleri #2 >\n"+ayrac);
System.out.println("Öğrenci Numarası\tİsmi\t\t\tVize Notu\tFinal Notu\tOrtalaması\n"+ayrac);
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println(ayrac);
}
}
Kod Çıktısı:
Bu oluşturmuş olduğum örnek içerisinde öğrencinin sahip olduğu not ortalamasına göre sıralama yapan bir priorityqueue yapısı oluşturduk. Daha sonra bu yapıyı kullanarak içerisine öğrenci bilgilerini ekledik ve ekran çıktısı olarak bu değerleri konsol ekranımıza gönderdik.
“Java PriorityQueue Nedir” sorusuna benimle cevap aradığınız ve bu serüvende bana eşlik ettiğiniz için teşekkür ederim (🙏🏻). Eğer konuya devam etmek ve bu yapı hakkında farklı kaynaklarda nasıl örnekler çözülmüş, anlatım uygulanmış görmek isterseniz sizlere güvenilir bir kaynak olan Oracle firmasının hazırlamış olduğu içeriği tavsiye ederim. Bahsetmiş olduğum içeriğe buraya tıklayarak ulaşabilirsiniz.
Unutmayın, aklınıza takılan herhangi bir soruyu ya da konu işleyişi ile ilgili önerilerinizi aşağıda bulunan yorum yap kısmından bana iletebilirsiniz.👋🏻
