Coffee break #136. Pagbukud-bukurin ang isang array sa pataas o pababang pagkakasunud-sunod gamit ang Arrays.sort(). Ano ang pagkakaiba sa pagitan ng mga interface ng Listahan at Itakda?

Pagbukud-bukurin ang isang array sa pataas o pababang pagkakasunud-sunod gamit ang Arrays.sort()

Pinagmulan: FreeCodeCamp Sa post na ito, matututunan mo kung paano mag-uri-uriin ang isang array sa alinman sa pataas o pababang pagkakasunud-sunod sa Java. Sa Java, gumagamit kami ng mga arrays para mag-imbak ng set ng mga variable (na may parehong uri ng data) sa isang variable. Ngunit kung minsan ang mga halaga na nakaimbak sa array ay lilitaw sa isang random na pagkakasunud-sunod. Salamat sa klase ng Arrays sa Java, mayroon kaming ilang paraan para manipulahin ang mga array, kabilang ang pag-uuri ng mga ito. Ang isa sa mga pamamaraan na gagamitin namin mula sa klase ng Arrays ay ang sort() method , na nag-uuri ng array sa pataas na pagkakasunud-sunod. Upang pag-uri-uriin ang isang array sa pababang pagkakasunud-sunod, gamitin ang reverseOrder() na paraan ng Collections class sa Java.

Paano pag-uri-uriin ang isang array sa pataas na pagkakasunud-sunod sa Java gamit ang Arrays.sort()

Narito ang isang halimbawa kung paano natin magagamit ang sort() na paraan upang pagbukud-bukurin ang isang array sa pataas na pagkakasunud-sunod.

import java.util.Arrays;

class ArraySort {
    public static void main(String[] args) {
        int[] arr = { 5, 2, 1, 8, 10 };
        Arrays.sort(arr);

        for (int values : arr) {
            System.out.print(values + ", ");
            // 1, 2, 5, 8, 10,
        }
    }
}

Ang unang bagay na ginawa namin sa halimbawa sa itaas ay ang pag-import ng klase ng Arrays : import java.util.Arrays; . Nagbibigay ito sa amin ng access sa lahat ng mga pamamaraan ng klase ng Arrays . Pagkatapos ay gumawa kami ng array na may mga numero sa random na pagkakasunud-sunod: int[] arr = { 5, 2, 1, 8, 10 }; . Upang pag-uri-uriin ang array na ito sa pataas na pagkakasunud-sunod, ipinasa namin ang array bilang isang parameter sa sort() method : Arrays.sort(arr); . Tandaan na ang klase ng Arrays ay isinusulat muna bago i-access ang sort() method gamit ang dot notation. Sa wakas, gumawa kami ng loop at na-print ang array sa console. Ang resulta ay isang pinagsunod-sunod na array: 1, 2, 5, 8, 10 . Ngayon ay pag-usapan natin ang tungkol sa pag-uuri ng isang array sa pababang pagkakasunud-sunod.

Paano pag-uri-uriin ang isang array sa pababang pagkakasunud-sunod sa Java gamit ang Collections.reverseOrder()

Upang pagbukud-bukurin ang isang array sa pababang pagkakasunud-sunod, dapat mong gamitin ang reverseOrder() , na maaaring ma-access mula sa klase ng Collections . Gagamitin pa rin namin ang Arrays.sort(); , ngunit sa halimbawang ito ay kukuha ito ng dalawang parameter - isang array upang ayusin at Collections.reverseOrder() .

import java.util.Arrays;
import java.util.Collections;

class ArraySort {
    public static void main(String[] args) {
        Integer[] arr = { 5, 2, 1, 8, 10 };
        Arrays.sort(arr, Collections.reverseOrder());

        for (int values : arr) {
            System.out.print(values + ", ");
            // 10, 8, 5, 2, 1,
        }
    }
}

Ang unang bagay na ginawa namin ay ang pag-import ng mga klase ng Arrays at Collections dahil gagamitin namin ang mga pamamaraan na ibinigay ng mga klase na ito. Pagkatapos ay gumawa kami ng hanay ng mga numero sa random na pagkakasunud-sunod: Integer[] arr = { 5, 2, 1, 8, 10 }; . Gaya ng nakikita mo, ginamit namin ang Integer[] sa halip na int[] tulad ng sa nakaraang halimbawa. Kung hindi, magkakaroon ng error. Upang ayusin ang array sa pababang pagkakasunud-sunod, ginawa namin ito: Arrays.sort(arr, Collections.reverseOrder()); . Ang unang parameter ay isang array arr na pag-uuri-uriin sa pataas na pagkakasunud-sunod. Ang pangalawang parameter, Collections.reverseOrder() , ay babaligtarin ang pagkakasunud-sunod ng pinagsunod-sunod na array upang ito ay nasa pababang pagkakasunud-sunod. Kapag na-loop at na-print, ang array ay magiging ganito: 10, 8, 5, 2, 1 .

Konklusyon

Sa artikulong ito, tinalakay namin ang tungkol sa pag-uuri-uri ng mga array sa Java - kung paano sila maiayos sa pataas o pababang pagkakasunud-sunod. Upang gawin ito, maaari naming gamitin ang sort() method , na maaaring ma-access mula sa Arrays class . Ang paraan ng sort() ay tumatagal ng isang array upang pag-uri-uriin bilang isang parameter. Upang pag-uri-uriin ang array sa pababang pagkakasunud-sunod, ginamit namin ang reverseOrder() na pamamaraan na ibinigay ng klase ng Collections. Ito ay ipinapasa bilang pangalawang parameter sa sort() na paraan upang ang pinagsunod-sunod na hanay ay maaaring muling ayusin sa pababang pagkakasunud-sunod.

Koleksyon ng Java. Ano ang pagkakaiba sa pagitan ng mga interface ng Listahan at Itakda?

Pinagmulan: Ang Listahan at Set ng Rrtutors ay mga interface ng Java upang palawigin ang interface ng Collection . Sa post na ito, titingnan natin ang mga pangunahing pagkakaiba sa pagitan ng dalawa, pati na rin kung paano sila magagamit.

Mga pagkakaiba sa pagitan ng Set at List interface sa Java

Tukuyin natin ang mga pangunahing pagkakaiba sa pagitan ng mga interface ng Listahan at Itakda batay sa mga sumusunod na pangunahing parameter:

Pagpapatupad

Ang listahan ay nagpapatupad ng ArrayLists , samantalang ang HashSet ay nagpapatupad ng Set .

Pag-index

Maaari mong gamitin ang ListIterator upang ilipat ang parehong pasulong at paatras sa pamamagitan ng isang Listahan , ngunit hindi sa pamamagitan ng isang Set . Gamitin ang Iterator sa halip (na gumagana sa parehong List at Set ).

Umorder

Ang Set interface ay hindi sumusuporta sa anumang partikular na set order. Ang isang koleksyon ng uri ng Set ay pinagbukud-bukod na ayon sa sarili nitong panuntunan at hindi maaaring pag-uri-uriin nang ganoon lang. Ang listahan ay isang nakaayos na listahan. Ang mga bagay ay iniimbak sa pagkakasunud-sunod na idinagdag sa listahan. Ang mga elemento ng listahan ay ina-access ng index.

Null object

Ang listahan ay walang mga paghihigpit at suporta sa pagdaragdag ng mga Null na halaga, habang pinapayagan ng Set ang hindi hihigit sa isang null na halaga.

Mga duplicate

Maaaring maglaman ng mga duplicate ang listahan , ngunit hindi maaaring maglaman ang Set . Hindi pinapayagan ng Set ang mga duplicate na elemento dahil lahat ng elemento nito ay dapat na natatangi. Kung maglalagay ka ng duplicate na elemento sa Set , ma-overwrite ang kasalukuyang value.

Kailan mo dapat gamitin ang List and Set?

Ang Set ay ang pinakamahusay na pagpipilian kapag kailangan mo lang mag-imbak ng mga natatanging halaga, dahil iyon ang idinisenyo nito. Ngunit kung gusto mong mapanatili ang pagkakasunud-sunod ng pagpapasok sa kabila ng pagdoble, ang Listahan ang pinakamahusay na pagpipilian .

Set ng Halimbawa

import java.util.ArrayList;

import java.util.LinkedList;

import java.util.List;

public class ListExample {

            public static void main(String[] args) {

                        List<String> al = new ArrayList<String>();

                          al.add("Rohit");

                          al.add("Panjab");

                          al.add("Kamir");

                          System.out.println("My ArrayList Items: ");

                          System.out.print(al);

                          List<String> ll = new LinkedList<String>();

                          ll.add("Shobit");

                          ll.add("Raul");

                          ll.add("Ketel");

                          System.out.println("\n My LinkedList Items: ");

                          System.out.print(ll);

            }

}

Listahan ng Halimbawa

import java.util.HashSet;

import java.util.Set;

import java.util.TreeSet;

public class SetExample {

            public static void main(String[] args) {

                          int myList[] = {60, 70, 80, 40 };

                            Set<Integer> dispSet = new HashSet<Integer>();

                            try{

                              for(int i = 0; i<4; i++){

                                dispSet.add(myList[i]);

                              }

                              System.out.println(dispSet);

                              TreeSet<Integer> treeset = new TreeSet<Integer>(dispSet);

                              System.out.println("Sorting in Asceding order:");

                              System.out.println(treeset);

                            }

                            catch(Exception e){

                                e.printStackTrace();

                            }

            }

}