Jinsi ya Kupanga Orodha katika Java: list.sort, Comparator, Masharti Mengi, na Usimamizi wa Null

1. Unachojifunza katika Makala Hii (Njia Fupi Zaidi ya Kupanga Orodha ya Java)

Unapofanya kazi na Java, ni jambo la kawaida sana kukutana na hali ambapo unahitaji kupanga List.
Wakati huo huo, watengenezaji wengi—hasa wanaoanza—wanafanya mkanganyiko na maswali kama haya:

• Ni njia gani inapaswa kutumika kupanga List?
• Toa tofauti kati ya list.sort() na Collections.sort() ?
• Nifanyeje kupanga List ya vitu badala ya thamani rahisi?

Makala hii imeundwa kujibu maswali hayo kwa uwazi na vitendo, ikianza na hitimisho kwanza, kisha polepole kuelezea maelezo na matukio halisi ya matumizi.

1.1 Hitimisho: Huu Ndiyo Muundo Pekee Unayohitaji Kumbuka

Ukitaka njia fupi na ya kawaida zaidi ya kupanga List katika Java, hii ndiyo:

list.sort(Comparator.naturalOrder());

Hii inapanga List kwa mpangilio wa kupanda (ndogo hadi kubwa, A hadi Z, zamani hadi mpya).

Ukitaka mpangilio wa kushuka, tumia hii badala yake:

list.sort(Comparator.reverseOrder());

Kwa mistari hii miwili tu, unaweza tayari kupanga Orodha za:

• Integer
• String
• LocalDate
• na aina nyingi za kawaida nyingine

Kwa hali nyingi za kila siku, hii ndilo unalohitaji.

1.2 Kupanga Orodha ya Vitu: Bainisha Ufunguo wa Kupanga

Katika programu halisi, Orodha kawaida hushikilia vitu, si thamani rahisi.

Kwa mfano:

class Person {
    private String name;
    private int age;

    // getters omitted
}

Kupanga List<Person> kwa umri, andika:

list.sort(Comparator.comparing(Person::getAge));

Mstari huu mmoja unamaanisha:

• Chukua age kutoka kila Person
• Linganisha thamani hizo
• Panga List kwa mpangilio wa kupanda

Huna haja ya kutekeleza mantiki ya kulinganisha mwenyewe.
Kumbuka tu muundo huu:

Comparator.comparing(whatToCompare)

1.3 Makala Hii Inashughulikia

Makala hii inaelezea upangaji wa Orodha za Java kuanzia misingi hadi matumizi ya vitendo, ikijumuisha:

• Tofauti kati ya list.sort() na Collections.sort()
• Jinsi Comparator inavyofanya kazi kwa maneno rahisi
• Kupanga kwa masharti mengi (kwa mfano: umri → jina)
• Kuchanganya mpangilio wa kupanda na kushuka
• Jinsi ya kushughulikia thamani null kwa usalama
• Wakati wa kutumia stream().sorted() badala ya list.sort()

Lengo si kukumbuka, bali kuelewa kwa nini kila njia ipo.

1.4 Makala Hii Imeandaliwa Kwa Nani

Makala hii imeandikwa kwa watengenezaji ambao:

• Wanaelewa sarufi ya msingi ya Java (madarasa, mbinu, Orodha)
• Wamewahi kutumia ArrayList au List awali
• Bado wanahitaji kutafuta msimbo wa upangaji kila wanapohitaji

Haijalishi si kwa wanaoanza kabisa ambao hawajawahi kuandika msimbo wa Java,
ila ni rafiki kwa wanaoanza kwa watengenezaji wanaojifunza programu ya Java ya vitendo.

2. Njia Tatu za Kawaida za Kupanga Orodha katika Java (Ni Ipi Unayopaswa Kutumia?)

Katika Java, hakuna njia moja tu ya kupanga List.
Katika vitendo, watengenezaji hutumia njia tatu tofauti, kila moja ikiwa na tabia na nia kidogo tofauti.

Kabla ya kuingia zaidi katika Comparator, ni muhimu kuelewa lini na kwa nini kila chaguo linapatikana.

2.1 list.sort(Comparator) — Njia ya Kisasa na Inayopendekezwa

Tangu Java 8, hii ndiyo njia ya kawaida na inayopendekezwa zaidi ya kupanga Orodha.

list.sort(Comparator.naturalOrder());

Sifa kuu

• Imefafanuliwa moja kwa moja kwenye kiolesura cha List
• Ni wazi na inasomeka
• Inapanga Orodha asili mahali (inaharibu)

Kupanga vitu kunafanyika kwa njia ile ile:

list.sort(Comparator.comparing(Person::getAge));

Lini kuitumia

• Unapokubaliana kubadilisha Orodha asili
• Unapohitaji suluhisho lililo wazi na rahisi zaidi

👉 Ukikosa uhakika, list.sort() kawaida ndiyo chaguo sahihi.

2.2 Collections.sort(list) — Mtindo wa Zamani Unaobadilika Kuwa Nafasi ya Kumbukumbu

Unaweza kuona msimbo kama huu katika mafunzo ya zamani au miradi ya urithi:

Collections.sort(list);

Au kwa kutumia Comparator:

Collections.sort(list, Comparator.reverseOrder());

Sifa kuu

• Inapatikana tangu Java 1.2
• Ndani inafanya kazi karibu sawa na list.sort
• Pia hubadilisha Orodha asili

Kwa nini haijulikani sana leo

• Java 8 ilileta list.sort, ambayo inahisi asili zaidi
• Kusortira Orodha kupitia Collections si rahisi sana

Kwa msimbo mpya, list.sort inapendekezwa.
Hata hivyo, kuelewa Collections.sort bado ni muhimu wakati wa kusoma misimbo ya zamani.

2.3 stream().sorted() — Usortaji usioharibu

Chaguo la tatu linatumia API ya Stream.

List<Integer> sorted =
    list.stream()
        .sorted()
        .toList();

Kwa kutumia Comparator:

List<Person> sorted =
    list.stream()
        .sorted(Comparator.comparing(Person::getAge))
        .toList();

Sifa kuu

• Haitabadilisha Orodha asili
• Inarudisha Orodha mpya iliyosortiwa
• Rahisi kuchanganya na filter , map , na operesheni nyingine za stream

Wakati wa kuitumia

• Unapohitaji kudumisha Orodha asili bila kubadilika
• Unapokusortiwa ni sehemu ya mchakato wa usindikaji data

Kwa usortaji rahisi, hata hivyo, list.sort kwa kawaida ni wazi zaidi na yenye ufanisi zaidi.

2.4 Jinsi ya Kuchagua (Mwongozo wa Maamuzi ya Haraka)

Katika hatua hii, kumbuka kanuni moja tu:

Tumia list.sort() isipokuwa una sababu wazi ya kutoifanya.

3. Usortaji wa Msingi: Mpangilio wa Kupanda na Kushuka

Sasa unapojua njia gani ya usortaji kutumia, hebu tuelekeze kwenye hitaji la kawaida zaidi:
kusortiwa kwa mpangilio wa kupanda au kushuka.

Sehemu hii inashughulikia Orodha za aina za msingi kama nambari, maandishi, na tarehe—misingi ya kila kitu kinachofuata.

3.1 Kusortiwa kwa Mpangilio wa Kupanda (Mpangilio Asili)

Aina nyingi za Java zina mpangilio asili, kama vile:

• Nambari → ndogo hadi kubwa
• Maandishi → mpangilio wa alfabeti (A hadi Z)
• Tarehe → za zamani hadi mpya

Kusortira Orodha kwa mpangilio wa kupanda, tumia:

list.sort(Comparator.naturalOrder());

Mfano: Kusortira nambari

List<Integer> numbers = Arrays.asList(5, 1, 3, 2);
numbers.sort(Comparator.naturalOrder());

Matokeo:

[1, 2, 3, 5]

Mfano: Kusortira maandishi

List<String> names = Arrays.asList("Tom", "Alice", "Bob");
names.sort(Comparator.naturalOrder());

Matokeo:

[Alice, Bob, Tom]

👉 Ukihitaji tu mpangilio wa kupanda, huu ndio njia rahisi na salama zaidi.

3.2 Kusortiwa kwa Mpangilio wa Kushuka

Kurejesha mpangilio asili, tumia Comparator.reverseOrder().

list.sort(Comparator.reverseOrder());

Mfano: Nambari katika mpangilio wa kushuka

List<Integer> numbers = Arrays.asList(5, 1, 3, 2);
numbers.sort(Comparator.reverseOrder());

Matokeo:

[5, 3, 2, 1]

Mfano: Maandishi katika mpangilio wa kushuka

List<String> names = Arrays.asList("Tom", "Alice", "Bob");
names.sort(Comparator.reverseOrder());

Matokeo:

[Tom, Bob, Alice]

3.3 Wakati Comparator Inaweza Kutokuwepo

Katika baadhi ya hali, unaweza kuona msimbo wa usortaji ulioandikwa bila Comparator dhahiri.

Collections.sort(list);

Au hata:

list.sort(null);

Hizi hufanya kazi tu ikiwa:

• Vipengele vinatekeleza Comparable
• Unataka mpangilio asili (kupanda)

Ingawa ni sahihi, mitindo hii si wazi sana.
Katika misimbo ya ulimwengu halisi, toleo hili kwa kawaida linapendekezwa kwa uwazi:

list.sort(Comparator.naturalOrder());

3.4 Uelewa wa Kawaida: Nani Anaamua Mpangilio?

Chanzo cha kawaida cha kuchanganyikiwa kwa wanaoanza ni kufikiri kwamba:

sort() inaamua mpangilio wa kupanda au kushuka

Kwa kweli:

• sort() hufanya usortaji
• Comparator inaelezea jinsi vipengele vinavyolinganishwa

Mara tu unapofahamu mgawanyiko huu wa majukumu, kila kitu kingine—kusortiwa kwa vitu, masharti mengi, na usimamizi wa null—huwezekana rahisi zaidi.

4. Kusortiwa kwa Orodha ya Viumbe: Kuelewa Comparator

Katika programu za Java za ulimwengu wa kweli, huwa hauorodheshi maadili rahisi kama Integer au String.
Mara nyingi, utakuwa ukiorodhesha Orodha za vitu vya kawaida.

Hii ndio mahali Comparator inakuwa dhana kuu.

4.1 Je, Nini ni Comparator?

Comparator inafafanua jinsi vipengele viwili vinapaswa kulinganishwa.

Kwa dhana, inajibu swali hili:

“Ikiwa vitu viwili, ni kipi kinapaswa kuja kwanza?”

Ndani, Comparator inarudisha:

• Nambari hasi → kipengele cha kwanza kinakuja kwanza
• Sifuri → mpangilio haujali
• Nambari chanya → kipengele cha pili kinakuja kwanza

Kwa bahati nzuri, katika Java ya kisasa huwa hauhitaji kutekeleza mantiki hii kwa mkono.

4.2 Kiorodheshaji kwa Kifaa kwa Kutumia Comparator.comparing

Fikiria darasa lifuatalo:

class Person {
    private String name;
    private int age;

    // getters omitted
}

Ili kiorodhesha List<Person> kwa umri, tumia:

list.sort(Comparator.comparing(Person::getAge));

Hii inasomwa kwa urahisi:

• Chukua kila Person
• Toa age
• Linganisha maadili hayo
• Panga Orodha kwa mpangilio wa kuongezeka

Mstari huu mmoja unachukua nafasi ya mistari mingi ya nambari ya kulinganisha ya zamani.

4.3 Kiorodheshaji kwa Nambari, Tarehe, na Aina Zingine

Mfumo huu unafanya kazi kwa karibu aina yoyote ya kifaa.

Kiorodhesha kwa jina

list.sort(Comparator.comparing(Person::getName));

Kiorodhesha kwa tarehe

list.sort(Comparator.comparing(Person::getBirthDate));

Mradi thamani iliyotolewa ina mpangilio wa asili,
Comparator.comparing itafanya kazi bila usanidi wa ziada.

4.4 Kutumia Kiorodheshaji Mahususi kwa Primitive

Kwa vipengele vya nambari, Java inatoa njia zilizoboreshwa:

• comparingInt
• comparingLong
• comparingDouble

Mfano:

list.sort(Comparator.comparingInt(Person::getAge));

Njia hizi:

• Epuka sanduku la kitu kisilo lazima
• Fanya nia yako iwe wazi zaidi
• Ni bora kidogo kwa Orodha kubwa

Ingawa tofauti ni ndogo, zinachukuliwa kama mazoezi bora kwa vipengele vya nambari.

4.5 Kwa Nini Hii Inahusika

Maridadi unapoelewa Comparator.comparing, unafungua:

• Kiorodheshaji cha hali nyingi
• Mchanganyiko wa mpangilio wa kuongezeka na kushuka
• Kushughulikia salama maadili ya null

Kwa maneno mengine, hii ndio msingi wa kiorodheshaji cha vitendo cha Orodha katika Java.

5. Kiorodheshaji kwa Masharti Mengi (Mfumo wa Kawaida Zaidi wa Ulimwengu wa Kweli)

Katika programu za kweli, kiorodheshaji kwa kifaa kimoja mara nyingi hakutoshi.
Kawaida unahitaji masharti ya pili na ya tatu ili kuunda mpangilio thabiti na wenye maana.

Mifano ni pamoja na:

• Kiorodhesha kwa umri, kisha kwa jina
• Kiorodhesha kwa kipaumbele, kisha kwa wakati
• Kiorodhesha kwa alama (kushuka), kisha kwa KITAMBULISHO (kuongezeka)

API ya Comparator ya Java imeundwa mahususi kwa hii.

5.1 Misingi ya thenComparing

Kiorodheshaji la hali nyingi linafuata kanuni rahisi:

Ikiwa vipengele viwili ni sawa kwa sharti la kwanza, tumia sharti la kisha.

Hapa kuna mfumo wa msingi:

list.sort(
    Comparator.comparingInt(Person::getAge)
              .thenComparing(Person::getName)
);

Hii inamaanish:

1. Kiorodhesha kwa age (kuongezeka)
2. Ikiwa umri ni sawa, kiorodhesha kwa name (kuongezeka)

Hii inazalisha mpangilio thabiti na unaotabirika.

5.2 Kuchanganya Mpangilio wa Kuongezeka na Kushuka

Mara nyingi sana, unataka kifaa kimoja katika mpangilio wa kushuka na kingine katika mpangilio wa kuongezeka.

Mfano: Alama (kushuka), Jina (kuongezeka)

list.sort(
    Comparator.comparingInt(Person::getScore).reversed()
              .thenComparing(Person::getName)
);

Maelezo muhimu:

• reversed() inatumika tu kwa Comparator iliyotangulia mara moja

Hii inafanya iwe salama kuchanganya mwelekeo tofauti wa kiorodheshaji.

5.3 Kupitisha Comparator kwa thenComparing

Kwa kusomwa vizuri, unaweza kufafanua wazi mwelekeo wa kiorodheshaji ndani ya thenComparing.

Mfano: Umri (kuongezeka), Tarehe ya Usajili (kushuka)

list.sort(
    Comparator.comparingInt(Person::getAge)
              .thenComparing(
                  Comparator.comparing(Person::getRegisterDate).reversed()
              )
);

Mtindo huu unafanya iwe wazi sana ni vipengele gani vinapanda au vinashuka,
ambayo ni muhimu kwa ukaguzi wa msimbo na matengenezo ya muda mrefu.

5.4 Mfano wa Biashara wa Kweli

list.sort(
    Comparator.comparingInt(Order::getPriority)
              .thenComparing(Order::getDeadline)
              .thenComparing(Order::getOrderId)
);

Mantiki ya kusort:

1. Kipaumbele cha juu kwanza
2. Mwisho wa kazi wa mapema kwanza
3. Kitambulisho cha agizo la chini kwanza

Hii inahakikisha mpangilio thabiti na rafiki wa biashara.

5.5 Weka Kusort kwa Hali Nyingi Kusomwa Vizuri

Kadri mantiki ya kusort inavyokua, uwezo wa kusoma inakuwa muhimu zaidi kuliko ufupi.

Mbinu bora:

• Vunja mistari kwa kila hali
• Epuka lambdas zilizowekwa ndani sana
• Ongeza maoni ikiwa sheria za biashara hazionekani wazi

Mantiki wazi ya kusort inaokoa wakati kwa kila mtu anayesoma msimbo baadaye.

6. Kushughulikia Thamani za null Kwa Usalama (Chanzo cha Kawaida Sana cha Makosa)

Unaposort data ya ulimwengu halisi, thamani za null ni karibu zisizoweza kuepukwa.
Vipengele vinaweza kuwa vya hiari, data ya zamani inaweza kuwa isiyokamilika, au thamani zinaweza kukosekana tu.

Ikiwa hautashughulikia null wazi, kusort kunaweza kushindwa kwa urahisi wakati wa utekelezaji.

6.1 Kwa Nini null Inasababisha Matatizo Wakati wa Kusort

Fikiria msimbo huu:

list.sort(Comparator.comparing(Person::getName));

Ikiwa getName() inarudisha null kwa kipengele chochote, Java itatupa
NullPointerException wakati wa kulinganisha.

Hii hutokea kwa sababu:

• Comparator inadhani thamani zinaweza kulinganishwa
• null haina mpangilio wa asili isipokuwa ukiifafanua

Kwa hivyo, kushughulikia null lazima iwe wazi.

6.2 Kutumia nullsFirst na nullsLast

Java hutoa njia za msaada kufafanua jinsi thamani za null zinapaswa kupangwa.

Weka thamani za null kwanza

list.sort(
    Comparator.comparing(
        Person::getName,
        Comparator.nullsFirst(Comparator.naturalOrder())
    )
);

Weka thamani za null mwisho

list.sort(
    Comparator.comparing(
        Person::getName,
        Comparator.nullsLast(Comparator.naturalOrder())
    )
);

Mbinu hizi:

• Zinazuia NullPointerException
• Zinafanya sheria ya kusort iwe wazi na isosomwe

6.3 Wakati Orodha Yenyewe Inajumuisha Vipengele vya null

Mara nyingi, vipengele vya Orodha yenyewe vinaweza kuwa null.

List<Person> list = Arrays.asList(
    new Person("Alice", 20),
    null,
    new Person("Bob", 25)
);

Kushughulikia hii kwa usalama:

list.sort(
    Comparator.nullsLast(
        Comparator.comparing(Person::getName)
    )
);

Hii inahakikisha:

• Vipengele vya null vinahamishiwa mwishoni
• Vipengele visivyo null vinapangwa kawaida

6.4 Kuwa Makini na comparingInt na null

Comparators maalum za primitive kama comparingInt haziwezi kushughulikia null.

Comparator.comparingInt(Person::getAge); // age must be int

Ikiwa uwanja ni Integer ambayo inaweza kuwa null, tumia:

Comparator.comparing(
    Person::getAge,
    Comparator.nullsLast(Integer::compare)
);

Hii inazuia makosa ya utekelezaji yasiyotarajiwa.

6.5 Tumia Kushughulikia null Kama Sehemu ya Ufafanuzi

Kuamua ikiwa thamani za null zinapaswa kuonekana:

• Mwanzo
• Mwisho
• Au kuchujwa kabisa

ni maamuzi ya biashara, si tu ya kiufundi.

Kwa kutumia nullsFirst au nullsLast, unaandika uamuzi huo moja kwa moja katika msimbo—
ukifanya mantiki yako ya kusort iwe salama zaidi na rahisi kuelewa.

7. Makosa ya Kawaida na Makosa (Jinsi ya Kuepuka Matatizo Yaliyofichika)

Kusort List katika Java inaonekana rahisi, lakini kuna makosa kadhaa yaliyo rahisi kuyapuuza ambayo yanaweza kusababisha matatizo, tabia isiyotarajiwa, au masuala ya utendaji.

Kuelewa haya mapema itaokoa wakati wako wakati wa kurekebisha na ukaguzi wa msimbo.

7.1 Kusahau Kwamba Kusort Ni Lenye Uharibifu

.Both list.sort() and Collections.sort() hubadilisha Orodha asili.

List<Integer> original = new ArrayList<>(List.of(3, 1, 2));
List<Integer> alias = original;

original.sort(Comparator.naturalOrder());

Katika kesi hii:

• original imepangwa
• alias pia imepangwa (kwa sababu yanarejelea Orodha ileile)

Jinsi ya kuepuka hili

Kama unahitaji kuhifadhi mpangilio asili:

List<Integer> sorted = new ArrayList<>(original);
sorted.sort(Comparator.naturalOrder());

Au tumia mikondo:

List<Integer> sorted =
    original.stream()
            .sorted()
            .toList();

Daima jiulize:
“Je, ni sawa kubadilisha Orodha asili?”

7.2 Utulivu wa Comparator na Mpangilio Thabiti

Comparator inapaswa kutoa matokeo yanayokubalika na yanayoweza kutabirika.

Mfano:

Comparator.comparing(Person::getAge);

Kama watu wengi wana umri sawa, mpangilio wao wa jamaa haujafafanuliwa.

Hii inaweza kukubalika—lakini mara nyingi si hivyo.

Mazoea mazuri

Ongeza hali ya pili ili kusimamia mpangilio:

Comparator.comparingInt(Person::getAge)
          .thenComparing(Person::getId);

Hii inahakikisha matokeo ya kupanga ni ya kutabirika.

7.3 Uhusiano wa Herufi Kukuwa na Ukubwa katika Upangaji wa String

Mpangilio wa asili wa String ni kukuwa na herufi kubwa/kudogo.

List<String> list = List.of("apple", "Banana", "orange");
list.sort(Comparator.naturalOrder());

Hii inaweza kutoa matokeo ambayo hayajihisi ya kawaida.

Upangaji usio na herufi kubwa/kudogo

list.sort(String.CASE_INSENSITIVE_ORDER);

Kabla ya kuchagua, fikiria:

• Je, hii ni kwa ajili ya kuonyesha?
• Au kwa mantiki ya ndani?

Jibu linaamua njia sahihi.

7.4 Kufanya Kazi Nzito Ndani ya Comparator

Comparator inaweza kuitwa mara nyingi wakati wa kupanga.

Epuka:

• Ufikiaji wa hifadhidata
• Simu za mtandao
• Mahesabu ghali

  // Bad idea (conceptual example)
  Comparator.comparing(p -> expensiveOperation(p));
  

Njia bora

• Hesabu thamani mapema
• Ziweke katika sehemu
• Linganisha thamani rahisi, nafuu

Comparator zenye ufanisi hufanya tofauti kubwa na Orodha kubwa.

7.5 Kipa Umakini Usomaji Badala ya Ujasusi

Mantiki ya kupanga mara nyingi husomwa zaidi kuliko ilivyoandikwa.

Badala ya:

• Usemi mrefu mmoja uliofungwa
• Lambdas zilizopachikwa ndani sana

Pendelea:

• Mipangilio ya mistari
• Muundo wazi
• Maoni ya hiari kwa sheria za biashara

Msimbo wa kupanga unaoweza kusomwa hupunguza hitilafu na kurahisisha matengenezo.

8. Mambo ya Utendaji na Kuchagua Njia Sahihi

Kwa sasa, unajua jinsi ya kupanga Orodha katika Java.
Sehemu hii inazingatia ni njia gani kuchagua kutoka kwa mtazamo wa utendaji na muundo.

Katika programu nyingi, kupanga si tatizo la utendaji—lakini uchaguzi mbaya bado unaweza kusababisha mzigo usio wa lazima.

8.1 list.sort() dhidi ya stream().sorted()

Hii ndiyo sehemu ya maamuzi ya kawaida zaidi.

list.sort()

list.sort(Comparator.comparingInt(Person::getAge));

Faida

• Hakuna ugawaji wa Orodha ya ziada
• Nia wazi: “panga Orodha hii”
• Kidogo zaidi ufanisi

Hasara

• Hubadilisha Orodha asili

stream().sorted()

List<Person> sorted =
    list.stream()
        .sorted(Comparator.comparingInt(Person::getAge))
        .toList();

Faida

• Orodha asili haibadiliki
• Inafaa asili katika mikondo ya stream

Hasara

• Inaunda Orodha mpya
• Kidogo zaidi mzigo

Sheria ya vitendo

• Upangaji rahisi → list.sort()
• Mikondo ya ubadilishaji au isiyobadilika → stream().sorted()

8.2 Kupanga Orodha Kubwa Kwa Ufanisi

Algoritimu za kupanga humuita Comparator mara nyingi. Kwa Orodha kubwa, hii ina umuhimu.

Miongozo muhimu

• Weka Comparator nyepesi
• Epuka minyororo ya mbinu inayofanya kazi nzito
• Pendelea Comparator za primitive ( comparingInt, n.k.)

Mfano: Hesabu mapema funguo ghali

Badala ya:

Comparator.comparing(p -> calculateScore(p));

Fanya:

// Precompute once
p.setScore(calculateScore(p));

Kisha panga kwa uwanja huo:

Comparator.comparingInt(Person::getScore);

Hii hupunguza sana kazi inayorudiwa wakati wa kupanga.

8.3 Je, Collections.sort() Ni Chaguo Sahihi Wakati Wowote?

Kwa code mpya, karibu kamwe.

Hata hivyo, bado inaonekana katika:

• Miradi ya zamani
• Mafunzo ya zamani
• Codebases za Java 7 na mapema

Huna haja ya kuitumia—lakini unapaswa kuiona.

8.4 Orodha ya Kuthibitisha Uamuzi Iliyopendekezwa

Kabla ya kupanga, uliza:

1. Je, naweza kubadilisha Orodha asili?
2. Je, ninahitaji hali nyingi za kupanga?
3. Je, uwanja wowote unaweza kuwa null ?
4. Je, utendaji ni muhimu kwa kiwango kikubwa?

Kujibu maswali haya hutanguliza suluhisho sahihi kwa asili.

9. Muhtasari: Java Orodha Panga Karatasi ya Kumbukumbu

Wacha tufupishe kila kitu katika mwongozo wa marejeo ya haraka unaoweza kutegemea.

9.1 Mifumo ya Haraka Utakayoitumia Mara Nyingi Zaidi

Mpangilio wa kupanda

list.sort(Comparator.naturalOrder());

Mpangilio wa kushuka

list.sort(Comparator.reverseOrder());

9.2 Kupanga Vitu kwa Uwanja

list.sort(Comparator.comparing(Person::getName));

Kwa nambari:

list.sort(Comparator.comparingInt(Person::getAge));

9.3 Hali Nyingi

list.sort(
    Comparator.comparingInt(Person::getAge)
              .thenComparing(Person::getName)
);

Mpangilio mchanganyiko:

list.sort(
    Comparator.comparingInt(Person::getScore).reversed()
              .thenComparing(Person::getName)
);

9.4 Kushughulikia null Kwa Usalama

list.sort(
    Comparator.comparing(
        Person::getName,
        Comparator.nullsLast(Comparator.naturalOrder())
    )
);

Orodha inaweza kuwa na vipengele vya null:

list.sort(
    Comparator.nullsLast(
        Comparator.comparing(Person::getName)
    )
);

9.5 Kupanga Bila Kuharibu

List<Person> sorted =
    list.stream()
        .sorted(Comparator.comparingInt(Person::getAge))
        .toList();

9.6 Hitimisho La Mwisho

Kupanga Orodha ya Java kunakuwa rahisi mara tu ukikumbuka:

• Comparator inafafanua mpangilio
• sort() inafanya operesheni
• Uwazi hushinda ujanja
• Kushughulikia null wazi huzuia makosa

Kama utazingatia kanuni hizi,
hutahitaji “kujifunza upya” kupanga Orodha ya Java tena.