Java kengaytirilgan saralash
Java kengaytirilgan saralash
Java List’ni saralash bobida ro‘yxatlarni alifbo va son bo‘yicha saralashni o‘rgandingiz, lekin ro‘yxatda obyektlar bo‘lsa-chi?
Obyektlarni saralash uchun ularni qanday saralash kerakligini belgilovchi qoidani ko‘rsatishingiz kerak. Masalan, sizda avtomobillar ro‘yxati bo‘lsa, ularni yili bo‘yicha saralashni xohlashingiz mumkin; bunda qoida yili oldinroq bo‘lgan avtomobillar birinchi turishidan iborat bo‘lishi mumkin.
Comparator va Comparable interfeyslari obyektlarni saralashda qaysi qoida ishlatilishini belgilash imkonini beradi.
Saralash qoidasini belgilay olish stringlar va sonlar qanday saralanishini o‘zgartirishga ham imkon beradi.
Komparatorlar
Comparator interfeysini amalga oshiruvchi obyekt komparator (comparator) deb ataladi.
Comparator interfeysi ikki obyektni solishtirib, ro‘yxatda qaysi biri birinchi turishi kerakligini aniqlaydigan compare() metodiga ega sinf yaratish imkonini beradi.
compare() metodi quyidagicha son qaytarishi kerak:
- Agar ro‘yxatda birinchi obyekt oldin turishi kerak bo‘lsa — manfiy.
- Agar ro‘yxatda ikkinchi obyekt oldin turishi kerak bo‘lsa — musbat.
- Agar tartib ahamiyatsiz bo‘lsa — nol.
Comparator interfeysini amalga oshiruvchi sinf taxminan quyidagicha ko‘rinishi mumkin:
// Sort Car objects by year
class SortByYear implements Comparator {
public int compare(Object obj1, Object obj2) {
// Make sure that the objects are Car objects
Car a = (Car) obj1;
Car b = (Car) obj2;
// Compare the objects
if (a.year < b.year) return -1; // The first car has a smaller year
if (a.year > b.year) return 1; // The first car has a larger year
return 0; // Both cars have the same year
}
}
Komparatordan foydalanish uchun uni saralash metodiga argument sifatida uzating:
// Use a comparator to sort the cars
Comparator myComparator = new SortByYear();
Collections.sort(myCars, myComparator);
Quyida avtomobillar ro‘yxatini yili bo‘yicha saralash uchun komparatordan foydalanilgan to‘liq misol keltirilgan:
Misol
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
// Define a Car class
class Car {
public String brand;
public String model;
public int year;
public Car(String b, String m, int y) {
brand = b;
model = m;
year = y;
}
}
// Create a comparator
class SortByYear implements Comparator {
public int compare(Object obj1, Object obj2) {
// Make sure that the objects are Car objects
Car a = (Car) obj1;
Car b = (Car) obj2;
// Compare the year of both objects
if (a.year < b.year) return -1; // The first car has a smaller year
if (a.year > b.year) return 1; // The first car has a larger year
return 0; // Both cars have the same year
}
}
public class Main {
public static void main(String[] args) {
// Create a list of cars
ArrayList<Car> myCars = new ArrayList<Car>();
myCars.add(new Car("BMW", "X5", 1999));
myCars.add(new Car("Honda", "Accord", 2006));
myCars.add(new Car("Ford", "Mustang", 1970));
// Use a comparator to sort the cars
Comparator myComparator = new SortByYear();
Collections.sort(myCars, myComparator);
// Display the cars
for (Car c : myCars) {
System.out.println(c.brand + " " + c.model + " " + c.year);
}
}
}
Lambda ifodasidan foydalanish
Kodni qisqartirish uchun komparatorni compare() metodi bilan bir xil argumentlar va qaytariladigan qiymatga ega lambda ifodasi bilan almashtirish mumkin:
Misol
Komparator sifatida lambda ifodasidan foydalaning:
Collections.sort(myCars, (obj1, obj2) -> {
Car a = (Car) obj1;
Car b = (Car) obj2;
if (a.year < b.year) return -1;
if (a.year > b.year) return 1;
return 0;
});
Maxsus saralash qoidalari
Komparatorlar yordamida stringlar va sonlar uchun maxsus saralash qoidalarini ham yaratish mumkin. Ushbu misolda barcha juft sonlarni toq sonlardan oldin joylashtirish uchun komparatordan foydalanamiz:
Misol
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
class SortEvenFirst implements Comparator {
public int compare(Object obj1, Object obj2) {
// Make sure the objects are integers
Integer a = (Integer)obj1;
Integer b = (Integer)obj2;
// Check each number to see if it is even
// A number is even if the remainder when dividing by 2 is 0
boolean aIsEven = (a % 2) == 0;
boolean bIsEven = (b % 2) == 0;
if (aIsEven == bIsEven) {
// If both numbers are even or both are odd then use normal sorting rules
if (a < b) return -1;
if (a > b) return 1;
return 0;
} else {
// If a is even then it goes first, otherwise b goes first
if (aIsEven) {
return -1;
} else {
return 1;
}
}
}
}
public class Main {
public static void main(String[] args) {
ArrayList<Integer> myNumbers = new ArrayList<Integer>();
myNumbers.add(33);
myNumbers.add(15);
myNumbers.add(20);
myNumbers.add(34);
myNumbers.add(8);
myNumbers.add(12);
Comparator myComparator = new SortEvenFirst();
Collections.sort(myNumbers, myComparator);
for (int i : myNumbers) {
System.out.println(i);
}
}
}
Comparable interfeysi
Comparable interfeysi obyektga compareTo() metodi orqali o‘zining saralash qoidasini belgilash imkonini beradi.
compareTo() metodi argument sifatida obyekt qabul qiladi va ro‘yxatda qaysi biri birinchi turishi kerakligini aniqlash uchun comparable obyektni argument bilan solishtiradi.
Komparatordagi kabi compareTo() metodi ham quyidagicha son qaytaradi:
- Agar ro‘yxatda comparable obyekt oldin turishi kerak bo‘lsa — manfiy.
- Agar ro‘yxatda boshqa obyekt oldin turishi kerak bo‘lsa — musbat.
- Agar tartib ahamiyatsiz bo‘lsa — nol.
Java tilining ko‘plab o‘rnatilgan sinflari, masalan, String va Integer, Comparable interfeysini amalga oshiradi.
Shuning uchun stringlar va sonlarni saralash uchun komparator kerak emas.
Comparable interfeysini amalga oshiruvchi obyekt taxminan quyidagicha ko‘rinishi mumkin:
class Car implements Comparable {
public String brand;
public String model;
public int year;
// Decide how this object compares to other objects
public int compareTo(Object obj) {
Car other = (Car)obj;
if(year < other.year) return -1; // This object is smaller than the other one
if(year > other.year) return 1; // This object is larger than the other one
return 0; // Both objects are the same
}
}
Quyida avvalgi misolning o‘zi keltirilgan, lekin unda komparator o‘rniga Comparable interfeysidan foydalanilgan:
Misol
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
// Define a Car class which is comparable
class Car implements Comparable {
public String brand;
public String model;
public int year;
public Car(String b, String m, int y) {
brand = b;
model = m;
year = y;
}
// Decide how this object compares to other objects
public int compareTo(Object obj) {
Car other = (Car)obj;
if(year < other.year) return -1; // This object is smaller than the other one
if(year > other.year) return 1; // This object is larger than the other one
return 0; // Both objects are the same
}
}
public class Main {
public static void main(String[] args) {
// Create a list of cars
ArrayList<Car> myCars = new ArrayList<Car>();
myCars.add(new Car("BMW", "X5", 1999));
myCars.add(new Car("Honda", "Accord", 2006));
myCars.add(new Car("Ford", "Mustang", 1970));
// Sort the cars
Collections.sort(myCars);
// Display the cars
for (Car c : myCars) {
System.out.println(c.brand + " " + c.model + " " + c.year);
}
}
}
Keng qo‘llaniladigan saralash usuli
Ikki sonni tabiiy tartibda saralashning eng oddiy usuli quyidagicha yozishdir:
if(a.year < b.year) return -1; // a is less than b
if(a.year > b.year) return 1; // a is greater than b
return 0; // a is equal to b
Lekin aslida buni atigi bitta qator bilan bajarish mumkin:
return a.year - b.year;Bu usul yordamida elementlarni teskari tartibda ham osongina saralash mumkin:
return b.year - a.year;Comparator va Comparable
Komparator — ikki xil obyektni solishtirish uchun ishlatiladigan bitta metodli obyekt.
Comparable — o‘zini boshqa obyektlar bilan solishtira oladigan obyekt.
Imkon bo‘lsa, Comparable interfeysidan foydalanish osonroq, lekin Comparator interfeysi kuchliroq, chunki u har qanday turdagi obyektni, hatto uning kodini o‘zgartira olmasangiz ham, saralash imkonini beradi.
W3Schools Pathfinder
Yutuqlaringizni kuzating – bu bepul!