Tömb osztály, 2. rész

"Rishi, nagyon várom, hogy megismerjem az Arrays osztály többi módszerét.

"A tanulás iránti ilyen buzgóság nem tehet mást, mint a régi tanárod! De ha tényleg mindent meg akarsz tudni, akkor egy Google nevű kedves varázsló éjjel-nappal segít neked."

– Ööö...

Arrays.fill"Csak viccelek. Valahogy. Természetesen mindent jobban elmagyarázok, de ha valami közbejön, emlékezz a jó varázslóra. A mai leckét ezzel a módszerrel kezdem

"Amikor tömbökkel dolgoznak, a Java programozóknak nagyon gyakran ugyanazzal az értékkel kell kitölteniük a tömböt. Természetesen írhat egy ciklust, és egyszerűen hozzárendelhet valamilyen értéket a ciklusban lévő tömb minden cellájához:

int[] x = new int[100];
for (int i = 0; i < x.length; i++)
x[i] = 999;

"Vagy mindezek helyett meghívhatja a Arrays.fill()metódust, amely pontosan ugyanazt teszi: kitölti az átadott tömböt az átadott értékkel. Így néz ki:

Arrays.fill(name, value)

És a fenti példa kódja egy kicsit tömörebbé és világosabbá tehető:

int[] x = new int[100];
Arrays.fill(x, 999);

"Gyönyörű!"

"A Arrays.fill()módszerrel nem a teljes tömböt, hanem annak egy részét töltheti ki valamilyen értékkel:

Arrays.fill(name, first, last, value)

"Hol van az első és az utolsó kitöltendő cella indexe.

" A Java régi jó (vagy rossz) hagyományainak megfelelően ne feledje, hogy az utolsó elem nem szerepel a tartományban.

Példa:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Arrays.fill(x, 3, 7, 999);


String str = Arrays.toString(x);

"A Arrays.fill()metódus csak egydimenziós tömbökkel működik. Ha egy kétdimenziós tömböt ad át a metódusnak, a rendszer egydimenziósként kezeli, az ebből fakadó összes következménnyel együtt.

Arrays.copyOf()

"Amigo, kérlek, mondd meg, hogyan változtassam meg egy tömb méretét a létrehozása után?"

"Öhm... Ez egy trükkös kérdés, igaz? Nem vagyok már olyan tapasztalatlan. A helyes válasz az, hogy nem lehet! Nem lehet átméretezni egy tömböt, miután létrehozták."

– De mi van, ha nagyon akarod?

"Még mindig lehetetlen!

"Igazából, ha nagyon akarod, akkor megteheted! Egy programozási trükk segítségével:

1. Először hozzon létre egy új, kívánt hosszúságú tömböt
2. Ezután az első tömb összes elemét bemásolja bele.

"Ez a két dolog, amit a Arrays.copyOf()módszer csinál. Így néz ki a hívás:

Type[] name2 = Arrays.copyOf(name, length);

"Ez a módszer nem módosítja a meglévő tömböt , hanem egy új tömböt hoz létre , és a régi tömb elemeit másolja bele."

"Mi van, ha az új tömb hossza kisebb, mint a meglévőé ?

"Remek kérdés, Amigo! Ha az elemek nem illenek össze, akkor az extra értékeket egyszerűen figyelmen kívül hagyja."

"És ha éppen ellenkezőleg, vannak extra cellák, mi a kezdeti értékük?

"Ha az új tömb hossza nagyobb, mint a régié, akkor a cellák nullákkal töltődnek fel.

Példa:

int[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int[] x2 = Arrays.copyOf(x, 5);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOf(x, 15);
String str3 = Arrays.toString(x3);

Arrays.copyOfRange()

"És mi van akkor, ha egy 10 hosszúságú tömbből egy 5 hosszúságú tömböt szeretne kapni, de az utolsó 5 elemet kell tartalmaznia, nem pedig az első 5-öt? Ebben az esetben az osztály másik metódusára van szüksége Arrays. Arrays.copyOfRange()Így néz ki a hívás:

Type[] name2 = Arrays.copyOfRange(name, first, last);

"Ez a módszer egy új tömböt is létrehoz, de az eredeti tömb tetszőleges helyéről tölti fel elemekkel. Hol az első és az utolsó az első és az utolsó elem indexei, amelyeket be kell tenni az új tömbbe. Meg tudná mondani, hogy az utolsó elem benne van ebben a tartományban?"

"Hah! Ahogy a nagy tanárom szokta mondani: " Jáva jó (vagy rossz) régi hagyományai szerint ne feledje, hogy az utolsó elem nem szerepel a tartományban ".

„Amigo, a szemünk láttára nősz.

Példa:

int[] x = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20};

int[] x2 = Arrays.copyOfRange(x, 5, 10);
String str2 = Arrays.toString(x2);

int[] x3 = Arrays.copyOfRange(x, 5, 15);
String str3 = Arrays.toString(x3);

Arrays.sort()

"És végül a leg... mmm... kellemes módszert hagytam utoljára: a rendezést . A tömböket a programozás során elég gyakran rendezik. Íme a 3 legnépszerűbb művelet a tömbökkel végzett munka során:

• Tömb rendezése
• Egy tömb minimális (vagy maximum) elemének megkeresése
• Egy elem indexének meghatározása egy tömbben (elem keresése egy tömbben)

"A jól teljesítő rendezési algoritmusokat meg kell mondanom, nem olyan egyszerű megírni. Pontosabban, ez egy standard feladat, és diákként nem árt, ha néha gyakorolni kell a válogató algoritmusok írását. De a munkában ez van jobb, ha nem vesztegeti az idejét a kerék újrafeltalálásával. A Java készítői beépítették a sort()módszert az osztályba Arrays. Így néz ki a hívás:

Arrays.sort(name);

Ez a módszer növekvő sorrendbe rendezi az átadott tömböt.

Példa:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x);
String str = Arrays.toString(x);

"Kiváló! Csak egy módszert hívtam meg, és a tömb rendeződik. Egy gyönyörűség!"

"Egyébként nem csak a teljes tömböt rendezheti, hanem annak egy részét is. Így néz ki a hívás:

Arrays.sort(name, first, last);

"Hol vannak az első és az utolsó cellák indexei, amelyeket a rendezésnek érintenie kell. ÉS…

"Már tudom, mit fogsz mondani! "A Java régi (vagy rossz) hagyományának megfelelően ne feledje, hogy az utolsó elem nem szerepel a tartományban . "

Példa:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};

Arrays.sort(x, 4, 8);
String str = Arrays.toString(x);

"A tömbök rendezéséhez a Java a leggyorsabb rendezési algoritmust, a QuickSortot használja . Számítási bonyolultsága a tömb méretétől függ, és az N log(N) képlettel számítják ki.

"Egy 1000 elemből álló tömb rendezése körülbelül 10 000 tömbelem összehasonlítását vonja maga után. Egy millió elemből álló tömb rendezése körülbelül 20 millió összehasonlítást von maga után."

" Nem túl sok összehasonlítás, ha figyelembe vesszük az elemek számát!"

"Pontosan ezt mondom. A QuickSort algoritmus nagyon hatékony.

Arrays.binarySearch()

"Nos, és az osztály legérdekesebb metódusai közül az utolsó Arraysképes egy adott értéket keresni egy tömbben. Ez nem egy szokványos keresés - ez a szeretett bináris keresés . Ennek lényege:

• Először a tömb rendezése történik.
• Ezután a tömb középső elemét hasonlítjuk össze azzal, amit keresünk.
• Ha az elem nagyobb, mint a középső elem, akkor a keresés a tömb jobb felében folytatódik.
• Ha a keresett elem kisebb, mint a középső elem, akkor a keresés a tömb bal felében folytatódik.

"Mivel a tömb rendezett, a felét egyetlen összehasonlítással ki lehet küszöbölni. Aztán a következő lépésben kidobunk egy másik felét, és így tovább."

"Fantasztikus! Nagyon gyorsan haladunk egyenesen a cél felé!"

"Pontosan. Egymillió (!) elemből álló tömbben a bináris keresőalgoritmus mindössze 20 összehasonlításban képes megtalálni a kívánt elem indexét. Az algoritmus hiányossága, hogy először rendezni kell a tömböt, és a rendezés is időbe telik.

Így néz ki a hívás:

int index = Arrays.binarySearch(name, value);

"Hol namevan a tömb neve, amelyet már rendezve kell átadni (például metódussal Arrays.sort()). És valueaz az elem, amit keresünk a tömbben. A metódus által visszaadott eredmény a kívánt tömbelem indexe .

Példák:

int[] x = {11, -2, 3, 0, 999, -20, 8, -20, 99, -20};
Arrays.sort(x);

int index1 = Arrays.binarySearch(x, 0);
int index2 = Arrays.binarySearch(x, -20);
int index3 = Arrays.binarySearch(x, 99);
int index4 = Arrays.binarySearch(x, 5);

"Mi van, ha a kívánt elem többször is megjelenik a tömbben ?"

"Ez egy jogos kérdés, Amigo. Ebben az esetben az algoritmus az egyik indexét adja vissza (nincs garancia arra, hogy mondjuk a legelső lesz, vagy fordítva – a legutolsó ezek közül az ismétlődő elemek közül) ."

"Mi van, ha a tömb egyáltalán nem tartalmazza a kívánt elemet?"

"Ebben az esetben az algoritmus negatív indexet ad vissza .

Dokumentáció

"Minden világos, Rishi! Ez nagyon érdekes volt."

"Ha valóban nagyon érdekesnek találta ezt, akkor szabadidőben nézze át az Arraysosztály hivatalos dokumentációját és módszereit az Oracle webhelyén .

"Megnézheti közelebbről például a Arrays.mismatch()és Arrays.compare()módszereket. Valószínűleg jól tudja majd használni őket.

"És ne zavarjon meg a metódusok száma. Mindegyik módszernek 5-10 változata van, amelyek csak paramétertípusukban különböznek egymástól."