java array class tutorial java
Questo tutorial tratta la classe Array in Java e i metodi della classe java.util.arrays insieme a una descrizione dettagliata ed esempi di metodi della classe Array:
La classe 'Arrays' è un membro del pacchetto 'java.util'. Questa è una parte del framework Java Collections e fornisce metodi per creare, accedere e manipolare dinamicamente gli array Java.
Tutti i metodi forniti dalla classe Arrays sono di natura statica e sono metodi della classe 'Object'. Poiché i metodi sono statici, è possibile accedervi utilizzando il nome della classe stessa.
=> Controlla TUTTI i tutorial Java qui.
Cosa imparerai:
Java Array Class
La classe Arrays è stata introdotta in Java 1.2 ei metodi in essa contenuti sono utilizzati principalmente per la manipolazione dell'array inclusa la ricerca, l'ordinamento, ecc. La classe array fornisce metodi sovraccaricati per quasi tutti i tipi di dati.
La gerarchia delle classi per la classe Arrays è mostrata di seguito:
La classe Arrays si estende dalla classe Object ei suoi metodi sono metodi della classe Object.
La sintassi generale per accedere a qualsiasi metodo della classe Arrays è:
Arrays.;
Nella prossima sezione, elencheremo i vari metodi forniti dalla classe Arrays.
Metodi di array Java
Le tabelle seguenti forniscono un'introduzione ai vari metodi forniti dalla classe Arrays. Qui abbiamo elencato i metodi principali. Si noti che la maggior parte dei metodi sono sovraccaricati per fornire supporto per tutti i tipi primitivi.
Elencheremo il prototipo e la descrizione di ciascuna delle funzioni. Quindi, nella sezione seguente, descriveremo alcuni dei metodi importanti fornendo esempi di programmazione.
Nome metodo | Prototipo | Descrizione |
---|---|---|
static int binarySearch (double [] a, int fromIndex, int toIndex, double key) | Cerca la chiave nell'intervallo specificato in una doppia matrice | |
asList | Elenco statico< T> asList (Object [] a) | Restituisce un elenco (dimensione fissa) dall'array specificato |
binarySearch Questo metodo utilizza l'algoritmo di ricerca binaria. Nella colonna successiva sono mostrati vari overload del metodo binarySearch. | static int binarySearch (byte [] a, byte key) | Cerca una chiave in una matrice di byte |
static int binarySearch (byte [] a, int fromIndex, int toIndex, byte key) | Cerca la chiave nell'intervallo specificato in una matrice di byte | |
static int binarySearch (char [] a, char key) | Cerca una chiave in una matrice di caratteri | |
static int binarySearch (char [] a, int fromIndex, int toIndex, char key) | Cerca la chiave nell'intervallo specificato in una matrice di caratteri | |
static int binarySearch (double [] a, double key) | Cerca una chiave in una doppia matrice | |
static int binarySearch (float [] a, float key) | Cerca una chiave in un array di float | |
static int binarySearch (float [] a, int fromIndex, int toIndex, float key) | Cerca la chiave nell'intervallo specificato in un array di float | |
static int binarySearch (int [] a, int key) | Cerca una chiave in un array int | |
static int binarySearch (int [] a, int fromIndex, int toIndex, int key) | Cerca la chiave nell'intervallo specificato in un array int | |
static int binarySearch (long [] a, long key) | Cerca una chiave in un array lungo | |
static int binarySearch (long [] a, int fromIndex, int toIndex, long key) | Cerca la chiave nell'intervallo specificato in una matrice lunga | |
static int binarySearch (Object [] a, Object key) | Cerca una chiave in un array di oggetti | |
static int binarySearch (Object [] a, int fromIndex, int toIndex, Object key) | Cerca la chiave nell'intervallo specificato nell'array di oggetti | |
static int binarySearch (short [] a, short key) | Cerca una chiave in una serie di corti | |
static int binarySearch (short [] a, int fromIndex, int toIndex, tasto breve) | Cerca la chiave nell'intervallo specificato in una matrice di corti | |
static int binarySearch (T [] a, T key, Comparator c) | Cerca una chiave in una matrice di oggetti specificati | |
static int binarySearch (T [] a, int fromIndex, int toIndex, T key, Comparator c) | Cerca la chiave nell'intervallo specificato nella matrice di oggetti |
Nome metodo | Prototipo | Descrizione |
---|---|---|
statico long [] copyOf (long [] original, int newLength) | Copia la matrice specificata. Tronca o aggiunge degli zeri se necessario | |
copia di Il metodo viene utilizzato per copiare la matrice con la lunghezza specificata. La colonna successiva elenca gli overload di questo metodo | static boolean [] copyOf (boolean [] original, int newLength) | Copia la matrice specificata. Se necessario, tronca o aggiunge i valori 'false' |
byte statico [] copyOf (byte [] originale, int newLength) | Copia la matrice specificata. Tronca o aggiunge degli zeri se necessario | |
char statico [] copyOf (char [] original, int newLength) | Copia la matrice specificata. Tronca o aggiunge null se necessario | |
static double [] copyOf (double [] original, int newLength) | Copia la matrice specificata. Tronca o aggiunge degli zeri se necessario | |
statico float [] copyOf (float [] original, int newLength) | Copia la matrice specificata. Tronca o aggiunge degli zeri se necessario | |
static int [] copyOf (int [] original, int newLength) | Copia la matrice specificata. Tronca o aggiunge degli zeri se necessario | |
static short [] copyOf (short [] original, int newLength) | Copia la matrice specificata. Tronca o aggiunge degli zeri se necessario | |
static T [] copyOf (T [] original, int newLength) | Copia la matrice specificata. Tronca o aggiunge valori nulli se necessario | |
static T [] copyOf (U [] original, int newLength, ClassnewType) | Copia la matrice specificata. Tronca o aggiunge valori nulli se necessario | |
copyOfRange Questo metodo viene utilizzato per copiare un intervallo specificato nell'array. Gli overload per questo metodo sono riportati nella colonna successiva | statico booleano [] copyOfRange (booleano [] originale, int da, int a) | Copia la matrice con l'intervallo specificato in una nuova matrice |
byte statico [] copyOfRange (byte [] originale, int da, int a) | Copia la matrice con l'intervallo specificato in una nuova matrice | |
statico char [] copyOfRange (char [] original, int from, int to) | Copia la matrice con l'intervallo specificato in una nuova matrice | |
static double [] copyOfRange (double [] original, int from, int to) | Copia la matrice con l'intervallo specificato in una nuova matrice | |
statico float [] copyOfRange (float [] originale, int da, int a) | Copia la matrice con l'intervallo specificato in una nuova matrice | |
static int [] copyOfRange (int [] original, int from, int to) | Copia la matrice con l'intervallo specificato in una nuova matrice | |
statico lungo [] copyOfRange (lungo [] originale, int da, int a) | Copia la matrice con l'intervallo specificato in una nuova matrice | |
statico breve [] copyOfRange (breve [] originale, int da, int a) | Copia la matrice con l'intervallo specificato in una nuova matrice | |
static T [] copyOfRange (T [] original, int from, int to) | Copia la matrice con l'intervallo specificato in una nuova matrice | |
static T [] copyOfRange (U [] original, int from, int to, ClassnewType) | Copia la matrice con l'intervallo specificato in una nuova matrice |
Nome metodo | Prototipo | Descrizione |
---|---|---|
booleano statico è uguale a (double [] a, double [] a2) | Restituisce vero se i due doppi array specificati sono uguali. | |
deepEquals | static boolean deepEquals (Object [] a1, Object [] a2) | Controlla se due array specificati sono profondamente uguali |
deepHashCode | static intdeepHashCode (Object [] a) | Restituisce un codice hash della matrice specificata |
deepToString | static StringdeepToString (Object [] a) | Restituisce il 'contenuto profondo' dell'array specificato in una stringa |
È uguale a Controlla se due array specificati sono uguali | booleano statico è uguale a (booleano [] a, booleano [] a2) | Restituisce vero se i due booleanarrays specificati sono uguali. |
booleano statico è uguale a (byte [] a, byte [] a2) | Restituisce vero se i due array di byte specificati sono uguali | |
booleano statico è uguale a (char [] a, char [] a2) | Restituisce vero se le due matrici di caratteri specificate sono uguali. | |
booleano statico è uguale a (float [] a, float [] a2) | Restituisce vero se i due array float specificati sono uguali. | |
booleano statico è uguale a (int [] a, int [] a2) | Restituisce vero se i due array int specificati sono uguali. | |
booleano statico è uguale a (long [] a, long [] a2) | Restituisce vero se i due array lunghi specificati sono uguali. | |
booleano statico è uguale a (Object [] a, Object [] a2) | Restituisce true se i due array di oggetti specificati sono uguali. | |
booleano statico è uguale a (short [] a, short [] a2) | Restituisce vero se i due array brevi specificati sono uguali. |
Nome metodo | Prototipo | Descrizione |
---|---|---|
riempimento vuoto statico (double [] a, double val) | Riempie il double array con il valore double specificato | |
riempire Riempie la matrice (tutti gli elementi) con il valore specificato. La colonna successiva fornisce gli overload per questa funzione | riempimento vuoto statico (booleano [] a, booleano val) | Riempie l'array booleano con un valore booleano specificato |
static void fill (boolean [] a, int fromIndex, int toIndex, boolean val) | Assegna un valore booleano all'intervallo specificato nell'array booleano. | |
riempimento vuoto statico (byte [] a, byte val) | Riempie la matrice di byte con un valore di byte specificato | |
riempimento vuoto statico (byte [] a, int fromIndex, int toIndex, byte val) | Riempie l'array di byte con il valore di byte specificato nell'intervallo specificato | |
static void fill (char [] a, char val) | Riempie l'array di caratteri con il valore di caratteri specificato | |
static void fill (char [] a, int fromIndex, int toIndex, char val) | Riempie l'intervallo dell'array di caratteri con il valore di caratteri specificato | |
static void fill (double [] a, int fromIndex, int toIndex, double val) | Assegna un valore double all'intervallo specificato nella matrice doppia. | |
static void fill (float [] a, float val) | Assegna il valore float all'intervallo specificato nell'array float. | |
static void fill (float [] a, int fromIndex, int toIndex, float val) | Assegna il valore float all'intervallo specificato nell'array float. | |
riempimento vuoto statico (int [] a, int val) | Assegna un valore int all'array int. | |
static void fill (int [] a, int fromIndex, int toIndex, int val) | Assegna un valore int all'intervallo specificato nell'array int. | |
static void fill (long [] a, int fromIndex, int toIndex, long val) | Assegna un valore lungo all'intervallo specificato nella matrice lunga. | |
riempimento di vuoti statici (long [] a, long val) | Assegna un valore lungo all'array lungo. | |
static void fill (Object [] a, int fromIndex, int toIndex, Object val) | Assegna il riferimento all'oggetto all'intervallo specificato nella matrice degli oggetti. | |
riempimento vuoto statico (Object [] a, Object val) | Assegna il riferimento all'oggetto all'oggetto specificato | |
static void fill (short [] a, int fromIndex, int toIndex, short val) | Assegna un valore breve all'intervallo specificato nella matrice breve. | |
riempimento di vuoti statici (short [] a, short val) | Assegna un valore short all'array short specificato. |
Nome metodo | Prototipo | Descrizione |
---|---|---|
statico void sort (float [] a) | Ordina l'array float in ordine numerico crescente. | |
Ordinare Ordina l'array passato come parametro al metodo. I sovraccarichi sono indicati nella colonna successiva. | statico void sort (byte [] a) | Ordina numericamente l'array di byte |
statico void sort (byte [] a, int fromIndex, int toIndex) | Ordina l'intervallo di elementi dall'array | |
statico void sort (char [] a) | Ordina la matrice di caratteri in ordine numerico crescente. | |
statico void sort (char [] a, int fromIndex, int toIndex) | Ordina la gamma di elementi nell'array in ordine crescente. | |
statico void sort (double [] a) | Ordina il doppio array in ordine numerico crescente. | |
statico void sort (double [] a, int fromIndex, int toIndex) | Ordina la gamma di elementi dalla matrice in ordine crescente. | |
statico void sort (float [] a, int fromIndex, int toIndex) | Ordina la gamma di elementi dalla matrice in ordine crescente. | |
statico void sort (int [] a) | Ordina l'array int in ordine numerico crescente. | |
statico void sort (int [] a, int fromIndex, int toIndex) | Ordina la gamma di elementi dalla matrice in ordine crescente. | |
statico void sort (long [] a) | Ordina la matrice lunga in ordine numerico crescente. | |
statico void sort (long [] a, int fromIndex, int toIndex) | Ordina la gamma di elementi dalla matrice in ordine crescente | |
statico void sort (Object [] a) | Ordina la matrice di oggetti in ordine crescente. L'ordinamento avviene in base all'ordinamento naturale dei suoi elementi | |
statico void sort (Object [] a, int fromIndex, int toIndex) | Ordina l'intervallo specificato da un array di oggetti in ordine crescente. L'ordinamento avviene in base all'ordinamento naturale dei suoi elementi. | |
statico void sort (short [] a) | Ordina la matrice di tipo short in ordine numerico crescente. | |
statico void sort (short [] a, int fromIndex, int toIndex) | Ordina la gamma di elementi dalla matrice in ordine crescente. | |
statico void sort (T [] a, Comparator c) | Ordina la matrice di oggetti specificata. L'ordine di ordinamento è indotto secondo il comparatore specificato. | |
statico void sort (T [] a, int fromIndex, int toIndex, Comparator c) | Ordina l'intervallo di elementi da un array di oggetti nell'ordine specificato dal comparatore. |
Nome metodo | Prototipo | Descrizione |
---|---|---|
static String toString (long [] a) | Restituisce una rappresentazione di stringa di un array lungo | |
accordare Questo metodo restituisce la rappresentazione di stringa di un dato array. Nella colonna successiva vengono forniti diversi overload di questo metodo | stringa statica toString (boolean [] a) | Restituisce una rappresentazione di stringa di un array booleano |
stringa statica toString (byte [] a) | Restituisce una rappresentazione di stringa di una matrice di byte | |
stringa statica toString (char [] a) | Restituisce una rappresentazione di stringa di una matrice di caratteri | |
static String toString (double [] a) | Restituisce una rappresentazione di stringa di un doppio array | |
stringa statica toString (float [] a) | Restituisce una rappresentazione di stringa di un array float | |
stringa statica toString (int [] a) | Restituisce una rappresentazione di stringa di un array int | |
stringa statica toString (Object [] a) | Restituisce una rappresentazione di stringa di un array di oggetti | |
stringa statica toString (short [] a) | Restituisce una rappresentazione di stringa di un array breve |
Nome metodo | Prototipo | Descrizione |
---|---|---|
static int hashCode (long [] a) | Restituisce il codice hash del contenuto di un array lungo | |
codice hash Questo metodo restituisce l'hashCode del contenuto dell'array specificato I metodi sovraccaricati sono indicati nella colonna successiva. | static int hashCode (boolean [] a) | Restituisce il codice hash del contenuto dell'array booleano |
static int hashCode (byte [] a) | Restituisce il codice hash del contenuto della matrice di byte | |
static int hashCode (char [] a) | Restituisce il codice hash del contenuto della matrice di caratteri | |
static int hashCode (double [] a) | Restituisce il codice hash del contenuto di un doppio array | |
static int hashCode (float [] a) | Restituisce il codice hash del contenuto di un array float | |
static int hashCode (int [] a) | Restituisce il codice hash del contenuto di un array int. | |
static int hashCode (Object [] a) | Restituisce il codice hash del contenuto dell'array di oggetti | |
static int hashCode (short [] a) | Restituisce il codice hash del contenuto dell'array breve |
Le tabelle precedenti mostrano tutti i metodi forniti dalla classe Arrays. La maggior parte di questi sono sovraccaricati per vari tipi primitivi.
Discutiamo in dettaglio alcuni di questi metodi.
# 1) asList
Prototipo: static List asList (Object [] a)
Parametri: a - array di oggetti da cui verrà eseguito il backup dell'elenco.
Valore di ritorno: List => elenco a dimensione fissa dell'array specificato
Descrizione: Restituisce un elenco serializzabile di dimensioni fisse supportato da un array fornito come argomento.
differenza tra scenario di test e scenario di test
Esempio:
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); } }
Produzione:
Il programma precedente mostra l'utilizzo del metodo 'asList' della classe Arrays. Qui, abbiamo dichiarato un array di stringhe e lo abbiamo passato al metodo asList per ottenere un elenco.
# 2) binarySearch
Prototipo: static int binarySearch (int [] a, int key)
Parametri:
a => array in cui cercare la chiave
Chiave => valore dell'elemento da cercare
Valore di ritorno: int => posizione (indice) in cui si trova la chiave, altrimenti restituisce (- (il 'punto di inserimento') - 1).
Descrizione: Cerca la chiave specificata nell'array dato utilizzando un algoritmo di ricerca binaria. L'array deve essere ordinato affinché la ricerca binaria funzioni. Se la matrice non è ordinata, i risultati non sono definiti. Inoltre, se sono presenti più posizioni nell'array per lo stesso valore di chiave, la posizione restituita non è garantita.
Esempio:
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)); } }
Produzione:
Nel programma precedente, prima ordiniamo l'array di input poiché per binarySearch l'array dovrebbe essere ordinato. Quindi l'array e la chiave da cercare vengono passati al metodo 'binarySearch'. L'indice in cui si trova la chiave viene visualizzato nell'output.
Prototipo: static int binarySearch (int [] a, int fromIndex, int toIndex, int key)
Parametri:
a => array da cercare
fromIndex => indice iniziale dell'intervallo in cui la chiave deve essere cercata
toIndex => l'indice dell'ultimo elemento dell'intervallo
chiave => chiave da cercare
Valore di ritorno: l'indice dell'elemento chiave si trova nell'intervallo specificato. Altrimenti ritorna (- (il “punto di inserimento”) - 1).
Descrizione: Questo overload di binarySearch cerca un valore chiave nell'intervallo specificato dell'array e restituisce la posizione di indice dell'elemento chiave, se trovato. L'array e quindi l'intervallo devono essere ordinati affinché binarySearch funzioni. Se non è ordinato, i risultati non sono definiti.
Esempio:
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)); } }
Produzione:
Il programma sopra è uguale al precedente con la differenza che nella chiamata al metodo binarySearch abbiamo specificato un intervallo dell'array in cui deve essere condotta la ricerca.
# 3) copyOf
Prototipo: static int [] copyOf (int [] original, int newLength)
Parametri:
originale => matrice da copiare
newLength => lunghezza dell'array copiato
Valore di ritorno: Un nuovo array copiato dall'originale e riempito o troncato con zeri a seconda di una lunghezza specificata.
Descrizione: Copia l'originale dell'array in un nuovo array e lo inserisce o lo tronca con zeri a seconda della lunghezza specificata.
Esempio:
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))); } }
Produzione:
Il programma precedente dimostra l'uso del metodo 'copyOf' della classe Arrays che copia l'array dato in uno nuovo. Il programma precedente copia l'array di stringhe originale in un nuovo array.
# 4) copyOfRange
Prototipo: static int [] copyOfRange (int [] original, int from, int to)
Parametri:
originale => matrice da cui copiare i valori nell'intervallo
Da => primo indice dell'intervallo
To => ultimo indice dell'intervallo
Valore di ritorno: Nuovo array con valori dell'intervallo specificato con zeri troncati o riempiti per ottenere la lunghezza desiderata.
Descrizione: Copia l'intervallo specificato da un dato array in un nuovo array. L'indice iniziale dell'array dovrebbe essere compreso tra 0 e original.length. L'indice finale può essere esclusivo.
Esempio:
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))); } }
Produzione:
Abbiamo modificato il programma precedente per utilizzare il metodo 'copyOfRange' che copia un intervallo specifico dall'array e forma un nuovo array. Nel programma precedente, abbiamo specificato l'intervallo come 1, 3. Quindi l'output mostra un nuovo array di 2 elementi.
# 5) Uguale a
Prototipo: booleano statico è uguale a (int [] a, int [] a2)
Parametri:
per => primo array da verificare per l'uguaglianza
A2 => secondo array da verificare per l'uguaglianza
Valore di ritorno: Restituisce vero se entrambi gli array sono uguali.
Descrizione: Questo metodo controlla se entrambi gli array sono uguali e restituisce i risultati. Si dice che i due array sono uguali se entrambi gli array hanno un numero uguale di elementi e gli elementi corrispondenti in entrambi gli array sono uguali.
Esempio:
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
'); } } }
Produzione:
Il programma precedente mostra il metodo 'uguale'. Qui abbiamo utilizzato due serie di array e chiamato due volte 'uguale'. Nella prima chiamata a uguale, entrambi gli array sono uguali e quindi il metodo restituisce true. Nella seconda chiamata a uguale, i due array sono diversi e il metodo restituisce false.
# 6) Riempi
Prototipo: riempimento vuoto statico (int [] a, int val)
Parametri:
a => matrice da riempire
val => valore da riempire in tutti i posti dell'array
Valore di ritorno: Nessuna
Descrizione: Riempie la matrice con il valore specificato.
Esempio:
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)); } }
Produzione:
miglior downloader gratuito di YouTube per Windows 10
Il programma sopra mostra la versione base del metodo di riempimento. Qui, riempiamo semplicemente l'intero array con un altro valore. In questo caso, abbiamo riempito l'array con tutti zeri.
Prototipo: static void fill (int [] a, int fromIndex, int toIndex, int val)
Parametri:
a => array il cui intervallo deve essere riempito
fromIndex => indice iniziale dell'intervallo
toIndex => indice di fine dell'intervallo
val => valore con il quale devono essere riempiti gli elementi nell'intervallo
Valore di ritorno: Nessuna
Descrizione: Riempie l'intervallo specificato da fromIndex a toIndex nella matrice 'a' con il valore specificato. Se fromIndex = toIndex, l'intervallo da riempire è vuoto.
Esempio:
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)); } }
Produzione:
Questa è un'altra versione del metodo di riempimento in cui specifichiamo il particolare intervallo nell'array che deve essere riempito con un valore diverso. Nel programma sopra, abbiamo specificato l'intervallo [2, 6] da riempire con zeri. Gli altri elementi rimangono gli stessi come mostrato nell'output.
# 7) Ordina
Prototipo: statico void sort (int [] a)
Parametri: a => array da ordinare
Valore di ritorno: Nessuna
Descrizione: Questo metodo ordina l'array in ordine crescente.
Esempio:
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)); } }
Produzione:
Il programma precedente ordina un array di interi usando il metodo sort della classe Arrays e stampa l'array ordinato.
Prototipo: statico void sort (int [] a, int fromIndex, int toIndex)
Parametri:
come aprire i file eps in Windows 10
a => array da cui deve essere ordinato un intervallo
fromIndex => indice iniziale per l'intervallo
toIndex => end index per l'intervallo
Valore di ritorno: nessuna
Descrizione: Ordina l'intervallo specificato da fromIndex a toIndex in ordine crescente. Se fromIndex = toIndex, l'intervallo da ordinare è vuoto.
Esempio:
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)); } }
Produzione:
Il programma sopra mostra la variazione del metodo di ordinamento. In questo, possiamo specificare un intervallo su cui ordinare l'array. Gli elementi fuori da questo intervallo non vengono ordinati. Nel programma precedente, l'intervallo [2,7] nell'array dato è specificato per essere ordinato nel metodo di ordinamento.
Quindi nell'output, possiamo vedere che solo gli elementi in questo intervallo sono ordinati in ordine crescente.
# 8) toString
Prototipo: stringa statica toString (int [] a)
Parametri: a => array la cui rappresentazione di stringa è richiesta
Valore di ritorno: string => rappresentazione di stringa dell'array
Descrizione: Converte la matrice data nella sua rappresentazione di stringa.
Esempio:
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)); } }
Produzione:
Nell'esempio precedente, abbiamo utilizzato il metodo toString che converte gli array in una rappresentazione di stringa. Quindi, per dimostrare questo metodo, abbiamo utilizzato due array ciascuno di tipo int e double. Quindi, utilizzando il metodo toString, ciascuno di questo array viene convertito nella corrispondente rappresentazione di stringa mostrata nell'output.
# 9) hashCode
Prototipo: static int hashCode (int [] a)
Parametri: a => array il cui hashcode deve essere calcolato.
Valore di ritorno: int => hashcode calcolato
Descrizione: Il metodo restituisce il codice hash di un dato array. Il codice hash di un Giava L'oggetto è in realtà un numero a 32 bit (int con segno). Usando hashcode puoi gestire un oggetto usando una struttura basata su hash.
L'hashcode viene allocato da JVM a un oggetto e di solito è unico a meno che i due oggetti non siano uguali tra loro, nel qual caso entrambi gli oggetti avranno lo stesso hashcode.
Esempio:
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); } }
Produzione:
Il metodo hashCode calcola l'hashcode per l'array dato passato come argomento ad esso.
Domande frequenti
D # 1) Cosa sono gli array java.util?
Risposta: La classe java.util.Arrays si estende dalla classe java.lang.Object. La classe Arrays contiene il metodo per rappresentare gli array come un elenco. Contiene anche vari metodi per manipolare gli array come l'ordinamento, la ricerca, la rappresentazione degli array come stringhe, ecc.
D # 2) Quale ordinamento viene utilizzato nell'ordinamento di array in Java?
Risposta: Il metodo di ordinamento della classe Arrays in Java utilizza due tecniche di ordinamento. Utilizza quicksort quando vengono utilizzati tipi primitivi mentre quando vengono utilizzati oggetti che implementano un'interfaccia comparabile, viene utilizzato l'ordinamento di unione.
D # 3) Cosa fa il metodo Arrays.sort () in Java?
Risposta: Il metodo Arrays.sort () in Java ha vari overload che consentono di eseguire l'ordinamento sugli array. Ha sovraccarichi per l'ordinamento di array di tipi di dati primitivi diversi.
Inoltre, il metodo Arrays.sort () ha diversi overload per ordinare un array su un intervallo specificato. Oltre a questo, il metodo Arrays.sort () ci consente anche di ordinare in base al comparatore fornito.
D # 4) Cosa sono le collezioni e le classi di array?
Risposta: Le raccolte sono di natura dinamica e la classe Collections fornisce metodi diretti che agiscono sulle raccolte. Gli array sono di natura statica e hanno array di classi che forniscono metodi per manipolare gli array.
Ma questi non sono metodi diretti, ovvero gli oggetti Array non possono richiamare questi metodi. Invece, un oggetto array viene passato come argomento a questi metodi.
Conclusione
La classe Arrays appartiene al pacchetto java.util e si estende dalla classe java.lang.Object. La classe Arrays contiene metodi utilizzati per manipolare gli array. Questi metodi includono quelli usati per ordinare gli array, cercare un particolare elemento negli array, riempire l'array con un valore specifico, metodi per confrontare gli array, ecc.
Ciascuno di questi metodi ha vari overload che consentono al programmatore di invocare questi metodi su array di diversi tipi di dati e anche su parte o interi array.
In questo tutorial, abbiamo discusso la maggior parte dei metodi della classe array. Abbiamo anche visto una breve descrizione ed esempi dei principali metodi. Questi esempi possono essere replicati per vari tipi di dati e lasciamo a te.
=> Visita qui per imparare Java da zero.
Lettura consigliata
- Tutorial sulla lunghezza di array Java con esempi di codice
- Jagged Array in Java - Tutorial con esempi
- Tutorial JAVA per principianti: oltre 100 tutorial video Java pratici
- Cos'è Java Vector | Tutorial Java Vector Class con esempi
- Come ordinare un array in Java - Tutorial con esempi
- Invertire un array in Java - 3 metodi con esempi
- Java Generic Array - Come simulare array generici in Java?
- Java Copy Array: come copiare / clonare un array in Java