Como pode cambiar o tamaño dunha matriz?

Como Pode cambiar o tamaño dunha matriz?

A resposta é a non. En Java non pode cambiar o tamaño dun arranxo.

Pero antes de explicar por que, necesitamos quedar claro que significa cambiar o tamaño dun arranxo.

Vexamos A seguinte imaxe:

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

Na imaxe que nós Ten ao comezo un arranxo de 5 tipos de elementos integer pero entón quere aumentar 6 espazos de memoria no arranxo. A continuación, cambiar o tamaño dunha matriz simplemente significa aumentar ou diminuír o número de espazos de memoria que ten un arranxo. No noso bloque de memoria upstream, o tamaño da matriz de a 11, con todo, o mesmo bloque conservarase a memoria tanto Como despois do último elemento de arranxo non hai espazo de memoria ocupado, xa que se isto ocorre, debe ser reservado un novo bloque de memoria e, a continuación, os elementos do bloque antigo deben ser copiados ao novo.

xa,. .. Para os raios que mencionei todo o anterior?

Por que conseguir o tamaño dun arranxo é necesario unha función / rutina que pode aumentar ou diminuír a cantidade de elementos dun bloque de memoria. En Java non hai ningún método, con todo, noutras linguaxes de programación como lingua C, se ten esa función e chámase realloc.

Por que non pode cambiar o tamaño dunha matriz?

Por que non ten unha función como realloc, se non, se un arranxo pode ser redimensionado.

Tamén saliento que moitas persoas cren que o tamaño dun arranxo significa crear un novo arranxo e copiar o arranxo Elementos do arranxo anterior no novo, con todo, iso é incorrecto. Un gran exemplo é o método redimensionado de C #, alguén pensaría que redimensiona un arranxo, pero en realidade non é así, fai o mesmo procedemento que mencionara anteriormente. O nome do método é engañoso.

Redimensionar un arranxo significa cambiar o tamaño do arranxo pero preservar o mesmo bloque de memoria (onde se aloxan os elementos de matriz).

Agora, a Solución sinxela para poder rexistrar nomes de persoas inevitantes do tamaño do arranxo, está a usar a clase Arraylist e deste xeito, pode crear unha lista de tipo .

Por exemplo:

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

clase implementalo a través dun arranxo vectorial / dinámico, isto significa , que cando creas un obxecto de tipo ArrayList:

en realidade o constructor deste tipo é responsable para crear o arranxo dinámico cunha capacidade inicial (código fonte de arraylist) de elementos

, isto nos di que internamente esta clase ten a referencia dun acordo para os elementos X, pero non ten calquera Referencia dun obxecto (por ese motivo se se executará o método de tamaño (), debería resultar en0).

Con todo, a clase ArrayList non aumenta o tamaño do arranxo dinámico onde se almacenan as referencias de cada obxecto, polo tanto, cando o número de obxectos supera a máxima capacidade da lista, que vai ocorrer é que a memoria será reservar para un novo arranxo, no que os elementos do antigo bloque serán copiados no novo bloque de memoria.

Entón, se o seu profesor non lle permitirá usar a clase ArrayList, pode crear a súa propia clase na que é responsable de emular a implementación dun ArrayList.

Por exemplo:

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

Basicamente esta clase cando chegue ao instante, dálle a oportunidade de executar un constructor parametrizado ou por defecto.

Se executamos o constructor parametrizado :

• creará Un arranxo de obxectos cun tamaño que dependerá do valor do parámetro do constructor.

Se executamos o constructor por defecto (sen parámetros):

• Creará un arranxo de obxectos cun tamaño predeterminado (cunha capacidade máxima inicial de 10).

Agora vén a parte máis interesante, o Método add.Este método basicamente será responsable de engadir unha referencia (enderezo de memoria) na posición X do conxunto de obxectos, con todo, cando o número de obxectos supera a capacidade máxima de capacidade, calcularase unha nova capacidade e o método de copia da clase Arrays e que fai este método é reservar memoria para unha nova disposición de obxectos, en que copiará os elementos do bloque antigo no novo bloque de memoria e que este método devolve é o referencia dun obxecto de tipo String no que a referencia dos obxectos (cun tamaño de elemento actualizado) será internamente.

A forma de usar esta clase sería Sexa así:

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ón:

En Java non pode aumentar o tamaño do arranxo, pero se pode reservar a memoria Para un novo bloque de memoria no que copias os elementos do antigo bloque no novo bloque e para non facer Ou este mesmo procedemento cada vez que queira inserir un novo elemento en arranxo, o facemos cando a cantidade de elementos supera a capacidade máxima da matriz (como a clase ArrayList).

Recomendación:

É sempre bo usar as clases que pertencen á API de Java, porque, salva o traballo, con todo, para fins académicos, non estaría mal a implementar as túas propias clases.