Paano Pagbukud-bukurin ang 2d Array sa Java

Ang two-dimensional o 2D array ay isang koleksyon ng mga column at row. Maaaring random na ma-access ng mga programmer ang 2D array elements o bawat cell nang paisa-isa sa pamamagitan ng paggamit ng kanilang mga index. Sa tulong ng pag-uuri, ang mga elemento ng array ay inayos ayon sa mga kinakailangan, kung sa pataas o pababang pagkakasunud-sunod. Higit na partikular, ang Java ' Array.sort() ” ay maaaring gamitin para sa mga elemento ng isang 2D array sa loob ng isang programa.

Tatalakayin ng tutorial na ito kung paano ayusin ang mga 2D array sa Java.

Paano Pagbukud-bukurin ang 2D Array sa Java?

Sa Java, maaari mong ayusin ang isang 2D array gamit ang:

Pag-uuri-uri ng hilera
Column-wise Pag-uuri

Tatalakayin natin ngayon ang bawat isa sa mga nabanggit na pamamaraan nang paisa-isa.

Paraan 1: Row-wise na pag-uuri ng 2D Array sa Java

Sa row-wise sorting, maaari mong gamitin ang ' Array.sort() ” paraan upang pag-uri-uriin ang mga elemento ng array. Inuulit nito ang bawat elemento ng isang partikular na row at pinapalitan ang mga integer kapag ang kasalukuyang elemento ay mas malaki kaysa sa susunod.

Tingnan natin ang isang halimbawa upang maunawaan ang panig ng pagpapatupad.

Halimbawa
Sa halimbawang ito, gagawa muna tayo ng isang static na pamamaraan ' rowWiseSorting() ” upang pag-uri-uriin ang array sa pataas na pagkakasunud-sunod sa pamamagitan ng pagtawag sa “ Arrays.sort() 'paraan ng klase ng Arrays at pagkatapos ay i-print ang pinagsunod-sunod na elemento ng array gamit ang ' para sa 'mga loop:

static int rowWiseSorting ( int arr [ ] [ ] ) {
para sa ( int i = 0 ; i < arr. haba ; i ++ ) {
Mga array. uri ( arr [ i ] ) ;
}
para sa ( int i = 0 ; i < arr. haba ; i ++ ) {
para sa ( int j = 0 ; j < arr [ i ] . haba ; j ++ ) {
Sistema. palabas . print ( arr [ i ] [ j ] + '' ) ;
}
Sistema. palabas . println ( ) ;
}
bumalik 0 ;
}

Dito, mayroon kaming 2D array na pinangalanang ' arr ” ng 3×3 matrix form (tatlong row at tatlong column). Ngayon, upang pag-uri-uriin ang mga hilera ng nilikha na hanay, tatawagin natin ang pamamaraan na ' rowWiseSorting() ” sa pamamagitan ng pagpasa ng array bilang argumento sa pangunahing() na pamamaraan:

pampubliko static walang bisa pangunahing ( String [ ] args ) {
int arr [ ] [ ] = bago int [ ] [ ] {
{ 12 , 14 , 4 } ,
{ 14 , 23 , dalawampu } ,
{ 28 , 25 , 8 } ,
{ labing-isa , 5 , 1 } } ;
rowWiseSorting ( arr ) ;
}
}

Tulad ng nakikita mo, inayos namin ang aming array sa pataas na pagkakasunud-sunod:

Gustong subukan ang column-wise sorting sa Java? Tingnan ang sumusunod na seksyon.

Paraan 2: Pag-uuri-uri ng 2D Array sa Java sa pamamagitan ng column

Upang pag-uri-uriin ang isang 2D Array sa Java, tawagan ang ' Arrays.sort() 'paraan na may ' Interface ng paghahambing ”. Tinutukoy ng interface ng Comparator ang isang “ ihambing () ” paraan na tumatanggap ng dalawang parameter at pagkatapos ay inihahambing ang mga ito sa isa't isa. Kung ang mga naipasa na mga parameter ay pantay, ito ay nagbabalik ng zero. Kung ang 1st parameter ay mas malaki kaysa sa 2nd parameter, ito ay nagbabalik ng positibong halaga. Kung hindi, isang negatibong halaga ang ibinalik.

Halimbawa
Sa halimbawang ito, gagawa kami ng paraan na pinangalanang ' columnWiseSorting() 'na may dalawang argumento, isang 2D array' arr[][] ” at isang numero ng column na pinangalanang “ pangkalahatang-ideya ”. Pagkatapos, tawagan ang ' Arrays.sort() 'paraan na may ' Interface ng paghahambing ” upang ihambing ang mga halaga ng isang column. Sa wakas, ipi-print namin ang mga halaga ng pinagsunod-sunod na hanay ng array gamit ang ' para sa 'mga loop:

static walang bisa columnWiseSorting ( int arr [ ] [ ] , int pangkalahatang-ideya ) {
Mga array. uri ( arr , bago Kumpare < int [ ] > ( ) {
pampubliko int ihambing ( int [ ] frst , int [ ] scnd ) {
kung ( frst [ pangkalahatang-ideya - 1 ] > scnd [ pangkalahatang-ideya - 1 ] ) {
bumalik 1 ;
}
iba pa bumalik - 1 ;
}
} ) ;
}
para sa ( int i = 0 ; i < arr. haba ; i ++ ) {
para sa ( int j = 0 ; j < arr [ i ] . haba ; j ++ ) {
Sistema. palabas . print ( arr [ i ] [ j ] + '' ) ;
}
Sistema. palabas . println ( ) ;
}

Gagamitin namin ang nagawa na array na pinangalanang ' arr 'at ipasa ito sa' columnWiseSorting() ' bilang unang parameter at ' 1 ” bilang pangalawang parameter:

columnWiseSorting ( arr , 1 ) ;

Ang pagpapatupad ng ibinigay na programa sa itaas ay pag-uuri-uriin ang unang column ng aming 2D array:

Kino-compile namin ang lahat ng mahahalagang impormasyon para pag-uri-uriin ang 2D array sa Java.

Konklusyon

Sa Java, ang isang 2D array ay maaaring pag-uri-uriin sa row-wise o column-wise ayon sa mga kinakailangan. Para sa row-wise sorting, Array.sort() method lang ang ginagamit; gayunpaman, sa column-wise sorting, ang Array.sort() method ay tinatawag na may Comparator interface. Para sa row-wise sorting, walang parameter na ipinapasa sa Array.sort() method, samantalang, sa column-wise sorting method, ang bilang ng mga column na kailangang ayusin ay binanggit bilang isang parameter. Tinalakay ng tutorial na ito ang mga paraan upang pag-uri-uriin ang 2D array sa Java na may mga halimbawa.

Paano Pagbukud-bukurin ang 2d Array sa Java