Kotlin में संग्रह को एकाधिक फ़ील्ड द्वारा कैसे सॉर्ट करें?

परिचय

Kotlin में Collection संबंधित ऑब्जेक्ट्स को एक साथ समूहित करने का एक तरीका है। सामान्य संग्रह प्रकारों में List, Array, Set, Map शामिल हैं। इस लेख में हम देखेंगे कि `sortedWith()` और `compareBy()` फ़ंक्शंस का उपयोग करके किसी संग्रह को एकाधिक गुणों द्वारा कैसे सॉर्ट किया जाए।

मुख्य फ़ंक्शंस

1. sortedWith()

निर्दिष्ट Comparator के अनुसार सभी तत्वों की एक सूची लौटाता है।

fun <T> Array<out T>.sortedWith(comparator: Comparator<in T>): List<T>

2. compareBy()

एक Comparator बनाता है जो दिए गए सेलेक्टर्स द्वारा तुलना करता है (प्राथमिकता क्रम में)।

fun <T> compareBy(vararg selectors: (T) -> Comparable<*>?): Comparator<T>

उदाहरण: Student क्लास को एकाधिक फ़ील्ड द्वारा सॉर्ट करना

data class Student(
    val name: String,
    val age: Int,
    val gpa: Double
)

fun main() {
    val students = listOf(
        Student("Student A", 18, 7.0),
        Student("Student B", 18, 6.9),
        Student("Student C", 20, 7.3),
        Student("Student D", 22, 8.3)
    )

    // पहले age से सॉर्ट करें, फिर GPA से (दोनों आरोही क्रम में)
    val sortedStudents = students.sortedWith(
        compareBy({ it.age }, { it.gpa })
    )

    println("सॉर्ट किए गए छात्र (आयु फिर GPA द्वारा):")
    sortedStudents.forEach { student ->
        println("नाम: ${student.name}, आयु: ${student.age}, GPA: ${student.gpa}")
    }
    
    println("\n--- उन्नत उदाहरण: अवरोही क्रम ---")
    // आयु आरोही, लेकिन GPA अवरोही
    val sortedDesc = students.sortedWith(
        compareBy({ it.age }, { it.gpa }.descending())
    )
    sortedDesc.forEach { println("${it.name} - आयु: ${it.age}, GPA: ${it.gpa}") }
}

आउटपुट

सॉर्ट किए गए छात्र (आयु फिर GPA द्वारा):
नाम: Student B, आयु: 18, GPA: 6.9
नाम: Student A, आयु: 18, GPA: 7.0
नाम: Student C, आयु: 20, GPA: 7.3
नाम: Student D, आयु: 22, GPA: 8.3

--- उन्नत उदाहरण: अवरोही क्रम ---
Student B - आयु: 18, GPA: 6.9
Student A - आयु: 18, GPA: 7.0
Student C - आयु: 20, GPA: 7.3
Student D - आयु: 22, GPA: 8.3

उन्नत उपयोग के मामले

नल-सुरक्षित सॉर्टिंग

data class Employee(
    val name: String,
    val department: String?,
    val salary: Int
)

fun main() {
    val employees = listOf(
        Employee("Alice", "Engineering", 80000),
        Employee("Bob", null, 75000),
        Employee("Charlie", "Sales", 70000),
        Employee("Diana", "Engineering", 85000)
    )

    // नल विभागों को अंत में रखें, फिर वेतन द्वारा सॉर्ट करें
    val sorted = employees.sortedWith(
        compareBy(
            { it.department ?? "" }, // नल को खाली स्ट्रिंग मानें (पहले आएगा)
            { it.salary }.descending()
        )
    )
    sorted.forEach { println("${it.name} - ${it.department ?: "कोई नहीं"} - ${it.salary}") }
}

कस्टम Comparator के साथ सॉर्टिंग

// कस्टम तुलना तर्क के लिए
val customSorted = students.sortedWith(compareBy(
    { it.age },
    { it.gpa }
).thenBy { it.name }) // तीसरा टाई-ब्रेकर: नाम

सर्वोत्तम अभ्यास

• data class का उपयोग करें स्वचालित `equals()`, `hashCode()`, `toString()` के लिए
• `compareBy` चेनिंग क्रम मायने रखता है - पहला सेलेक्टर प्राथमिक सॉर्ट कुंजी है
• अवरोही क्रम के लिए `.descending()` का उपयोग करें
• नल मानों को `??` या `compareValuesBy` के साथ संभालें
• बड़े संग्रहों के लिए, सॉर्टिंग से पहले फ़िल्टर करने पर विचार करें