1.Arrays.fill()

När man arbetar med arrayer behöver Java-programmerare väldigt ofta fylla arrayen med samma värde. Du kan naturligtvis skriva en slinga och helt enkelt tilldela något värde till varje cell i arrayen i slingan:

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

Eller så kan du helt enkelt anropa Arrays.fill()metoden, som gör exakt samma sak: den fyller den passerade arrayen med det godkända värdet. Så här ser det ut:

Arrays.fill(name, value)

Och koden i exemplet ovan kan göras lite mer kompakt och tydligare:

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

Du kan också använda Arrays.fill()metoden för att fylla inte hela arrayen, utan en del av den, med något värde:

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

Där första och sista är indexen för den första och sista cellen som ska fyllas.

I enlighet med Javas gamla goda tradition, kom ihåg att det sista elementet inte ingår i sortimentet.

Exempel:

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

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


String str = Arrays.toString(x);

Vi fyller cellerna x[3], x[4], x[5]och x[6]med värdet 999. Celler i en matris numreras från noll!

Variabeln strinnehåller värdet:
"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

Metoden Arrays.fill()fungerar endast med endimensionella arrayer. Om du skickar en tvådimensionell array till metoden kommer den att behandlas som endimensionell, med alla följder av det.

2.Arrays.copyOf()

Som du redan vet kan du inte ändra storlek på en array efter att den har skapats.

Men tänk om du verkligen vill?

Java webinar

Tja, om du verkligen vill, då kan du!

  • Skapa en ny array med önskad längd
  • Kopiera alla element från den första arrayen till den.

Det är förresten precis vad Arrays.copyOf()metoden gör. Så här ser den ut:

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

Den här metoden ändrar inte den befintliga arrayen utan skapar istället en ny array och kopierar elementen från den gamla arrayen in i den.

Om elementen inte passar ( längden är mindre än längden på den befintliga arrayen ) ignoreras de extra värdena.

Om längden på den nya arrayen är större än längden på den gamla fylls cellerna med nollor.

Exempel:

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

Variabeln str2innehåller värdet:
"[1, 2, 3, 4, 5]"

Variabeln str3innehåller värdet:
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]"

3.Arrays.copyOfRange()

Och vad händer om du vill få en array med längden 5 från en array med längden 10, men du behöver den ska innehålla de sista 5 elementen snarare än de första 5?

I det här fallet kommer en annan metod i Arraysklassen att vara användbar - Arrays.copyOfRange(). Så här ser det ut när vi kallar det:

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

Denna metod skapar också en ny array, men fyller den med element från en godtycklig plats i den ursprungliga arrayen. Där första och sista är indexen för de första och sista elementen som ska läggas in i den nya arrayen.

I enlighet med Javas gamla goda tradition, kom ihåg att det sista elementet inte ingår i sortimentet.

Exempel:

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

Variabeln str2innehåller värdet:
"[16, 17, 18, 19, 20]"

Variabeln str3innehåller värdet:
"[16, 17, 18, 19, 20, 0, 0, 0, 0, 0]"

4.Arrays.sort()

Ah, den godaste godbiten: sortering . Matriser sorteras ganska ofta i programmering. De tre vanligaste åtgärderna när du arbetar med arrayer är:

  • Sortera en array
  • Hitta minimum (eller maximum) element i en array
  • Bestämma indexet för ett element i en array (hitta ett element i en array)

Det är just därför Javas skapare inkluderade sort()metoden i Arraysklassen. Så här ser den ut:

Arrays.sort(name);

Denna metod sorterar den passerade arrayen i stigande ordning.

Exempel:

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

Arrays.sort(x);

String str = Arrays.toString(x);


Variabeln strinnehåller värdet:
"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

Utmärkt, eller hur? Du anropade en metod och nu har du en sorterad array. Skön.

Förresten, du kan använda den här metoden för att sortera inte bara hela arrayen, utan bara en del av den. Så här ser den ut:

Arrays.sort(name, first, last);

Där första och sista är indexen för den första och sista cellen som sorteringen ska beröra.

I enlighet med Javas gamla goda tradition, kom ihåg att det sista elementet inte ingår i sortimentet.

Exempel:

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

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

Variabeln strinnehåller värdet:
"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

För att sortera arrayer använder Java den snabbaste sorteringsalgoritmen — QuickSort . Dess beräkningskomplexitet beror på storleken på arrayen och beräknas med formeln N log(N).

Att sortera en array med 1000 element kommer att involvera cirka 3 000 jämförelser av arrayelement. Att sortera en uppsättning av en miljon element kommer att innebära cirka 6 miljoner jämförelser.

5.Arrays.binarySearch()

Tja, och den sista av de mest intressanta metoderna i klassen Arrayskan söka efter ett givet värde i en array. Det här är ingen vanlig sökning – det är den älskade binära sökningen . Det kokar ner till detta:

  • Först sorteras arrayen.
  • Sedan jämförs mittelementet i arrayen med det vi letar efter.
  • Om elementet är större än mittelementet fortsätter sökningen i den högra halvan av arrayen.
  • Om elementet vi letar efter är mindre än mittelementet, fortsätter sökningen i den vänstra halvan av arrayen.

Eftersom arrayen är sorterad är det möjligt att eliminera hälften av den i en enda jämförelse. Sedan i nästa steg slänger vi ut ytterligare en halv osv.

Detta tillvägagångssätt gör binär sökning mycket snabb. I en uppsättning av en miljon (!) element kan den hitta indexet för det önskade elementet i bara 20 jämförelser. Tillvägagångssättets brist är att arrayen först måste sorteras, och sorteringen tar också tid.

Så här ser den ut:

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

Var nameär namnet på arrayen, som måste skickas redan sorterad (till exempel med metoden) Arrays.sort(). Och valueär det element vi söker efter i arrayen. Resultatet som returneras av metoden är indexet för det önskade arrayelementet .

Exempel:

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);
 xär:
{-20, -20, -20, -2, 0, 3, 8, 11, 99, 999}

4
1(index 0och 2är också acceptabla)
8
-7

Om arrayen innehåller flera instanser av elementet som söks efter, kommer algoritmen helt enkelt att returnera indexet för en av dem (det finns ingen garanti för att det kommer att vara den allra första, eller vice versa - den allra sista av dessa dubbletter av element)."

Om elementet inte hittas i arrayen kommer indexet att vara negativt.

6. Länk till Oracle-dokumentation om Arraysklassen

Om du är superintresserad kan du läsa allt om Arraysklassen och alla dess metoder i den officiella dokumentationen a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base /java/util/Arrays.html">på Oracles webbplats.

Du kan till exempel läsa om Arrays.mismatch()och Arrays.compare()metoderna. Kanske kommer du att hitta dem användbara på något sätt.

Och bli inte förvirrad av antalet metoder. Varje metod har 5-10 varianter, som endast skiljer sig åt i sina parametertyper.