java array class tutorial java
Denne vejledning dækker Array Class i Java og metoderne i java.util.arrays Class sammen med detaljeret beskrivelse og eksempler på Array Class-metoder:
Klassen 'Arrays' er medlem af pakken 'java.util'. Dette er en del af Java Collections-rammen og giver metoder til at oprette, få adgang til og manipulere Java-arrays dynamisk.
Alle de metoder, der leveres af Arrays-klassen, er statiske og er metoder i klassen 'Objekt'. Da metoderne er statiske, kan de tilgås ved hjælp af selve klassens navn.
=> Tjek ALLE Java-tutorials her.
Hvad du lærer:
Java Array-klasse
Arrays-klassen blev introduceret i Java 1.2, og metoderne, den indeholder, bruges hovedsagelig til manipulation af arrayet inklusive søgning, sortering osv. Arrays-klassen giver overbelastede metoder til næsten alle datatyper.
Klassehierarkiet for Arrays-klassen er vist nedenfor:
Arrays-klassen strækker sig fra objektklassen, og dens metoder er metoder til objektklassen.
Den generelle syntaks for adgang til enhver metode i Arrays-klassen er:
Arrays.;
I det kommende afsnit viser vi de forskellige metoder, der leveres af Arrays-klassen.
Java Arrays Metoder
De følgende tabeller giver en introduktion til de forskellige metoder, der leveres af Arrays-klassen. Her har vi listet de vigtigste metoder. Bemærk, at de fleste af metoderne er overbelastede for at yde support til alle de primitive typer.
Vi viser prototypen og beskrivelsen af hver af funktionerne. Derefter beskriver vi i det følgende afsnit nogle af de vigtige metoder ved at give programmeringseksempler.
Metodenavn | Prototype | Beskrivelse |
---|---|---|
statisk int binærsøgning (dobbelt [] a, int fraIndex, int tilIndex, dobbeltnøgle) | Søger nøglen over det angivne område i et dobbelt array | |
asListe | statisk liste< T> asList (Objekt [] a) | Returnerer en liste (fast størrelse) fra den specificerede matrix |
binærsøgning Denne metode bruger den binære søgealgoritme. Vist i næste kolonne er forskellige overbelastninger af binærsøgningsmetoden. | statisk int binærsøgning (byte [] a, byte-nøgle) | Søger efter en nøgle i et byte-array |
statisk int binærsøgning (byte [] a, int fraIndex, int tilIndex, byte-nøgle) | Søger nøglen over det angivne område i et byte-array | |
statisk int binærsøgning (char [] a, char-nøgle) | Søger efter en nøgle i et tegnarray | |
statisk int binærsøgning (char [] a, int fraIndex, int tilIndex, char-nøgle) | Søger nøglen over det angivne område i et tegnarray | |
statisk int binærsøgning (dobbelt [] a, dobbelt tast) | Søger efter en nøgle i et dobbelt array | |
statisk int binærsøgning (float [] a, float key) | Søger efter en nøgle i en række floats | |
statisk int binærsøgning (float [] a, int fromIndex, int toIndex, float key) | Søger nøglen på tværs af det angivne område i et float-array | |
statisk int binærsøgning (int [] a, int-nøgle) | Søger efter en nøgle i et int-array | |
statisk int binærsøgning (int [] a, int fraIndex, int tilIndex, int-nøgle) | Søger nøglen over det angivne område i et int-array | |
statisk int binærsøgning (lang [] a, lang nøgle) | Søger efter en nøgle i lang række | |
statisk int binærsøgning (lang [] a, int fraIndex, int tilIndex, lang nøgle) | Søger nøglen på tværs af det angivne område i lang række | |
statisk int binærsøgning (Objekt [] a, Objektnøgle) | Søger efter en nøgle i et objektmatrix | |
statisk int binærsøgning (Objekt [] a, int fraIndex, int tilIndex, Objektnøgle) | Søger nøglen over det angivne område i objektmatrixen | |
statisk int binærsøgning (kort [] a, kort nøgle) | Søger efter en nøgle i en række shorts | |
statisk int binærsøgning (kort [] a, int fraIndex, int tilIndex, kort nøgle) | Søger nøglen over det angivne interval i en række shorts | |
statisk int binærsøgning (T [] a, T-tast, komparator c) | Søger efter en nøgle i en række specificerede objekter | |
statisk int binærsøgning (T [] a, int fraIndex, int tilIndex, T-tast, Comparator c) | Søger nøglen på tværs af det specificerede område i objekter |
Metodenavn | Prototype | Beskrivelse |
---|---|---|
statisk lang [] copyOf (lang [] original, int newLength) | Kopierer det angivne array. Afkorter eller tilføjer nuller, hvis det er nødvendigt | |
copyOf Metoden bruges til at kopiere arrayet med den angivne længde. Næste kolonne viser overbelastningen af denne metode | statisk boolsk [] copyOf (boolsk [] original, int newLength) | Kopierer det angivne array. Afkorter eller tilføjer værdier 'falske', hvis det er nødvendigt |
statisk byte [] copyOf (byte [] original, int newLength) | Kopierer det angivne array. Afkorter eller tilføjer nuller, hvis det er nødvendigt | |
statisk char [] copyOf (char [] original, int newLength) | Kopierer det angivne array. Afkortes eller tilføjes nul, hvis det er nødvendigt | |
statisk dobbelt [] copyOf (dobbelt [] original, int newLength) | Kopierer det angivne array. Afkorter eller tilføjer nuller, hvis det er nødvendigt | |
statisk float [] copyOf (float [] original, int newLength) | Kopierer det angivne array. Afkorter eller tilføjer nuller, hvis det er nødvendigt | |
statisk int [] copyOf (int [] original, int newLength) | Kopierer det angivne array. Afkorter eller tilføjer nuller, hvis det er nødvendigt | |
statisk kort [] copyOf (kort [] original, int newLength) | Kopierer det angivne array. Afkorter eller tilføjer nuller, hvis det er nødvendigt | |
statisk T [] copyOf (T [] original, int newLength) | Kopierer det angivne array. Afkorter eller tilføjer nul, hvis det er nødvendigt | |
statisk T [] copyOf (U [] original, int newLength, ClassnewType) | Kopierer det angivne array. Afkorter eller tilføjer nul, hvis det er nødvendigt | |
copyOfRange Denne metode bruges til at kopiere et specificeret interval i arrayet. Overbelastningen for denne metode er angivet i den næste kolonne | statisk boolsk [] copyOfRange (boolsk [] original, int fra, int til) | Kopierer arrayet med det angivne interval til et nyt array |
statisk byte [] copyOfRange (byte [] original, int fra, int til) | Kopierer arrayet med det angivne interval til et nyt array | |
statisk char [] copyOfRange (char [] original, int fra, int til) | Kopierer arrayet med det angivne interval til et nyt array | |
statisk dobbelt [] copyOfRange (dobbelt [] original, int fra, int til) | Kopierer arrayet med det angivne interval til et nyt array | |
statisk flyde [] copyOfRange (flyde [] original, int fra, int til) | Kopierer arrayet med det angivne interval til et nyt array | |
statisk int [] copyOfRange (int [] original, int fra, int til) | Kopierer arrayet med det angivne interval til et nyt array | |
statisk lang [] copyOfRange (lang [] original, int fra, int til) | Kopierer arrayet med det angivne interval til et nyt array | |
statisk kort [] copyOfRange (kort [] original, int fra, int til) | Kopierer arrayet med det angivne interval til et nyt array | |
statisk T [] copyOfRange (T [] original, int fra, int til) | Kopierer arrayet med det angivne interval til et nyt array | |
statisk T [] copyOfRange (U [] original, int fra, int til, ClassnewType) | Kopierer arrayet med det angivne interval til et nyt array |
Metodenavn | Prototype | Beskrivelse |
---|---|---|
statiske boolske lig (dobbelt [] a, dobbelt [] a2) | Returnerer sandt, hvis de to angivne dobbeltarrays er ens. | |
deepEquals | statisk boolsk deepEquals (Objekt [] a1, Objekt [] a2) | Kontrollerer, om to specificerede arrays er dybt ens |
deepHashCode | statisk intdeepHashCode (Objekt [] a) | Returnerer en hash-kode for det angivne array |
deepToString | statisk StringdeepToString (Objekt [] a) | Returnerer det 'dybe indhold' af det angivne array i en streng |
Lige med Kontrollerer, om to specificerede arrays er ens | statisk boolsk lig (boolsk [] a, boolsk [] a2) | Returnerer sandt, hvis de to angivne booleanarrays er ens. |
statiske boolske lig (byte [] a, byte [] a2) | Returnerer sandt, hvis de to specificerede byte-arrays er ens | |
statiske boolske lig (char [] a, char [] a2) | Returnerer sandt, hvis de to angivne tegnrække er ens. | |
statiske boolske lig (float [] a, float [] a2) | Returnerer sandt, hvis de to angivne flydearrays er ens. | |
statiske boolske er lig med (int [] a, int [] a2) | Returnerer sandt, hvis de to angivne int-arrays er ens. | |
statisk boolsk lig (lang [] a, lang [] a2) | Returnerer sandt, hvis de to angivne lange arrays er ens. | |
statiske boolske er lig med (Objekt [] a, Objekt [] a2) | Returnerer sandt, hvis de to angivne objektarrays er ens. | |
statisk boolsk lig (kort [] a, kort [] a2) | Returnerer sandt, hvis de to angivne korte arrays er ens. |
Metodenavn | Prototype | Beskrivelse |
---|---|---|
statisk tomrumsfyld (dobbelt [] a, dobbelt val) | Udfylder dobbeltarrayet med den angivne dobbeltværdi | |
fylde Udfylder arrayet (alle elementer) med den angivne værdi. Næste kolonne giver overbelastningen for denne funktion | statisk hulfyldning (boolsk [] a, boolsk val) | Udfylder det boolske array med en specificeret boolsk værdi |
statisk tomrumsfyldning (boolsk [] a, int fraIndex, int tilIndex, boolsk val) | Tildeler en boolsk værdi til det angivne interval i det boolske array. | |
statisk tom udfyldning (byte [] a, byte val) | Fylder byte-arrayet med en specificeret byteværdi | |
statisk tomrumsudfyldning (byte [] a, int fraIndex, int tilIndex, byte val) | Fylder byte-arrayet med den specificerede byteværdi i det givne interval | |
statisk tomrumsudfyldning (char [] a, char val) | Fylder char-arrayet med den angivne char-værdi | |
statisk tomrumsudfyldning (char [] a, int fraIndex, int tilIndex, char val) | Fylder char-arrayområdet med den specificerede char-værdi | |
statisk tomrumsudfyldning (dobbelt [] a, int fraIndex, int tilIndex, dobbelt val) | Tildeler en dobbelt værdi til det angivne område i dobbeltarrayet. | |
statisk tomrumsfyldning (float [] a, float val) | Tildeler floatværdi til det angivne interval i float array. | |
statisk tomrumsudfyldning (float [] a, int fromIndex, int toIndex, float val) | Tildeler floatværdi til det angivne interval i float array. | |
statisk tomrumsudfyldning (int [] a, int val) | Tildeler int-værdi til int-arrayet. | |
statisk tomrumsudfyldning (int [] a, int fraIndex, int tilIndex, int val) | Tildeler int-værdi til det angivne område i int-arrayet. | |
statisk tomrumsudfyldning (lang [] a, int fraIndex, int tilIndex, lang val) | Tildeler en lang værdi til det angivne interval i det lange array. | |
statisk tomrumsudfyldning (lang [] a, lang val) | Tildeler en lang værdi til den lange matrix. | |
statisk tomrumsudfyldning (Objekt [] a, int fraIndex, int tilIndex, Objektval) | Tildel objektreference til det angivne område i objektmatrixen. | |
statisk tomrumsudfyldning (Objekt [] a, Objektval) | Tildeler objektreference til det angivne objektarray | |
statisk tomrumsudfyldning (kort [] a, int fraIndex, int tilIndex, kort val) | Tildeler en kort værdi til det angivne interval i det korte array. | |
statisk tomrumsfyld (kort [] a, kort val) | Tildeler en kort værdi til det angivne korte array. |
Metodenavn | Prototype | Beskrivelse |
---|---|---|
statisk tomrumsform (flyde [] a) | Sorterer float-arrayet i stigende numerisk rækkefølge. | |
Sortere Sorterer det array, der er sendt som parameter til metoden. Overbelastning er angivet i den næste kolonne. | statisk tomrums sort (byte [] a) | Sorterer byte-arrayet numerisk |
statisk tomrums sortering (byte [] a, int fraIndex, int tilIndex) | Sorterer rækkevidden af elementer fra arrayet | |
statisk ugyldig sortering (char [] a) | Sorterer tegnarrayet i stigende numerisk rækkefølge. | |
statisk tomrums sort (char [] a, int fraIndex, int tilIndex) | Sorterer rækkevidden af elementer i arrayet i stigende rækkefølge. | |
statisk tomrums sort (dobbelt [] a) | Sorterer det dobbelte array i stigende numerisk rækkefølge. | |
statisk tomrums sortering (dobbelt [] a, int fraIndex, int tilIndex) | Sorterer rækkevidden af elementer fra arrayet i stigende rækkefølge. | |
statisk tomrums sortering (flyde [] a, int fraIndex, int tilIndex) | Sorterer rækkevidden af elementer fra arrayet i stigende rækkefølge. | |
statisk tomrums sort (int [] a) | Sorterer int-array i stigende numerisk rækkefølge. | |
statisk tomrums sort (int [] a, int fraIndex, int tilIndex) | Sorterer række af elementer fra arrayet i stigende rækkefølge. | |
statisk tomrums sort (lang [] a) | Sorterer det lange array i stigende numerisk rækkefølge. | |
statisk tomrums sortering (lang [] a, int fraIndex, int tilIndex) | Sorterer rækkevidden af elementer fra arrayet i stigende rækkefølge | |
statisk tomrumsform (Objekt [] a) | Sorterer matrixen af objekter i stigende rækkefølge. Sortering udføres efter den naturlige rækkefølge af dets elementer | |
statisk tomrums sortering (Objekt [] a, int fraIndex, int tilIndex) | Sorterer det angivne interval fra en række objekter i stigende rækkefølge. Sortering udføres efter den naturlige rækkefølge af dets elementer. | |
statisk tomrums sort (kort [] a) | Sorterer arrayet af typen kort i stigende numerisk rækkefølge. | |
statisk tomrums sort (kort [] a, int fraIndex, int tilIndex) | Sorterer rækkevidden af elementer fra arrayet i stigende rækkefølge. | |
statisk tomrums sortering (T [] a, komparator c) | Sorterer det specificerede array af objekter. Sorteringsrækkefølgen induceres ifølge den specificerede komparator. | |
statisk tomrums sortering (T [] a, int fraIndex, int tilIndex, Comparator c) | Sorterer rækkevidden af elementer fra en række objekter i den rækkefølge, der er angivet af komparatoren. |
Metodenavn | Prototype | Beskrivelse |
---|---|---|
statisk streng til streng (lang [] a) | Returnerer en strengrepræsentation af et langt array | |
toString Denne metode returnerer strengrepræsentationen for et givet array. Forskellige overbelastninger af denne metode er angivet i den næste kolonne | statisk streng til streng (boolsk [] a) | Returnerer en strengrepræsentation af et boolsk array |
statisk streng til streng (byte [] a) | Returnerer en strengrepræsentation af et byte-array | |
statisk streng til streng (tegn [] a) | Returnerer en strengrepræsentation af et tegnarray | |
statisk streng til streng (dobbelt [] a) | Returnerer en strengrepræsentation af et dobbelt array | |
statisk streng til streng (flyde [] a) | Returnerer en strengrepræsentation af et float-array | |
statisk streng til streng (int [] a) | Returnerer en strengrepræsentation af et int-array | |
statisk streng til streng (objekt [] a) | Returnerer en strengrepræsentation af et objektmatrix | |
statisk streng til streng (kort [] a) | Returnerer en strengrepræsentation af et kort array |
Metodenavn | Prototype | Beskrivelse |
---|---|---|
statisk int hashCode (lang [] a) | Returnerer hash-kode for indholdet af et langt array | |
hashCode Denne metode returnerer hashCode for indholdet af det specificerede array De overbelastede metoder er angivet i den næste kolonne. | statisk int hashCode (boolsk [] a) | Returnerer hash-kode for indholdet af det boolske array |
statisk int hashCode (byte [] a) | Returnerer hash-kode for indholdet af byte-arrayet | |
statisk int hashCode (char [] a) | Returnerer hash-kode for indholdet af tegnarrayet | |
statisk int hashCode (dobbelt [] a) | Returnerer hash-kode for indholdet af et dobbelt array | |
statisk int hashCode (flyde [] a) | Returnerer hash-kode for indholdet af et float-array | |
statisk int hashCode (int [] a) | Returnerer hash-kode for indholdet af et int-array. | |
statisk int hashCode (Objekt [] a) | Returnerer hash-kode for indholdet af objektmatrixen | |
statisk int hashCode (kort [] a) | Returnerer hash-kode for indholdet af det korte array |
Ovenstående tabeller viser alle de metoder, arrays-klassen tilbyder. De fleste af disse er overbelastede for forskellige primitive typer.
Lad os diskutere nogle af disse metoder i detaljer.
# 1) asListe
Prototype: statisk liste som liste (objekt [] a)
Parametre: a - matrix af objekter, hvorfra listen bakkes op.
Returværdi: Liste => liste over faste størrelser med specificeret matrix
Beskrivelse: Returnerer en liste med fast størrelse, der kan serienummeres, bakket op af et array, der leveres som et argument.
Eksempel:
import java.util.Arrays; import java.util.List; public class Main { public static void main(String[] args) { String[] months = {'January', 'February', 'March', 'April', 'May'}; // converted string array to a List using asList System.out.println('The string array converted to list:'); List month_list = Arrays.asList(months); System.out.println(month_list); } }
Produktion:
Ovenstående program demonstrerer brugen af 'asList' -metoden i Arrays-klassen. Her har vi deklareret et strengarray og sendt det til asList-metoden for at opnå en liste.
# 2) binærsøgning
Prototype: statisk int binærsøgning (int [] a, int-nøgle)
Parametre:
a => array, hvor nøglen skal søges
Nøgle => elementværdi, der skal søges
Returværdi: int => position (indeks), hvor nøglen findes, ellers returneres (- ('indsættelsespunktet') - 1).
Beskrivelse: Søger efter den angivne nøgle i det givne array ved hjælp af en binær søgealgoritme. Arrayet skal sorteres for at den binære søgning skal fungere. Hvis matrixen ikke er sorteret, er resultaterne udefineret. Også, hvis der er flere placeringer i arrayet til den samme nøgleværdi, er den returnerede position ikke garanteret.
Eksempel:
import java.util.Arrays; import java.util.List; public class Main { public static void main(String[] args) { // define the Array int numArr[] = { 23,43,26,65,35,16,74,27,98 }; //sort the array first Arrays.sort(numArr); System.out.println('Input array:' + Arrays.toString(numArr)); int key = 35; //call binarySearch function to search a given key System.out.println('Key ' + key + ' found at index = ' + Arrays .binarySearch(numArr, key)); } }
Produktion:
I ovenstående program sorterer vi først input-arrayet, da arrayet skal sorteres for binarySearch. Derefter overføres arrayet og nøglen, der skal søges, til 'binærsøgningsmetoden'. Indekset, hvor nøglen findes, vises i output.
Prototype: statisk int binærsøgning (int [] a, int fraIndex, int tilIndex, int-nøgle)
Parametre:
eksempler på unix shell-scripting til begyndere
a => array, der skal søges
fromIndex => startindeks for det område, som nøglen skal søges over
toIndex => indekset for det sidste element i området
nøgle => nøgle, der skal søges efter
Returværdi: indeks for nøgleelementet findes i det angivne interval. Ellers vender den tilbage (- ('indsættelsespunktet') - 1).
Beskrivelse: Denne overbelastning af binærsøgning søger efter en nøgleværdi i det specificerede område af arrayet og returnerer nøgleelementets indeksposition, hvis den findes. Matrixen og derfor området skal sorteres for at binærsøgning skal fungere. Hvis den ikke er sorteret, er resultaterne udefinerede.
Eksempel:
import java.util.Arrays; import java.util.List; public class Main { public static void main(String[] args) { int numArr[] = { 23,43,26,65,35,16,74,27,98 }; // define the Array Arrays.sort(numArr); //sort the array first System.out.println('Input array:' + Arrays.toString(numArr)); int key = 35; //call binarySearch function to search a given key System.out.println('Key ' + key + ' found at index = ' + Arrays .binarySearch(numArr,3,7, key)); } }
Produktion:
Ovenstående program er det samme som det forrige med en forskel, at vi i opkaldet til binærsøgningsmetoden har specificeret et område af det array, hvor søgningen skal udføres.
# 3) copyOf
Prototype: statisk int [] copyOf (int [] original, int newLength)
Parametre:
original => array, der skal kopieres
newLength => længden af det kopierede array
Returværdi: Et nyt array kopieret fra originalen og polstret eller afkortet med nuller afhængigt af en specificeret længde.
Beskrivelse: Kopierer matrixoriginalen til et nyt array og padser eller afkortes med nuller afhængigt af den angivne længde.
Eksempel:
import java.util.Arrays; public class Main { public static void main(String[] args) { // define the Array String strArr[] = {'Java', 'Python', 'Perl', 'C', 'Ruby'}; // print the original array System.out.println('Original String Array: ' + Arrays.toString(strArr)); //copy the array into new array using copyOf and print it System.out.println('Copied Array: ' + Arrays.toString( Arrays.copyOf(strArr, 5))); } }
Produktion:
Ovenstående program demonstrerer brugen af 'copyOf' -metoden i Arrays-klasse, der kopierer den givne matrix til en ny. Ovenstående program kopierer den originale streng array til en ny array.
# 4) copyOfRange
Prototype: statisk int [] copyOfRange (int [] original, int fra, int til)
Parametre:
original => array, hvorfra værdier i området skal kopieres
Fra => første indeks i området
Til => sidste indeks for området
Returværdi: Nyt array med værdier fra det angivne interval med nuller afkortet eller polstret for at opnå den ønskede længde.
Beskrivelse: Kopierer det specificerede interval fra et givet array til et nyt array. Matrixens startede indeks skal omfatte 0 til original.length. Slutindekset kan være eksklusivt.
Eksempel:
import java.util.Arrays; public class Main { public static void main(String[] args) { // define the Array String strArr[] = {'Java', 'Python', 'Perl', 'C', 'Ruby'}; // print the original array System.out.println('Original String Array: ' + Arrays.toString(strArr)); //copy the array into new array using copyOfRange and print it System.out.println('Copied Range of Array: ' + Arrays.toString( Arrays.copyOfRange(strArr,1,3))); } }
Produktion:
Vi har ændret det forrige program til at bruge 'copyOfRange' -metoden, der kopierer et specifikt område fra arrayet og danner et nyt array. I ovenstående program har vi specificeret området som 1, 3. Derfor viser output et nyt array med 2 elementer.
# 5) Lig
Prototype: statiske boolske er lig med (int [] a, int [] a2)
Parametre:
til => første array, der skal testes for lighed
A2 => andet array, der skal testes for lighed
Returværdi: Returnerer sandt, hvis begge arrays er ens.
Beskrivelse: Denne metode kontrollerer, om begge arrays er ens, og returnerer resultaterne. De to arrays siges at være ens, hvis begge arrays har det samme antal elementer, og de tilsvarende elementer i begge arrays er ens.
Eksempel:
import java.util.Arrays; public class Main { public static void main(String[] args) { // define two arrays, array_One and array_Two int[] array_One = { 1, 3, 5, 7 }; int[] array_Two = { 1, 3, 5, 7 }; //print the arrays System.out.println('array_One = ' + Arrays.toString(array_One)); System.out.println('array_Two = ' + Arrays.toString(array_Two)); //use equals method to check for equality of arrays booleanarray_equal = Arrays.equals(array_One, array_Two); //print the results if (array_equal) { System.out.println('equals method returns ' + array_equal + ', hence arrays array_One and array_Two are equal
'); }else { System.out.println('equals method returns ' + array_equal + ', hence arrays array_One and array_Two are not equal
'); } // define two more arrays, firstArray&secondArray int[] firstArray = { 2, 4, 6, 8 }; int[] secondArray = { 1, 3, 5, 7}; //display these arrays System.out.println('firstArray = ' + Arrays.toString(firstArray)); System.out.println('secondArray = ' + Arrays.toString(secondArray)); //use equals method to check equality of arrays boolean test_array = Arrays.equals(firstArray, secondArray); //print the results if (test_array) { System.out.println('equals method returns ' + test_array + ', hence arrays firstArray and secondArray are equal
'); }else { System.out.println('equals method returns ' + test_array + ', hence arrays firstArray and secondArray are not equal
'); } } }
Produktion:
Ovenstående program demonstrerer 'ligemetoden'. Her har vi brugt to sæt arrays og kaldet 'lig' to gange. I det første kald til lig er begge arrays de samme, og derfor returnerer metoden sand. I det andet kald til lig er de to arrays forskellige, og metoden returnerer falsk.
# 6) Udfyld
Prototype: statisk tomrumsudfyldning (int [] a, int val)
Parametre:
a => array, der skal udfyldes
val => værdi, der skal udfyldes alle steder i arrayet
Returværdi: Ingen
Beskrivelse: Udfylder arrayet med den angivne værdi.
Eksempel:
import java.util.Arrays; public class Main { public static void main(String[] args) { // define the array int[] intArray = { 1, 3, 5, 7 }; //print original array System.out.println('The original array: ' + Arrays.toString(intArray)); //call fill method to fill the array with all zeros Arrays.fill(intArray, 0); //print altered array System.out.println('Array after call to fill:' + Arrays.toString(intArray)); } }
Produktion:
hvordan man kører eksekverbar jar-fil
Ovenstående program viser den grundlæggende version af udfyldningsmetoden. Her udfylder vi bare hele arrayet med en anden værdi. I dette tilfælde har vi udfyldt arrayet med alle nuller.
Prototype: statisk tomrumsudfyldning (int [] a, int fraIndex, int tilIndex, int val)
Parametre:
a => array, hvis område skal udfyldes
fromIndex => startindeks for området
toIndex => slutindeks for området
val => værdi, som elementerne i området skal udfyldes med
Returværdi: Ingen
Beskrivelse: Fylder det angivne interval fraIndex tilIndex i arrayet 'a' med den angivne værdi. Hvis fraIndex = tilIndex, er området, der skal udfyldes, tomt.
Eksempel:
import java.util.Arrays; public class Main { public static void main(String[] args) { // define the array int[] intArray = { 1, 3, 5, 7, 9, 11, 13, 15,17}; //print original array System.out.println('The original array: ' + Arrays.toString(intArray)); //call fill method to fill the range (2,6) in the array with zeros Arrays.fill(intArray, 2, 6, 0); //print altered array System.out.println('Array after call to fill the range(2,6):' + Arrays.toString(intArray)); } }
Produktion:
Dette er en anden version af udfyldningsmetoden, hvor vi specificerer det særlige område i arrayet, der skal udfyldes med en anden værdi. I ovenstående program har vi specificeret området [2, 6], der skal udfyldes med nuller. De andre elementer forbliver de samme som vist i output.
# 7) Sorter
Prototype: statisk tomrums sort (int [] a)
Parametre: a => array, der skal sorteres
Returværdi: Ingen
Beskrivelse: Denne metode sorterer arrayet i stigende rækkefølge.
Eksempel:
import java.util.Arrays; public class Main { public static void main(String[] args) { // define the array int[] intArray = {10,4,25,63,21,51,73,24,87,18}; //print original array System.out.println('The original array: ' + Arrays.toString(intArray)); //call sort method to sort the given array in ascending order Arrays.sort(intArray); //print altered array System.out.println('Sorted array:' + Arrays.toString(intArray)); } }
Produktion:
Ovenstående program sorterer en række heltal ved hjælp af sorteringsmetoden i Arrays klasse og udskriver det sorterede array.
Prototype: statisk tomrums sort (int [] a, int fraIndex, int tilIndex)
Parametre:
a => matrix, hvorfra et område skal sorteres
fromIndex => startindeks for området
toIndex => slutindeks for området
Returværdi: ingen
Beskrivelse: Sorterer det interval, der er angivet fra Index til Index i stigende rækkefølge. Hvis fraIndex = tilIndex, er området, der skal sorteres, tomt.
Eksempel:
import java.util.Arrays; public class Main { public static void main(String[] args) { // define the array int[] intArray = {10,4,25,63,21,51,73,24,87,18}; //print original array System.out.println('The original array: ' + Arrays.toString(intArray)); //call sort method to sort the given range in the array in ascending order Arrays.sort(intArray, 2, 7); //print altered array System.out.println('Sorted range(2,7) in the array:' + Arrays.toString(intArray)); } }
Produktion:
Ovenstående program demonstrerer variationen i sorteringsmetoden. I dette kan vi specificere et område, hvor arrayet skal sorteres. Elementerne uden for dette område er ikke sorteret. I ovenstående program er området [2,7] i det givne array specificeret til at blive sorteret i sorteringsmetoden.
Derfor kan vi i output se, at kun elementerne i dette interval er sorteret i stigende rækkefølge.
# 8) toString
Prototype: statisk streng til streng (int [] a)
Parametre: a => array, hvis strengrepræsentation er påkrævet
Returværdi: streng => strengrepræsentation af array
Beskrivelse: Konverterer det givne array til dets strengrepræsentation.
Eksempel:
import java.util.*; public class Main { public static void main(String[] args) { //declare arrays of type int and double int[] intArray = {10,20,30,40,50}; double[] dblArray = {1.0,2.0,3.0,4.0,5.0}; System.out.println('String representation of int Array: '); //print string representation of int array using toString System.out.println(Arrays.toString(intArray)); System.out.println('
String representation of double Array: '); //print string representation of double array using toString System.out.println(Arrays.toString(dblArray)); } }
Produktion:
I ovenstående eksempel har vi brugt toString-metoden, der konverterer arrays til en strengrepræsentation. Så for at demonstrere denne metode har vi brugt to arrays af typen int og double. Derefter konverteres hver af denne matrix med toString-metoden til den tilsvarende strengrepræsentation, der vises i output.
# 9) hashCode
Prototype: statisk int hashCode (int [] a)
Parametre: a => array, hvis hashcode skal beregnes.
Returværdi: int => hashcode beregnet
Beskrivelse: Metoden returnerer hashkoden for et givet array. Det hashcode af en Java Objekt er faktisk et 32-bit nummer (signeret int). Ved hjælp af hashcode kan du administrere et objekt ved hjælp af hash-baseret struktur.
Hashcode tildeles af JVM til et objekt og er normalt unikt, medmindre de to objekter er lig med hinanden, i hvilket tilfælde begge objekterne har den samme hashcode.
Eksempel:
import java.util.*; public class Main { public static void main(String[] args) { //declare arrays of type int int[] intArray = {10,20,30,40,50}; //print the input array System.out.println('The input Array: ' + Arrays.toString(intArray)); //get hashcode of the array using 'hashCode' method of array inthashCde = Arrays.hashCode(intArray); //print the hashCode System.out.println('The hashCode for input array:' + hashCde); } }
Produktion:
Metoden hashCode beregner hashkoden for det givne array, der sendes som et argument til det.
Ofte stillede spørgsmål
Q # 1) Hvad er java.util-arrays?
Svar: Klassen java.util.Arrays strækker sig fra klassen java.lang.Object. Arrays-klassen indeholder metoden til at repræsentere arrays som en liste. Den indeholder også forskellige metoder til at manipulere arrays som at sortere, søge, repræsentere arrays som strenge osv.
Q # 2) Hvilken sortering bruges i arraysortering i Java?
Svar: Sorteringsmetoden til Arrays-klassen i Java bruger to sorteringsteknikker. Det bruger quicksort, når primitive typer bruges, mens når objekter bruges, der implementerer sammenlignelig grænseflade, bruges flettsortering.
Spørgsmål nr. 3) Hvad gør Arrays.sort () -metoden i Java?
Svar: Arrays.sort () -metoden i Java har forskellige overbelastninger, hvor du kan udføre sortering på arrays. Det har overbelastning til sortering af forskellige primitive datatypes arrays.
Derudover har metoden Arrays.sort () forskellige overbelastninger til sortering af en matrix over et bestemt område. Bortset fra dette giver metoden Arrays.sort () os også mulighed for at sortere afhængigt af den medfølgende komparator.
Q # 4) Hvad er samlinger og arrays klasse?
Svar: Samlinger er dynamiske og klassen Samlinger giver direkte metoder, der virker på samlinger. Arrays er statiske og har klassearrayer, der giver metoder til at manipulere arrays.
Men dette er ikke direkte metoder, dvs. Array-objekter kan ikke påberåbe sig disse metoder. I stedet sendes et array-objekt som et argument til disse metoder.
bedste registry cleaner til Windows 10
Konklusion
Arrays-klasse tilhører java.util-pakken og strækker sig fra java.lang.Object-klassen. Arrays klasse indeholder metoder, der bruges til at manipulere arrays. Disse metoder inkluderer dem, der bruges til at sortere arrays, søge efter et bestemt element i arrays, udfylde arrayet med en bestemt værdi, metoder til at sammenligne arrays osv.
Hver af disse metoder har forskellige overbelastninger, der gør det muligt for programmøren at påberåbe sig disse metoder på arrays af forskellige datatyper og også på del- eller hele arrays.
I denne vejledning har vi diskuteret de fleste af metoderne til arrays klasse. Vi så også en kort beskrivelse og eksempler på de vigtigste metoder. Disse eksempler kan replikeres for forskellige datatyper, og vi overlader det til dig.
=> Besøg her for at lære Java fra bunden.
Anbefalet læsning
- Java Array Length Tutorial med kodeeksempler
- Jagged Array In Java - Vejledning med eksempler
- JAVA-vejledning til begyndere: 100+ praktiske Java-videovejledninger
- Hvad er Java Vector | Java Vector Class Tutorial med eksempler
- Sådan sorteres en matrix i Java - vejledning med eksempler
- Vend en matrix i Java - 3 metoder med eksempler
- Java Generic Array - Sådan simuleres generiske arrays i Java?
- Java Copy Array: Sådan kopieres / klones en array i Java