جاوا جي Comparator ڪلاس

سلام اڄ اسان شين جي مقابلي بابت ڳالهائڻ وارا آهيون. ها... پر ڇا اسان اڳ ۾ ئي هن موضوع تي هڪ ڀيرو کان وڌيڪ نه ڳالهايو آهي؟ :/ اسان ڄاڻون ٿا ته ==آپريٽر ڪيئن ڪم ڪندو آهي، انهي سان گڏ equals()۽ hashCode()طريقا. مقابلو ٿورڙو مختلف آهي. اڳي، اسان جو مطلب گهڻو ڪري "برابري لاء شيون چيڪ ڪرڻ" آهي. پر هڪ ٻئي سان شين جي مقابلي جا سبب مڪمل طور تي مختلف ٿي سگهن ٿا! انهن مان سڀ کان وڌيڪ واضح آهي ترتيب ڏيڻ. منهنجو خيال آهي ته جيڪڏهن توهان کي ٻڌايو ويو ته انگن يا تارن کي ترتيب ڏيو ArrayList<>، توهان بغير ڪنهن پريشاني جي هن کي سنڀالڻ جي قابل هوندا:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {

   public static void main(String[] args) {

       String name1 = "Masha";
       String name2 = "Sasha";
       String name3 = "Dasha";

       List<String> names = new ArrayList<>();
       names.add(name1);
       names.add(name2);
       names.add(name3);

       Collections.sort(names);
       System.out.println(names);
   }
}

ڪنسول آئوٽ:

[Dasha, Masha, Sasha]

جيڪڏهن توهان Collectionsڪلاس ۽ ان جو sort()طريقو ياد ڪيو، سٺو ڪيو! مان سمجهان ٿو ته توهان کي نمبرن سان ڪا به پريشاني نه هوندي. هتي توهان لاءِ هڪ وڌيڪ مشڪل ڪم آهي:

public class Car {

   private int manufactureYear;
   private String model;
   private int maxSpeed;

   public Car(int manufactureYear, String model, int maxSpeed) {
       this.manufactureYear = manufactureYear;
       this.model = model;
       this.maxSpeed = maxSpeed;
   }

   // ...getters, setters, toString()

}

import java.util.ArrayList;
import java.util.List;

public class Main {

   public static void main(String[] args) {

       List<Car> cars = new ArrayList<>();

       Car ferrari = new Car(1990, "Ferrari 360 Spider", 310);
       Car lambo = new Car(2012, "Lamborghini Gallardo", 290);
       Car bugatti = new Car(2010, "Bugatti Veyron", 350);

       cars.add(ferrari);
       cars.add(bugatti);
       cars.add(lambo);
   }
}

ڪم اصل ۾ سادو آهي. اسان وٽ ھڪڙو Carڪلاس ۽ 3 ڪار شيون آھن. ڇا توھان مھرباني ڪري لسٽ ۾ ڪارن کي ترتيب ڏيو ٿا؟ توهان شايد شايد پڇو، "انهن کي ڪيئن ترتيب ڏيڻ گهرجي؟" نالي سان؟ پيداوار جي سال طرفان؟ وڌ ۾ وڌ رفتار سان؟ بهترين سوال. هن وقت، اسان کي خبر ناهي ته Carشيون ڪيئن ترتيب ڏيو. ۽، بلڪل قدرتي طور، جاوا کي خبر ناهي ته يا ته! جڏهن اسان Carشين جي لسٽ کي طريقي سان منتقل ڪرڻ جي ڪوشش ڪندا آهيون Collections.sort()، اسان کي هڪ غلطي ملي ٿي:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {

   public static void main(String[] args) {

       List<Car> cars = new ArrayList<>();

       Car ferrari = new Car(1990, "Ferrari 360 Spider", 310);
       Car lambo = new Car(20012, "Lamborghini Gallardo", 290);
       Car bugatti = new Car(2010, "Bugatti Veyron", 350);

       cars.add(ferrari);
       cars.add(bugatti);
       cars.add(lambo);

       // Compilation error!
       Collections.sort(cars);
   }
}

۽ درحقيقت، ٻولي ڪيئن ڄاڻي سگهندي ته توهان جي لکيل صنفن جي شين کي ڪيئن ترتيب ڏيو؟ اهو منحصر آهي ته توهان جي پروگرام کي ڇا ڪرڻ جي ضرورت آهي. اسان کي ڪنهن نه ڪنهن طرح جاوا کي سيکارڻ گهرجي انهن شين جو مقابلو ڪرڻ. ۽ انهن جو مقابلو ڪرڻ لاءِ جيئن اسان چاهيون ٿا. جاوا وٽ ھن لاءِ ھڪ خاص ميکانيزم آھي: Comparableانٽرفيس. اسان جي شين کي ڪنهن به طرح موازنہ ۽ ترتيب ڏيڻ لاءِ Car، ڪلاس کي لازمي طور تي هن انٽرفيس کي لاڳو ڪرڻ گهرجي، جيڪو هڪ طريقو تي مشتمل آهي: compareTo():

public class Car implements Comparable<Car> {

   private int manufactureYear;
   private String model;
   private int maxSpeed;

   public Car(int manufactureYear, String model, int maxSpeed) {
       this.manufactureYear = manufactureYear;
       this.model = model;
       this.maxSpeed = maxSpeed;
   }

   @Override
   public int compareTo(Car o) {
       return 0;
   }

   // ...getters, setters, toString()

}

مهرباني ڪري نوٽ ڪريوجيڪو اسان Comparable<Car>انٽرفيس جي وضاحت ڪئي، نه صرف Comparable. هي هڪ parameterized انٽرفيس آهي، اهو آهي، اسان کي مخصوص لاڳاپيل طبقي جي وضاحت ڪرڻ گهرجي. اصول ۾، توهان <Car>انٽرفيس تان هٽائي سگهو ٿا، پر پوءِ موازن Objectشين تي ٻڌل هوندو ڊفالٽ. طريقي جي بدران compareTo(Car o)، اسان جي طبقي ۾ هوندي:

@Override
   public int compareTo(Object o) {
       return 0;
   }

يقينن، اسان لاء ڪم ڪرڻ تمام آسان آهي Car. طريقي جي اندر compareTo()، اسان ڪارن جي مقابلي لاء اسان جي منطق تي عمل ڪندا آهيون. فرض ڪريو اسان کي انهن کي ترتيب ڏيڻ جي ضرورت آهي پيداوار جي سال طرفان. توهان شايد محسوس ڪيو آهي ته اهو compareTo()طريقو واپس اچي ٿو هڪ int، نه boolean. اهو توهان کي حيران ٿيڻ نه ڏيو. جڏهن اسان ٻن شين جو مقابلو ڪريون ٿا، اتي 3 امڪان آهن:

• а < b
• a > b
• a == b.

booleanصرف 2 قدر آهن: صحيح ۽ غلط، جيڪي شيون جي مقابلي لاءِ سٺو ڪم نٿا ڪن. سان int، سڀڪنھن شيء کي تمام آسان آهي. جيڪڏهن واپسي جي قيمت آهي > 0، پوء a > b. جيڪڏهن نتيجو compareToآهي ته < 0، پوء a < b. ۽، جيڪڏهن نتيجو آهي == 0، پوء ٻه شيون برابر آهن: a == b. اسان جي طبقي کي سيکارڻ لاء ڪارن کي ترتيب ڏيڻ جي سال جي ترتيب سان آسان آهي:

@Override
public int compareTo(Car o) {
   return this.getManufactureYear() - o.getManufactureYear();
}

پر هتي ڇا ٿي رهيو آهي؟ اسان هڪ ڪار شئي وٺون ٿا ( this)، هن ڪار جي پيداوار جو سال حاصل ڪريو، ۽ ان مان هڪ ٻئي ڪار جي پيداوار جو سال (جنهن سان اعتراض ڪيو پيو وڃي) کي گھٽايو. جيڪڏهن پهرين ڪار جي پيداوار جو سال وڏو آهي، اهو طريقو واپس ڪندو int > 0. هن جو مطلب آهي ته this car >ڪار o. ان جي ابتڙ، جيڪڏهن ٻئي ڪار جي پيداوار جو سال ( о) وڏو آهي، ته اهو طريقو هڪ منفي نمبر واپس ڪندو، جنهن جو مطلب آهي o > this. آخرڪار، جيڪڏهن اهي برابر آهن، پوء طريقو واپس ٿيندو 0. هي سادو ميکانيزم اسان لاءِ ڪافي آهي ته اسان Carشين جي مجموعن کي ترتيب ڏيو! توهان کي ٻيو ڪجهه ڪرڻ جي ضرورت ناهي. چڪاس ڪريو:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {

   public static void main(String[] args) {

       List<Car> cars = new ArrayList<>();

       Car ferrari = new Car(1990, "Ferrari 360 Spider", 310);
       Car lambo = new Car(2012, "Lamborghini Gallardo", 290);
       Car bugatti = new Car(2010, "Bugatti Veyron", 350);

       cars.add(ferrari);
       cars.add(bugatti);
       cars.add(lambo);

       // There was previously an error here
       Collections.sort(cars);
       System.out.println(cars);
   }
}

ڪنسول آئوٽ:

[Car{manufactureYear=1990, model='Ferrari 360 Spider', maxSpeed=310}, 
Car{manufactureYear=2010, model='Bugatti Veyron', maxSpeed=350}, 
Car{manufactureYear=2012, model='Lamborghini Gallardo', maxSpeed=290}]

ڪارون ترتيب ڏنل آهن جيئن اسان چاهيون ٿا! :) جڏهن مون کي استعمال ڪرڻ گهرجي Comparable؟ مقابلي واري طريقي کي لاڳو ڪيو ويو آهي Comparableقدرتي ترتيب سڏيو ويندو آهي. اهو ئي سبب آهي ته compareTo()طريقي سان توهان هن طبقي جي شين جي مقابلي جو سڀ کان عام، يا قدرتي طريقو بيان ڪيو آهي. جاوا اڳ ۾ ئي هڪ قدرتي ترتيب آهي. مثال طور، جاوا ڄاڻي ٿو ته اسٽرنگ اڪثر ڪري الفابيٽ سان ترتيب ڏنل آهن، ۽ انگن کي عددي قدر وڌائڻ سان. تنهن ڪري، جيڪڏهن توهان sort()طريقي کي نمبرن يا تارن جي فهرست تي سڏين ٿا، انهن کي ترتيب ڏنو ويندو. جيڪڏهن اسان جو پروگرام عام طور تي ڪارن جي ترتيب ۽ ترتيب جي ترتيب سان ترتيب ڏيندو، پوء اسان کي انٽرفيس Comparable<Car>۽ compareTo()طريقو استعمال ڪندي ڪارن لاء قدرتي ترتيب ڏيڻ گهرجي. پر ڇا جيڪڏهن اهو اسان لاء ڪافي نه آهي؟ اچو ته تصور ڪريو ته اسان جو پروگرام ايترو سادو ناهي. اڪثر ڪيسن ۾، ڪارن جي قدرتي ترتيب (جنهن کي اسان تيار ڪيو آهي سال جي ترتيب سان) اسان کي مناسب آهي. پر ڪڏهن ڪڏهن اسان جا گراهڪ تيز ڊرائيونگ جا شوقين هوندا آهن. جيڪڏهن اسان انهن کي استعمال ڪرڻ لاء ڪار جي فهرست تيار ڪري رهيا آهيون، ڪارن کي وڌ ۾ وڌ رفتار سان ترتيب ڏيڻ گهرجي. مثال طور، فرض ڪريو ته اسان کي هن طرح ترتيب ڏيڻ جي ضرورت آهي 15٪ وقت جي. اهو واضح طور تي اسان لاءِ ڪافي ناهي ته Carطبقن جي قدرتي ترتيب کي ترتيب ڏيڻ بجاءِ پيداوار جي سال جي رفتار سان. پر اسان اسان جي گراهڪن جي 15٪ کي نظر انداز نٿا ڪري سگھون. پوءِ ڇا ڪريون؟ هڪ ٻيو انٽرفيس اسان جي مدد لاءِ هتي اچي ٿو: Comparator. جيئن ته Comparable، اهو هڪ پيٽرولر ٿيل انٽرفيس آهي. ڪهڙو فرق آهي؟ Comparableاسان جي شين کي "مقابلي" بڻائي ٿو ۽ انهن جي سڀ کان وڌيڪ قدرتي ترتيب جي ترتيب کي بيان ڪري ٿو، يعني ترتيب ترتيب جيڪو اڪثر ڪيسن ۾ استعمال ڪيو ويندو. Comparatorهڪ الڳ "comparing" انٽرفيس آهي. Carجيڪڏهن اسان کي ڪنهن خاص قسم جي ترتيب ڏيڻ جي ضرورت آهي، اسان کي ڪلاس ۾ وڃڻ ۽ منطق کي تبديل ڪرڻ جي ضرورت ناهي compareTo(). ان جي بدران، اسان هڪ الڳ ڪلاس ٺاهي سگهون ٿا جيڪو Comparator کي لاڳو ڪري ٿو ۽ ان کي سيکاري ٿو ته اسان کي گهربل ترتيب ڪيئن ڪجي!

import java.util.Comparator;

public class MaxSpeedCarComparator implements Comparator<Car> {

   @Override
   public int compare(Car o1, Car o2) {
       return o1.getMaxSpeed() - o2.getMaxSpeed();
   }
}

جئين توهان ڏسي سگهو ٿا، اسان جو طريقو Comparatorبلڪل سادو آهي. اسان کي صرف هڪ انٽرفيس طريقو لاڳو ڪرڻ جي ضرورت آهي: compare(). اهو ٻن Carشين کي انپٽ طور وٺي ٿو ۽ انهن جي وڌ ۾ وڌ رفتار کي معمولي طريقي سان (ذاتي ڪرڻ سان). جهڙوڪ compareTo()، اهو هڪ واپسي int، ۽ مقابلي جو اصول ساڳيو آهي. اسان هن کي ڪيئن استعمال ڪريون ٿا؟ اهو سڀ ڪجهه سڌو آهي:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Main {

   public static void main(String[] args) {

       List<Car> cars = new ArrayList<>();

       Car ferrari = new Car(1990, "Ferrari 360 Spider", 310);
       Car lambo = new Car(2012, "Lamborghini Gallardo", 290);
       Car bugatti = new Car(2010, "Bugatti Veyron", 350);

       cars.add(ferrari);
       cars.add(bugatti);
       cars.add(lambo);

       Comparator speedComparator = new MaxSpeedCarComparator();
       Collections.sort(cars, speedComparator);

       System.out.println(cars);
   }
}

ڪنسول آئوٽ:

[Car{manufactureYear=2012, model='Lamborghini Gallardo', maxSpeed=290}, 
Car{manufactureYear=1990, model='Ferrari 360 Spider', maxSpeed=310}, 
Car{manufactureYear=2010, model='Bugatti Veyron', maxSpeed=350}]

اسان صرف هڪ comparator اعتراض ٺاهي ۽ ان کي Collections.sort()ترتيب ڏيڻ واري لسٽ سان گڏ طريقي سان منتقل ڪيو. جڏهن طريقو هڪ موازنہ حاصل ڪري ٿو، اهو ڪلاس جي طريقي sort()۾ بيان ڪيل قدرتي ترتيب کي استعمال نٿو ڪري . ان جي بدران، اهو لاڳو ٿئي ٿو ترتيب ڏيڻ وارو الگورتھم بيان ڪيل موازنہ ڪندڙ طرفان ان کي منظور ڪيو ويو. ائين ڪرڻ جا ڪهڙا فائدا آهن؟ پهريون، موجوده ڪوڊ سان مطابقت. اسان ھڪڙو نئون، خاص ترتيب ڏيڻ وارو طريقو ٺاھيو آھي، موجوده ھڪڙي کي برقرار رکڻ دوران جيڪو اڪثر وقت استعمال ڪيو ويندو. اسان ڪلاس کي بلڪل به هٿ نه ڪيو . اهو هڪ هو ، ۽ پوء اهو رهي ٿو: CarcompareTo()CarComparable

public class Car implements Comparable<Car> {

   private int manufactureYear;
   private String model;
   private int maxSpeed;

   public Car(int manufactureYear, String model, int maxSpeed) {
       this.manufactureYear = manufactureYear;
       this.model = model;
       this.maxSpeed = maxSpeed;
   }

   @Override
   public int compareTo(Car o) {
       return this.getManufactureYear() - o.getManufactureYear();
   }

   // ...getters, setters, toString()

}

ٻيو، لچڪدار. اسان شامل ڪري سگھون ٿا گھڻا ترتيب ڏيڻ وارا الگورتھم جيئن اسان چاهيون ٿا. مثال طور، اسان ڪارن کي ترتيب ڏئي سگھون ٿا رنگ، رفتار، وزن، يا بيٽمن فلمن ۾ ڪار کي ڪيترا ڀيرا استعمال ڪيو ويو آهي. اسان کي صرف هڪ اضافي ٺاهڻ جي ضرورت آهي Comparator. بس اهو آهي! اڄ توهان ٻه اهم ميکانيزم جو اڀياس ڪيو آهي جيڪي توهان اڪثر ڪم تي حقيقي منصوبن ۾ استعمال ڪندا. پر، جيئن توهان ڄاڻو ٿا، نظريو بغير عمل جي ڪا به شيء ناهي. هاڻي اهو توهان جي علم کي مضبوط ڪرڻ ۽ ڪجهه ڪمن کي مڪمل ڪرڻ جو وقت آهي!