1.Arrays.fill()

Når du arbejder med arrays, har Java-programmører meget ofte brug for at fylde arrayet med den samme værdi. Du kan selvfølgelig skrive en løkke og blot tildele en værdi til hver celle i arrayet i løkken:

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

Eller du kan blot kalde Arrays.fill()metoden, som gør nøjagtig det samme: den fylder det beståede array med den beståede værdi. Sådan ser det ud:

Arrays.fill(name, value)

Og koden i eksemplet ovenfor kan gøres en lille smule mere kompakt og tydeligere:

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

Du kan også bruge Arrays.fill()metoden til ikke at fylde hele arrayet, men en del af det med en vis værdi:

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

Hvor første og sidste er indekserne for den første og sidste celle, der skal udfyldes.

I overensstemmelse med Javas gode gamle tradition skal du huske, at det sidste element ikke er inkluderet i sortimentet.

Eksempel:

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

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


String str = Arrays.toString(x);

Vi udfylder cellerne x[3], x[4], x[5]og x[6]med værdien 999. Celler i en matrix er nummereret fra nul!

Variablen strindeholder værdien:
"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

Metoden Arrays.fill()fungerer kun med endimensionelle arrays. Hvis du videregiver et todimensionelt array til metoden, vil det blive behandlet som endimensionelt med alle de deraf følgende konsekvenser.

2.Arrays.copyOf()

Som du allerede ved, kan du ikke ændre størrelsen på et array, efter at det er blevet oprettet.

Men hvad hvis du virkelig vil?

Java university

Nå, hvis du virkelig vil, så kan du!

  • Opret et nyt array med den ønskede længde
  • Kopier alle elementerne fra det første array ind i det.

Det er i øvrigt præcis, hvad metoden Arrays.copyOf()gør. Sådan ser kald det ud:

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

Denne metode ændrer ikke det eksisterende array , men opretter i stedet et nyt array og kopierer elementerne fra det gamle array ind i det.

Hvis elementerne ikke passer (længden er mindre end længden af ​​det eksisterende array ), ignoreres de ekstra værdier.

Hvis længden af ​​den nye matrix er større end længden af ​​den gamle, udfyldes cellerne med nuller.

Eksempel:

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

Variablen str2indeholder værdien:
"[1, 2, 3, 4, 5]"

Variablen str3indeholder værdien:
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]"

3.Arrays.copyOfRange()

Og hvad hvis du vil have en matrix med længde 5 fra en matrix med længde 10, men du har brug for, at den indeholder de sidste 5 elementer i stedet for de første 5?

I dette tilfælde vil en anden metode i Arraysklassen være nyttig - Arrays.copyOfRange(). Sådan ser det ud, når vi kalder det:

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

Denne metode opretter også et nyt array, men fylder det med elementer fra et vilkårligt sted i det originale array. Hvor første og sidste er indekserne for de første og sidste elementer, der skal sættes ind i det nye array.

I overensstemmelse med Javas gode gamle tradition skal du huske, at det sidste element ikke er inkluderet i sortimentet.

Eksempel:

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

Variablen str2indeholder værdien:
"[16, 17, 18, 19, 20]"

Variablen str3indeholder værdien:
"[16, 17, 18, 19, 20, 0, 0, 0, 0, 0]"

4.Arrays.sort()

Ah, den lækreste godbid: sortering . Arrays sorteres ret ofte i programmering. De tre mest almindelige handlinger, når du arbejder med arrays er:

  • Sortering af et array
  • At finde minimum (eller maksimum) element i en matrix
  • Bestemmelse af indekset for et element i en matrix (finde et element i en matrix)

Det er netop derfor, Javas skabere inkluderede sort()metoden i Arraysklassen. Sådan ser kald det ud:

Arrays.sort(name);

Denne metode sorterer det beståede array i stigende rækkefølge.

Eksempel:

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

Arrays.sort(x);

String str = Arrays.toString(x);


Variablen strindeholder værdien:
"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

Fremragende, ikke? Du kaldte én metode, og nu har du et sorteret array. Smuk.

Forresten kan du bruge denne metode til at sortere ikke kun hele arrayet, men kun en del af det. Sådan ser kald det ud:

Arrays.sort(name, first, last);

Hvor første og sidste er indekserne for den første og sidste celle, som sorteringen skal røre ved.

I overensstemmelse med Javas gode gamle tradition skal du huske, at det sidste element ikke er inkluderet i sortimentet.

Eksempel:

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

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

Variablen strindeholder værdien:
"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

For at sortere arrays bruger Java den hurtigste sorteringsalgoritme — QuickSort . Dens beregningsmæssige kompleksitet afhænger af arrayets størrelse og beregnes ved hjælp af formlen N log(N).

Sortering af et array på 1000 elementer vil involvere omkring 3.000 sammenligninger af array-elementer. Sortering af en række af en million elementer vil involvere omkring 6 millioner sammenligninger.

5.Arrays.binarySearch()

Nå, og den sidste af de mest interessante metoder i klassen Arrayser i stand til at søge efter en given værdi i et array. Dette er ingen almindelig søgning - det er den elskede binære søgning . Det bunder i dette:

  • Først sorteres arrayet.
  • Derefter sammenlignes det midterste element i arrayet med det, vi leder efter.
  • Hvis elementet er større end det midterste element, så fortsætter søgningen i højre halvdel af arrayet.
  • Hvis det element, vi leder efter, er mindre end det midterste element, så fortsætter søgningen i venstre halvdel af arrayet.

Fordi arrayet er sorteret, er det muligt at eliminere halvdelen af ​​det i en enkelt sammenligning. Så i næste trin smider vi en anden halvdel ud, og så videre.

Denne tilgang gør binær søgning meget hurtig. I en række af en million (!) elementer kan den finde indekset for det ønskede element i kun 20 sammenligninger. Tilgangens mangel er, at arrayet først skal sorteres, og sorteringen tager også tid.

Sådan ser kald det ud:

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

Hvor nameer navnet på arrayet, som skal bestå allerede sorteret (for eksempel ved hjælp af metoden Arrays.sort()). Og valueer det element, vi leder efter i arrayet. Resultatet, der returneres af metoden, er indekset for det ønskede array-element .

Eksempler:

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

4
1(indekser 0og 2er også acceptable)
8
-7

Hvis arrayet indeholder flere forekomster af det element, der søges efter, vil algoritmen blot returnere indekset for en af ​​dem (der er ingen garanti for, at det f.eks. vil være den allerførste eller omvendt - den allersidste af disse duplikerede elementer)."

Hvis elementet ikke findes i arrayet, vil indekset være negativt.

6. Link til Oracle-dokumentation på Arraysklassen

Hvis du er super interesseret, kan du læse alt om Arraysklassen og alle dens metoder i den officielle dokumentation a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base /java/util/Arrays.html">på Oracle-webstedet.

Du kan for eksempel læse om Arrays.mismatch()og Arrays.compare()metoderne. Måske vil du finde dem nyttige på en eller anden måde.

Og lad dig ikke forvirre af antallet af metoder. Hver metode har 5-10 varianter, som kun adskiller sig i deres parametertyper.