Como Declarar, inicializar y el manejo de Arreglos en java

Declarar, inicializar y manejo de Arreglos en java desde 0

Para entender bien que es Declaración, Inicialización y manejo de arreglos (arrays), primero tenemos que entender bien a que llamamos arreglo (array).

Tenemos que tener claro que en programación las variables definen un tipo de dato que contienen y un valor que es el contenido real de esa variable.

Según el lenguaje de programación utilizado, el tipo de dato de la variable debe ser explicito o implícito. O sea, debe ser indicado (explicito) o pueder ser sobre entendido implícito.

En java, el tipo de dato es obligatoriamente explicito, en todos los casos a excepción de cierto tipo de variables llamadas colecciones, que en realidad variables de tipo objeto.

Y un objeto es un tipo de dato que a su vez posee datos de diferentes tipos, por lo que por favor no confundas, esto con un array normal, ya que en este caso los datos dentro de un objeto no son un array sino que son finitos y bien definidos igualmente como cualquier otra variable.

En programación los arreglos (arrays) no son mas que una forma especial de variable. Solo que en lugar de contener un solo valor, pueden albergar cierta cantidad de valores diferentes, de un mismo tipo de dato y con el mismo nombre de variable, pero un subíndice numérico distinto.

Digamos que un arreglo es una variable tipo arreglo cuya diferencia con una variable normal es que este tipo de variable comparte el mismo nombre y por lo general, y en java es estrictamente así, el mismo tipo de dato con otras variables del mismo nombre con la diferencia de que contiene un subíndice numérico entre paréntesis o corchetes que los diferencia unos de conjunto que tiene el mismo nombre.

Una variable normal seria, por ejemplo, la palabra dato.

Pero un arreglo seria dato[] o dato(), esto nos indica sin lugar a dudas de que estamos hablando de un array o arreglo de datos



Para entenderlo mejor pensemos en una variable normal, en la cual no tenemos que definir ningún número extra de casilleros, ya solo tiene un casillero y por tanto solo puede contener un solo valor.

Por ejemplo una variable para el nombre de una persona. Pues la variable valida y que nos indica a que dato nos referimos seria "nombre"

nombre ---- un casillero llamado "nombre" y dentro el valor "pepe" // variable tipo alfanumerico en java.

OJO, no olvides esta linea anterior, porque volverás a aquí de nuevo mas adelante a verificar la misma.

Ahora definiremos una variable para la edad. Pensaríamos en darle ese mismo nombre pero podemos escribir el que deseemos, siempre que conozcamos a que se refiere, y en este caso podemos poner numero
 
numero ---- un casillero llamado "numero" y dentro "13"    //  variable númerica en el caso de java

No porque la variable se llame nombre es alfabética, o sea solo letras.
Como tampoco numero indique que es numérica y acepta solo dígitos.

Este tipo de datos lo define el lenguaje que programación que utilicemos y en java debemos indicarlos explícitamente.

En Java es obligatorio declara el tipo de variable y su nombre, y esto es dificil de olvidar porque inmediatamente indica error si estas utilizando un IDE.

IDE (Integrated Development Environment) es el nombre dado a  los programas de Entorno de Desarrollo Integrados, que ayudan al programador a programar sus aplicaciones de forma mas amigable, indicándole en cada sentencia que escribe las mayoría de errores de sintaxis que se comenten a escribir programas.

Ahora, no nos distraigamos con otra cosa y sigamos estudiando lo de los arrays o arreglos

En un arreglo, tendríamos que usar un elemento de identificación del conjunto de casilleros que vamos a usar, que sería el nombre y le añadiremos unos corchetes"[ ]". Aunque existen lenguajes que usan los paréntesis"( )",en Java se usan los corchetes"[ ]".

Como se dijo antes esta variable tipo arreglo puede tener varios valores y no solo uno. Por lo tanto tendremos que buscar la cantidad de casilleros que necesitemos en función de la cantidad de valores numéricos o alfabéticos que vamos a guardar, según el tipo de datos que hubiéramos definido antes, sean estos alfabéticos o numéricos.

Supongamos por ejemplo que serán 4 los valores que pondremos y que los mismos serán alfabéticos.

Todos los casilleros tendrán el mismo nombre, pero además tendrán un número que los identifica individualmente, desde "0" hasta "3"

nombre[0] ---- "pepe";
nombre[1] ---- "ana";
nombre[2] ---- "nico";
nombre[3] ---- "eva";
 
Gráficamente tenemos esto:

Con el gráfico vemos que en una variable sin subíndice, no hay forma de poner sino un solo valor pepe, ana, nico o eva. En el ejemplo se puso pepe y no ha sido arbitrariamente.

Si volvemos atrás, vemos que hemos seguido una secuencia de un programa, y a la variable nombre en el renglón que definimos antes del OJO mas arriba marcado,  le habiamos asignamos el valor "pepe".

Que te dice esto?

Que la varialbe nombre sin subíndice es totalmente diferente a un arreglo llamado nombre[] o nombre() el cual deberá tener subíndices numéricos

Con lo visto llegamos a la conclusión, que básicamente la diferencia entre una variable normal y un arreglo, es que este ultimo maneja más valores bajo un mismo nombre con un subíndice, que representa un casillero para cada valor del array(arreglo) y que son diferentes a un variable del mismo nombre pero sin subíndice.

Las otras diferencias ya tiene que ver mas con el lenguaje que se utilice para manejar los arreglos, y uno de ellos es con que numero empiezan a identificar los casilleros.

Java los identifica desde "0", lo que significa que el primer elemento de un arreglo en Java será el casillero con el numero "0".

Vamos a ver un ejemplo de un arreglo donde en lugar de nombres tendrá números.


            numero[0] = 1;
            numero[1] = 2;
            numero[2] = 3;
            numero[3] = 4;



Si hasta ahora no se tiene claro que es un arreglo, pues hay que volver atrás y volver a leer hasta que se comprenda.

La razón es porque de aquí en adelante vamos a referirnos a como manejar los arreglos con el lenguaje Java.

Debemos saber que en Java los arreglos son finitos. Es decir, tienen un número definido de casilleros y una vez definido ya no se pueden añadir mas casillas.

Para preparar un arreglo en Java debemos primero declarar el arreglo, definir su tamaño (cuantos casilleros tendrá) y luego inicializarlo escribiendo en los casilleros el contenido de cada uno de ellos, incluyendo un valor vacío o null. 

Declarando un arreglo

Las formas de declarar arreglos en Java sería así:

// dos formas de declarar un arreglo (array) en Java
String[] nombre;   //tipo String

 
String nombre[];

int[] numero;    //tipo entero


int numero[];

Java es un lenguaje fuertemente tipado, lo que exige que toda variable, incluídos los arreglos (arrays) tengan un tipo definido de dato, al momento de declararse.

Hay una forma de declarar, asignar el tamaño, e inicializar un arreglo, en una sola sentencia, pero tenemos que tener los datos ya conocidos. Es la siguiente:

String[] nombre={"pepe","ana","nico","eva"};

Lo anterior, define el tamaño de cuatro casilleros del arreglo y coloca en cada casillero los strings "pepe","ana","nico","eva" en el siguiente orden 0 para "pepe", 1 para "ana", 2 para "nico" y 3 para "eva":

nombre[0] para "pepe" 
nombre[1] para "ana" 
nombre[2] para "nico" 
nombre[3] para "eva"


Cuando no tenemos los datos conocidos, lo que si debemos tener claro es cuantos casilleros necesitaremos, y como mínimo no quedarnos cortos, porque no importa que nos sobren uno o dos casilleros que queden vacíos, ya que el programa no se detendrá por eso, pero lo contrario si va darnos problemas.

Asignar el tamaño de un arreglo:

Tenemos las siguientes formas de asignar (crear) cuantos casilleros vamos a tener en un arreglo:

Previamente habiendo declarado el arreglo:

nombre = new String[4];  // Asigna cuatro casilleros de tipo string

numero = new int[10]; // Asigna diez casilleros de tipo int (entero)

Al momento de declarar el arreglo, podemos asignar el tamaño:

String[] nombre = new String[4];

int[] numero = new int[10]; 

La tercera forma vimos anteriormente y es la que engloba todo el proceso, declarar, asignar o definir el tamaño y añadir datos (contenido), en una sola sentencia, y vamos a repetir aquí de nuevo:

String[] nombre = {"pedro","pablo","vilma","betty"};

Añadiendo contenido a un arreglo

La forma de añadir contenido en un arreglo es igual a como se hace con cualquier variable:

nombre arreglo[numero-casillero] = valor a ser asignado

La parte tediosa de esto es que luego tenemos que ir asignando el valor correspondiente de cada casillero uno a uno, o sea, que para el arreglo nombre[] sería así:

nombre[0] = "pepe"; nombre[1] = "ana";
nombre[2] = "nico";
nombre[3] = "eva";

Otro forma es retomar los ejemplos que hemos dado anteriormente aquí , en donde la asignación del valor se hace a la hora de declarar el arreglo

Vamos a recordarlo otra vez:

String[] valores = {"10","20","30","40"};

Con lo anterior nos ahorramos unas cuantas lineas, y eso adecuado para cuando el arreglo que necesitemos, tenga una cantidad reducida de valores y que los mismos no cambien cambien su valor en el tiempo.

Pero que pasa si tenemos que añadir cien nombres? Ya no parece tan buena la sentencia anterior. Para esos casos ya tendríamos que pensar en un archivo que tenga guardado los nombres y luego utilizar un bucle for o while para recorrerlo e ir asignando uno a uno os valores al arreglo.

Vamos a ver un ejemplo pero no con un arreglo del tipo String, sino un arreglo del tipo int, con un bucle for.

Recordar, que hemos hecho antes la declaración y definición del tamaño del arreglo que llamaremos numeros.

int[] numeros=new numeros[100];

Ahora para asignar los valores del 1 al 100 usamos el bucle for.

Obtendremos una lista de números como la que sigue:

numeros[0] = 1
numeros[1] = 2
numeros[2] = 3
numeros[3] = 4
numeros[4] = 5
.....
.....
.....
.....
numeros[96] = 97
numeros[97] = 98
numeros[98] = 99
numeros[99] = 100



Como siempre si detectas algún error u omisión, o hacer una observación importante, por favor deja un comentario, para corregir, cambiar los conceptos que sean necesarios. Muchas Gracias por visitar mi blog.