1.Arrays.fill()

Når du arbeider med matriser, trenger Java-programmerere veldig ofte å fylle matrisen med samme verdi. Du kan selvfølgelig skrive en løkke og ganske enkelt tilordne en verdi til hver celle i matrisen i løkken:

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

Eller du kan ganske enkelt kalle Arrays.fill()metoden, som gjør nøyaktig det samme: den fyller den beståtte matrisen med den beståtte verdien. Slik ser det ut:

Arrays.fill(name, value)

Og koden i eksemplet ovenfor kan gjøres litt mer kompakt og tydeligere:

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

Du kan også bruke Arrays.fill()metoden til å fylle ikke hele matrisen, men en del av den, med en viss verdi:

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

Der første og siste er indeksene til den første og siste cellen som skal fylles.

I samsvar med Javas gode gamle tradisjon, husk at det siste elementet ikke er inkludert 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 fyller cellene x[3], x[4], x[5]og x[6]med verdien 999. Celler i en matrise er nummerert fra null!

Variabelen strinneholder verdien:
"[1, 2, 3, 999, 999, 999, 999, 8, 9, 10]"

Metoden Arrays.fill()fungerer kun med endimensjonale arrays. Hvis du sender en todimensjonal matrise til metoden, vil den bli behandlet som endimensjonal, med alle de påfølgende konsekvenser.

2.Arrays.copyOf()

Som du allerede vet, kan du ikke endre størrelsen på en matrise etter at den er opprettet.

Men hva om du virkelig vil?

Java university

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

  • Lag en ny matrise med ønsket lengde
  • Kopier alle elementene fra den første matrisen inn i den.

Det er forresten akkurat det Arrays.copyOf()metoden gjør. Slik ser kallet ut:

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

Denne metoden endrer ikke den eksisterende matrisen , men oppretter i stedet en ny matrise og kopierer elementene i den gamle matrisen inn i den.

Hvis elementene ikke passer (lengden er mindre enn lengden på den eksisterende matrisen ), ignoreres de ekstra verdiene.

Hvis lengden på den nye matrisen er større enn lengden på den gamle, fylles cellene 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);

Variabelen str2inneholder verdien:
"[1, 2, 3, 4, 5]"

Variabelen str3inneholder verdien:
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]"

3.Arrays.copyOfRange()

Og hva om du ønsker å få en matrise med lengde 5 fra en matrise med lengde 10, men du trenger at den inneholder de siste 5 elementene i stedet for de første 5?

I dette tilfellet vil en annen metode for Arraysklassen komme godt med - Arrays.copyOfRange(). Slik ser det ut når vi kaller det:

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

Denne metoden oppretter også en ny matrise, men fyller den med elementer fra et vilkårlig sted i den opprinnelige matrisen. Der første og siste er indeksene til de første og siste elementene som skal settes inn i den nye matrisen.

I samsvar med Javas gode gamle tradisjon, husk at det siste elementet ikke er inkludert 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);

Variabelen str2inneholder verdien:
"[16, 17, 18, 19, 20]"

Variabelen str3inneholder verdien:
"[16, 17, 18, 19, 20, 0, 0, 0, 0, 0]"

4.Arrays.sort()

Ah, den deiligste godbiten: sortering . Matriser sorteres ganske ofte i programmering. De tre vanligste handlingene når du arbeider med matriser er:

  • Sortering av en matrise
  • Finne minimum (eller maksimum) element i en matrise
  • Bestemme indeksen til et element i en matrise (finne et element i en matrise)

Det er nettopp derfor Javas skapere inkluderte sort()metoden i Arraysklassen. Slik ser kallet ut:

Arrays.sort(name);

Denne metoden sorterer den beståtte matrisen i stigende rekkefølge.

Eksempel:

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

Arrays.sort(x);

String str = Arrays.toString(x);


Variabelen strinneholder verdien:
"[-20, -20, -20, -2, 0, 3, 8, 11, 99, 999]"

Utmerket, ikke sant? Du kalte én metode, og nå har du en sortert matrise. Vakker.

Forresten, du kan bruke denne metoden til å sortere ikke bare hele matrisen, men bare en del av den. Slik ser kallet ut:

Arrays.sort(name, first, last);

Der første og siste er indeksene til den første og siste cellen som sorteringen skal berøre.

I samsvar med Javas gode gamle tradisjon, husk at det siste elementet ikke er inkludert 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);

Variabelen strinneholder verdien:
"[11, -2, 3, 0, -20, -20, 8, 999, 99, -20]"

For å sortere matriser bruker Java den raskeste sorteringsalgoritmen – QuickSort . Dens beregningsmessige kompleksitet avhenger av størrelsen på matrisen og beregnes ved hjelp av formelen N log(N).

Sortering av en matrise på 1000 elementer vil innebære omtrent 3000 sammenligninger av matriseelementer. Sortering av en rekke med én million elementer vil innebære omtrent 6 millioner sammenligninger.

5.Arrays.binarySearch()

Vel, og den siste av de mest interessante metodene i klassen Arrayser i stand til å søke etter en gitt verdi i en matrise. Dette er ikke noe vanlig søk – det er det elskede binære søket . Det koker ned til dette:

  • Først blir matrisen sortert.
  • Deretter sammenlignes det midterste elementet i arrayet med det vi ser etter.
  • Hvis elementet er større enn det midterste elementet, fortsetter søket i høyre halvdel av matrisen.
  • Hvis elementet vi ser etter er mindre enn det midterste elementet, fortsetter søket i venstre halvdel av matrisen.

Fordi matrisen er sortert, er det mulig å eliminere halvparten av den i en enkelt sammenligning. Så i neste trinn kaster vi ut en annen halvdel, og så videre.

Denne tilnærmingen gjør binært søk veldig raskt. I en rekke av én million (!) elementer kan den finne indeksen til det ønskede elementet i bare 20 sammenligninger. Tilnærmingens mangel er at arrayet først må sorteres, og sortering tar også tid.

Slik ser kallet ut:

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

Hvor nameer navnet på matrisen, som må sendes allerede sortert (for eksempel ved å bruke metoden Arrays.sort()). Og valueer elementet vi søker etter i matrisen. Resultatet som returneres av metoden er indeksen til det ønskede matriseelementet .

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å akseptable)
8
-7

Hvis matrisen inneholder flere forekomster av elementet det søkes etter, vil algoritmen ganske enkelt returnere indeksen til en av dem (det er ingen garanti for at det vil være, for eksempel, den aller første, eller omvendt - den aller siste av disse dupliserte elementer)."

Hvis elementet ikke finnes i matrisen, vil indeksen være negativ.

6. Link til Oracle-dokumentasjon på Arraysklassen

Hvis du er superinteressert, kan du lese alt om Arraysklassen og alle dens metoder i den offisielle dokumentasjonen a href="https://docs.oracle.com/en/java/javase/14/docs/api/java.base /java/util/Arrays.html">på Oracle-nettstedet.

Du kan for eksempel lese om metodene Arrays.mismatch()og Arrays.compare(). Kanskje vil du finne dem nyttige på en eller annen måte.

Og ikke la deg forvirre av antall metoder. Hver metode har 5-10 varianter, som bare er forskjellige i parametertypene.