Come si può modificare le dimensioni di un array?

Come Puoi cambiare la dimensione di un array?

La risposta è un no. In Java non è possibile modificare le dimensioni di un accordo.

Ma prima di spiegare perché, dobbiamo essere chiari che significa cambiare la dimensione di un accordo.

Diamo un’occhiata Immagine seguente:

Fonte: https://overiq.com/c-programming-101/the-realloc-function-in-c/

Nell’immagine noi Avere all’inizio una disposizione di 5 elementi di tipo integer ma quindi si desidera aumentare 6 spazi di memoria nella disposizione. Quindi, modificare la dimensione di un array significa semplicemente aumentare o diminuire il numero di spazi di memoria che ha una disposizione. Nel nostro blocco di memoria a monte, la dimensione dell’array di a 11 elementi, tuttavia, lo stesso blocco verrà conservato la memoria a lungo Come dopo l’ultimo elemento di disposizione non c’è spazio di memoria occupato, poiché se ciò accade, un nuovo blocco di memoria dovrebbe essere prenotato e quindi gli elementi del vecchio blocco devono essere copiati nel nuovo.

GIÀ ,. .. Per i raggi ho menzionato tutto quanto sopra?

Perché ottenere la dimensione di una disposizione è necessaria una funzione / routine che può aumentare o diminuire la quantità di elementi di un blocco di memoria. In Java non esiste tale metodo, tuttavia, in altri linguaggi di programmazione come lingua C, se si dispone di una tale funzione e si chiama realloc.

Perché non riesci a cambiare la dimensione di un array?

Perché non ha una funzione come Realloc, altrimenti, se un accordo potrebbe essere ridimensionato.

Sottolineo anche che molte persone credono che il ridimensionamento di un accordo significhi la creazione di una nuova disposizione e copiare il nuovo accordo e la copia Elementi del precedente accordo nel nuovo, tuttavia, che non è corretto. Un grande esempio è il metodo ridimensionato di C #, qualcuno avrebbe pensato che ridimensiona un accordo, ma in realtà non è così, fa la stessa procedura che avevo menzionato sopra. Il nome del metodo è ingannevole.

Ridimensiona una disposizione significa modificando la dimensione della disposizione ma conservando lo stesso blocco di memoria (in cui gli elementi dell’array sono ospitati).

Ora, a Soluzione semplice Per essere in grado di registrare i nomi delle persone inevitanti delle dimensioni della disposizione, sta utilizzando la classe ArrayList e in questo modo è possibile creare un elenco di tipo .

Ad esempio:

public class Program { public static void main(String args) { Scanner sc = new Scanner(System.in); String namePerson; List<String> listPerson = new ArrayList<String>(); int op; do { System.out.println("Ingrese un nombre:"); namePerson = sc.nextLine(); listPerson.add(namePerson); System.out.println("Desea salir? Presione (-1)"); op = sc.nextInt(); sc.nextLine();//para limpiar el buffer stdin if(op == -1) break; }while(true); for(int i = 0; i != listPerson.size(); ++i) { System.out.println(listPerson.get(i)); } }}

Classe ArrayList implementato tramite un accordo vettoriale / dinamico, questo significa , che quando si crea un oggetto di tipo :

In realtà il costruttore di questo tipo è responsabile Per creare la disposizione dinamica con una capacità iniziale (codice sorgente dell’arraylist) di 10 elementi, questo ci dice che internamente questa classe ha il riferimento di un accordo per gli elementi x ma non ha qualunque Riferimento di un oggetto (per quel motivo se il metodo Dimensione () verrà eseguito, dovrebbe comportare elementi).

Tuttavia, la classe ArrayList non aumenta la dimensione della disposizione dinamica in cui vengono memorizzati i riferimenti di ciascun oggetto, pertanto, quando il numero di oggetti supera la capacità massima dell’elenco, ciò che accadrà che la memoria lo farà Sii riservato per una nuova disposizione, in cui gli elementi del vecchio blocco verranno copiati nel nuovo blocco di memoria.

Quindi se il tuo insegnante non ti consente di utilizzare la classe ArrayList, potresti creare la tua classe in cui è responsabile per emulare l’implementazione di un ArrayList.

Ad esempio:

class ArrayPerson{ private String person; private int capacity; private int count; public ArrayPerson() { person = new String; capacity = 10; } public ArrayPerson(int capacity) { this.capacity = capacity; person = new String; } //Obtiene la cantidad actual de objetos reservados en el arreglo public int getCount() { return count; } //Para obtener la referencia donde está el arreglo por completo public String getPersons() { return person; } //Para obtener la referencia de X objeto de tipo String del mismo arreglo public String getPerson(int index) { return person; } //Inserta una referencia de un objeto de tipo String en el arreglo public void add(String refPerson) { ++count; if(count > capacity) { capacity += 10; person = Arrays.copyOf(person, capacity); } person = refPerson; }}

Fondamentalmente questa classe quando arrivi a Istant It, ti dà l’opportunità di eseguire un costruttore parametrizzato o predefinito.

Se eseguiamo il costruttore parametrizzato :

• creerà Una disposizione di oggetti con una dimensione che dipenderà dal valore del parametro del costruttore.

Se eseguiamo il costruttore predefinito (senza parametri):

• Creerà una disposizione degli oggetti con una dimensione predefinita (con una capacità iniziale massima di 10 elementi).

Ora arriva la parte più interessante, il Metodo add.Questo metodo sarà fondamentalmente responsabile per l’aggiunta di un riferimento (indirizzo di memoria) in posizione X dell’array dell’oggetto, tuttavia, quando il numero di oggetti supera la capacità massima della capacità, verrà calcolata una nuova capacità e il metodo di Copyof della classe Arrays e ciò che questo metodo è quello di prenotare la memoria per una nuova disposizione di oggetti, in cui copierà gli elementi del vecchio blocco nel nuovo blocco di memoria e ciò che questo metodo restituisce è il riferimento di un oggetto di tipo String in cui il riferimento degli oggetti (con una dimensione di elemento aggiornata) sarà internamente.

La forma per utilizzare questa classe sarebbe Sii in questo modo:

public class Program { public static void main(String args) { Scanner sc = new Scanner(System.in); String namePerson; //Instaciamos la clase ArrayPerson ArrayPerson ap = new ArrayPerson(); int op; do { System.out.println("Ingrese un nombre:"); namePerson = sc.nextLine(); //Añadimos la referencia del objeto al arreglo ap.add(namePerson); System.out.println("Desea salir? Presione (-1)"); op = sc.nextInt(); sc.nextLine();//para limpiar el buffer stdin if(op == -1) break; }while(true); //Recorremos el arreglo con los elementos que tenga registrado el arreglo for(int i = 0; i != ap.getCount(); ++i) { System.out.println(ap.getPerson(i)); } }}

Conclusione:

In Java non è possibile aumentare la dimensione della disposizione, ma se è possibile prenotare la memoria per un nuovo blocco di memoria in cui copia gli elementi del vecchio blocco nel nuovo blocco e così come non fare O questa stessa procedura ogni volta che si desidera inserire un nuovo elemento in disposizione, lo facciamo quando la quantità di elementi supera la capacità massima dell’array (come la classe ArrayList).

Raccomandazione:

È sempre bene usare le classi che appartengono all’API Java, perché risparmiano lavoro, tuttavia, per scopi accademici, non sarebbe sbagliato implementare Le tue stesse classi.