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

1.Arrays.fill()

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 egyszerűen 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);

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)

Ahol az első és az utolsó az első és az utolsó kitöltendő cella indexei.

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);

"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

A Arrays.fill()módszer 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, minden ebből következő következménnyel együtt.

2.Arrays.copyOf()

Mint már tudja, a tömb létrehozása után nem lehet átméretezni.

De mi van, ha nagyon akarod?

Nos, ha nagyon akarod, akkor megteheted!

• Hozzon létre egy új, kívánt hosszúságú tömböt
• Másold bele az első tömb összes elemét.

A módszer egyébként pontosan ezt Arrays.copyOf()teszi. Í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.

Ha az elemek nem illenek (a hossza kisebb, mint a meglévő tömb hossza ), akkor a plusz értékek figyelmen kívül maradnak.

Ha az új tömb hossza nagyobb, mint a régié, akkor a cellák nullákkal lesznek kitöltve.

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);

"[1, 2, 3, 4, 5]"

"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]"

3.Arrays.copyOfRange()

És mi van akkor, ha egy 10 hosszúságú tömbből 5 hosszúságú tömböt szeretne kapni, de az első 5 helyett az utolsó 5 elemet kell tartalmaznia?

Ebben az esetben az Arraysosztály másik módszere jól jöhet - a Arrays.copyOfRange(). Így néz ki, amikor hívjuk:

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

Ez a módszer is létrehoz egy új tömböt, de az eredeti tömb tetszőleges helyéről tölti fel elemekkel. Ahol az első és az utolsó az első és az utolsó elem indexei, amelyeket be kell helyezni az új tömbbe.

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);

"[16, 17, 18, 19, 20]"

"[16, 17, 18, 19, 20, 0, 0, 0, 0, 0]"

4.Arrays.sort()

Ó, a legfinomabb csemege: a válogatás . A programozás során a tömböket gyakran rendezik. A három leggyakoribb 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 Java készítői pontosan ezért vették fel 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);

"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

Kiváló, igaz? Meghívott egy metódust, és most van egy rendezett tömbje. Gyönyörű.

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

Arrays.sort(name, first, last);

Ahol az első és az utolsó az első és az utolsó cella indexei, amelyeket a rendezésnek érintenie kell.

Példa:

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

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

"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

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ítjuk ki.

Egy 1000 elemből álló tömb rendezése a tömbelemek körülbelül 3000 összehasonlítását vonja maga után. Egy millió elemből álló tömb rendezése körülbelül 6 millió összehasonlítást von maga után.

5.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 szokványos keresés – ez a szeretett bináris keresés . Ez így áll össze:

• 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, lehetséges a felét egyetlen összehasonlítással kiküszöbölni. Majd a következő lépésben kidobunk még egy felét, és így tovább.

Ez a megközelítés nagyon felgyorsítja a bináris keresést. Egy millió (!) elemből álló tömbben mindössze 20 összehasonlításban megtalálja a kívánt elem indexét. A megközelítés hiányossága, hogy a tömböt először rendezni kell, és a rendezés is időt vesz igénybe.

Í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 a Arrays.sort()metódus segítségével). És valueaz az elem, amelyet a tömbben keresünk. 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);

{-20, -20, -20, -2, 0, 3, 8, 11, 99, 999}

Ha a tömb a keresett elem több példányát tartalmazza, akkor az algoritmus egyszerűen visszaadja az egyik indexét (nincs garancia arra, hogy mondjuk a legelső lesz, vagy fordítva – ezek közül a legutolsó) . ismétlődő elemek).

Ha az elem nem található a tömbben, akkor az index negatív lesz.

Arrays6. Hivatkozás az osztály Oracle dokumentációjához

Ha nagyon érdekel, mindent elolvashat az osztályról Arraysés annak metódusairól a hivatalos dokumentációban a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base /java/util/Arrays.html">az Oracle webhelyén.

Arrays.mismatch()Például a és módszerekről olvashat Arrays.compare(). Talán hasznosnak találja őket valahogy.

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