Com es pot canviar la mida d’un array?

Com es pot canviar la mida d’un array?

La resposta és un NO. En Java no es pot canviar la mida d’un arranjament.

Però abans d’explicar el perquè, necessitem tenir clar que significa canviar la mida d’un arranjament.

Mirem la següent imatge:

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

a la imatge tenim a del principi un arranjament de 5 elements de tipus integer però després es vol augmentar 6 espais de memòria en l’arranjament. Llavors, canviar la mida d’un array simplement vol dir augmentar o disminuir la quantitat d’espais de memòria que té un arranjament. En el nostre bloc de memòria de dalt s’està augmentant la mida de l’arranjament de 5 a 11 elements, però, es conservarà el mateix bloc de memòria sempre que després de l’últim element de l’arranjament no hi hagi un espai de memòria ocupat, ja que si això arribés a passar s’hauria de reservar un nou bloc de memòria i després s’hauria de copiar els elements de el bloc antic a el nou.

Ja, … ¿perquè raigs vaig esmentar tot l’anterior?

perquè per aconseguir canviar la mida d’un arranjament es necessita d’una funció / rutina que pugui augmentar o disminuir la quantitat de elements d’un bloc de memòria. En Java no existeix tal mètode, però, en altres llenguatges de programació com a llenguatge C, si té tal funció i es diu realloc.

Per què en Java no es pot canviar la mida d’un array?

Perquè no té una funció com realloc, en cas contrari, si es pogués redimensionar un arranjament.

També recalco que moltes persones creuen que redimensionar un arranjament significa crear un nou arranjament i copiar els elements de l’anterior acord en el nou, però, això és incorrecte. Un gran exemple és el mètode Resize de C #, qualsevol pensaria que redimensiona un arranjament, però en realitat no és així, fa el mateix procediment que havia esmentat anteriorment. El nom de l’mètode és enganyós.

Redimensionar un arranjament significa canviar la mida de l’arranjament però conservant el mateix bloc de memòria (on estan allotjats els elements de l’arranjament).

Ara, una solució senzilla per poder registrar noms de persones sense preocupar-nos de la mida de l’arranjament, és usant la classe ArrayList i d’aquesta manera, podràs crear una llista d’objectes de tipus String.

Per exemple:

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

la classe ArrayList la van implementar a través d’un vector / arranjament dinàmic, això vol dir, que quan crees un objecte de tipus ArrayList:

List<String> listPerson = new ArrayList<String>();

En realitat el constructor d’aquesta classe s’encarrega de crear l’arranjament dinàmic amb una capacitat inicial (codi font de ArrayList) de 10 elements, això ens diu que internament aquesta classe té la referència d’un arranjament per a X elements però que encara no té cap a referència d’un objecte (per aquesta raó si el mètode size () s’arribés a executar hauria de donar com a resultat 0 elements).

No obstant això, la classe ArrayList no augmenta la mida de l’arranjament dinàmic on està emmagatzemada les referències de cada objecte, per tant, quan la quantitat d’objectes superi la capacitat màxima de la llista, el que passarà és que es reservarà memòria per a un nou arranjament, en la qual es copiarà els elements de el bloc antic al nou bloc de memòria.

Llavors si el teu professor no et deixés fer servir la classe ArrayList, podries crear la teva pròpia classe en la qual s’encarregui d’emular la implementació d’un ArrayList.

Per exemple:

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

Bàsicament aquesta classe quan la arribis a instanciar, et dóna l’oportunitat d’executar un constructor parametritzat o per defecte.

Si executem el constructor parametritzat:

• Crearà un arranjament d’objectes amb una grandària que dependrà de la valor que tingui el paràmetre de constructor.

Si executem el constructor per defecte (sense paràmetres):

• crearà un arranjament d’objectes amb una mida predeterminat (amb una capacitat inicial màxima de 10 elements).

Ara ve la part més interessant, el mètode add.Aquest mètode bàsicament s’encarregarà d’afegir una referència (direcció de memòria) en X posició de l’arranjament d’objectes, però, quan la quantitat d’objectes superi la capacitat màxima de l’arranjament, es calcularà una nova capacitat i es farà servir el mètode CopyOf de la classe Arrays i el que fa aquest mètode és reservar memòria per a un nou arranjament d’objectes, en la qual copiarà els elements de el bloc antic al nou bloc de memòria i el que retorna aquest mètode és la referència d’un objecte de tipus String en la qual internament haurà la referència de l’arranjament d’objectes (amb una mida d’elements ja actualitzat).

la forma d’usar aquesta classe seria d’aquesta manera:

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

Conclusió:

En Java no es pot augmentar la mida de l’arranjament, però si es pot reservar memòria per a un nou bloc de memòria en la qual copiem els elements de el bloc antic al bloc nou i per no estar haciend o aquest mateix procediment cada vegada que es vulgui inserir un nou element a l’arranjament, ho fem quan la quantitat d’elements superi la capacitat màxima de l’arranjament (tal com ho fa la classe ArrayList).

Recomanació:

Sempre és bo fer servir les classes que pertanyin a l’API de Java, a causa que, estalvia treball, però, per a fins acadèmics, no estaria malament en implementar els teus pròpies classes.