Arreglos y La sentencia for mejorada.

Los Arreglos son estructuras de datos que consisten en elementos relacionados por el tipo de dato. Los arreglos son estructuras de longitud fija, una vez inicializado su tamaño este se mantiene como  una constante, aunque se puede reasignar una variable tipo arreglo que haga refencia a un arreglo de longitud distinta.

Los arreglos son conjuntos de variables todas del mismo tipo, Es necesario recordar en que Java existen dos tipos de datos; los primitivos y los de tipo por referencia. Los arreglos son objetos, por ende, son del tipo por referencia, en realidad un arreglo es una referencia a un objeto arreglo en memoria (es por ello que se le considera como tipo referenciado).
Para la creación de un arreglo debemos especificar un tipo de dato, un nombre y un [ ](corchete abierto y cerrado)

Los objetos o valores dentro de un arreglo se ubican a partir de su "indice" o "subindice". el subindice de un arreglo siempre comienza en 0, por ende un arreglo de tamaño 5, sera asi.

c[ 5 ] = c[0]  ,  c[1]  , c[2]  ,  c[3]  ,  c[4]

Como el arreglo es de tamaño 5 y el subindice siempre comienza en 0, el ultimo subindice siempre sera 1 menos que el tamaño del arreglo. en este ejemplo el arreglo es de tamaño 5 el ultimo subindice es 4.

EJ:

int arreglo1[ ]; también puede ser int [ ] arreglo1;

estas sentencias lo único que hacen es crear un arreglo de valores int llamado arreglo1. pero no lo inicializa, esta declaración seria equivalente a declarar una variable como int num1;
Para inicializar el arreglo tenemos tres posibles caminos; simplemente declarar el arreglo como en el ejemplo, después dimencionarlo y por ultimo inicializarlo;

int arreglo1[ ];   //crea el arreglo
arreglo1 = new int[ 5 ];  //dimensiona el arreglo con un tamaño 5
arreglo1[ 0 ] = 33; //inicializa el subindice 0 con un valor de 33

Otra manera  es

int arreglo2[ ] = {22,102,1,5,99}; //crea en arreglo y lo dimensiona pasandole valores.
este arreglo es de tamaño 5,

¿que valor tendría en este arreglo  arreglo2[ 1 ]; ?

R; 102.  recuerda que el sub-indice de un arreglo siempre comienza en 0, en este caso [0]=22,[1]=102, etc...

También se pueden haber inicializado los valores de uno en uno a través de sus sub-indices el mismo ejemplo.


int arreglo2[] = new arreglo[5]; //crea el arreglo y le da un tamaño inmediatamente
arreglo2[ 0 ] = 22; //inicializa el indice con un valor del mismo tipo de dato del arreglo.

arreglo2[ 1 ] = 102;

etc,,,

Al crear un arreglo y dimensionarlo, pero no asignarle valores a sus subindices, java automáticamente inicializa el arreglo con los valores predeterminados dependiendo de su tipo... recordar, como ya puse en una entrada anterior: int, short, long, double, byte en 0, char en null, boolean en false y todos los de referencia en null.
*dimensionar un arreglo en la forma int c[4]; produce un error de sintaxis.

Ej:

//crea un arreglo de tamaño 10 y dale valores al azar entre 1 y 100


1     import java.util.Random;
2
3     public class arreglos
4     {
5        public static void main(String[]args)
6    {
7         int arreglo1[] = new int[10]; //crea y dimensiona un arreglo de tamaño 10  
8         Random azar = new Random();  //crea un nuevo objeto random
9         for(int i = 0; i<arreglo1.length; i++)
10      {
11         int num = azar.nextInt(99)+1;
12         arreglo1[i] = num;
13      }//fin del ciclo for
14  
15      for(int x=0; x<arreglo1.length; x++)
16       {
17         System.out.println("el valor del indice ["+x+"] es de :"+arreglo1[x]);
18        }
19    }//fin del metodo main
20    }//fin de la clase



En la linea 7  creamos y dimensionamos un arreglo de valores int cuyo tamaño es 10, en la linea 8 instanciamos (o creamos) un objeto de la clase Random que nos permite usar sus métodos y variables, en este ejemplo solo usamos el método nextInt(), que recibe un argumento de tipo entero el que establece el numero máximo de los posibles números, acá le pasamos como argumento 99 y esto es porque el numero cuenta desde el 0 hasta el que le pasemos, como acá es 99 podría ser un numero desde 0 (incluyéndolo) hasta 99, Como el ejercicio establecía que debían ser numero del 1 al 100 se le suma 1 (azar.nextInt(99)+1;). así aunque salga 0 seria 1 y si sale 99 serian 100 respectivamente   y le pasamos ese valor a la variable num.

en la linea 9 creamos un ciclo for, el que va a iterar mientras que i = 0 sea menor que arreglo1.length
El metodo .length es propio de los arreglos y su función es devolver el largo del arreglo, en este caso 10. es por eso que en el encabezado del for pongo que debe iterar hasta que sea menor que <arreglo1.length pues el i inicia en 0 (si dejaramos que iterara hasta que fuera menor o igual, en total daría 11 vueltas y nos daría un error Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: este es un arror por intentar llegar a un indice que noe sta en el arreglo, por ejemplo tenemos un arreglo de tamaño 10 e intentamos acceder al subindice 10, recordar que en un arreglod e tamaño 10 el ultimo subindice es 9 ). si el i iniciara en 1 entonces seria correcto poner <= .
en la linea 12 se realiza el "llenado del arreglo" ponemos arreglo1[ i ] para que vaya llenando el arreglo conforme itera el arreglo. así como en la primera vuelta i vale 0, se inicializa el subindice 0 del arreglo con algún valor al azar entregado por nexInt(99)+1
finalmente en la linea 15 crea otro ciclo for que iterara a traves del arreglo para mostrar sus valores.

La sentencia for mejorada

La instrucción for mejorada nos permite iterar a través de un arreglo o colección sin la necesidad de un contador, con lo que se evita la posibilidad de salir mas allá de los limites del arreglo.

su sintaxis es:

for(parametro : nombrearreglo)
{
instrucción
}

el parametro es una variable no inicializada del mismo tipo del arreglo, por ejemplo int. nombre arreglo es el nombre del arreglo sin los corchetes [ ]
//suma los elementos de un arreglo

int valores[ ] = {2,33,42,99,1};
int suma = 0;
for(int iterador : valores)
{
suma+=iterador;
}
System.out.println("El total de sumar los elementos del arreglo es : "+suma);

la variable iterador no se inicializa pues en este tipo de for realiza las veces de valor provisorio, por ejemplo en la primera vuelta, iterador toma el valor del elemento 0 del arreglo valores, así según este ejemplo en la primera vuelta iterador = 2, en la segunda iterador = 33 etc...

La sentencia for mejorada es util cuando debemos iterar sobre elementos de un arreglo pero no modificaros  tampoco se puede hacer referecia al iterador como se haria con uno en una sentencia for normal, ya que en este tipo de declaración el iterador no toma los valores 0, 1, 2... sino los valores de los elementos de arreglo, como recién dije..

Arreglos Multidimensionales


Los arreglos multidimensionales de dos dimensiones se utilizan con frecuencia para representar tablas de valores, las cuales consisten en información ordenada en fi las y columnas. Para identificar un elemento específico de una tabla, debemos especifi car dos subíndices. Por convención, el primero identifica la fi la del elemento y el segundo su columna. Los arreglos que requieren dos subíndices para identifi car un elemento específico se llaman arreglos bidimensionales (los arreglos multidimensionales pueden tener más de dos dimensiones). Java no soporta los arreglos multidimensionales directamente, pero permite al programador especificar arreglos unidimensionales, cuyos elementos sean también arreglos unidimensionales, con lo cual se obtiene el mismo efecto.
En general, a un arreglo con m fi las y n columnas se le llama arreglo de m por n.
Cada elemento en el arreglo a se identifica en la fi gura 7.16 mediante una expresión de acceso a un arreglo de la forma a [ fila ][ columna ]; a es el nombre del arreglo, fila y columna son los subíndices que identifi can
en forma única a cada elemento en el arreglo a por número de fila y columna.

imagen de "como programar en java". Deitel y Deitel

Arreglos de arreglos unidimensionales
Al igual que los arreglos unidimensionales, los arreglos multidimensionales pueden inicializarse mediante inicializadores
de arreglos en las declaraciones. Un arreglo bidimensional b con dos fi las y dos columnas podría declararse
e inicializarse con inicializadores de arreglos anidados, como se muestra a continuación:
int b[ ] [ ] = { { 1, 2 }, {3, 4} };
Los valores del inicializador se agrupan por fi la entre llaves. Así, 1 y 2 inicializan a b[ 0 ][ 0 ] y b[ 0 ][ 1 ],
respectivamente; 3 y 4 inicializan a b[ 1 ][ 0 ] y b[ 1 ][ 1 ], respectivamente. El compilador cuenta el número
de inicializadores de arreglos anidados (representados por conjuntos de llaves dentro de las llaves externas) en
la declaración del arreglo, para determinar el número de fi las en el arreglo b. El compilador cuenta los valores
inicializadores en el inicializador de arreglos anidado de una fi la, para determinar el número de columnas en esa
fi la. Como veremos en unos momentos, esto signifi ca que las fi las pueden tener distintas longitudes.
Los arreglos multidimensionales se mantienen como arreglos de arreglos unidimensionales. Por lo tanto, el
arreglo b en la declaración anterior está realmente compuesto de dos arreglos unidimensionales separados: uno que contiene los valores en la primera lista inicializadora anidada { 1, 2 } y uno que contiene los valores en la segunda lista inicializadora anidada { 3, 4 }. Así, el arreglo b en sí es un arreglo de dos elementos, cada uno de los cuales es un arreglo unidimensional de valores int.

Arreglos bidimensionales con filas de distintas longitudes
La forma en que se representan los arreglos multidimensionales los hace bastante flexibles. De hecho, las longitudes de las filas en el arreglo b no tienen que ser iguales. Por ejemplo,
int b[ ][ ] = { { 1, 2 }, { 3, 4, 5 } };
crea el arreglo entero b con dos elementos (los cuales se determinan según el número de inicializadores de arreglos anidados) que representan las fi las del arreglo bidimensional. Cada elemento de b es una referencia a un arreglo unidimensional de variables int. El arreglo int de la fi la 0 es un arreglo unidimensional con dos elementos (1 y 2), y el arreglo int de la fi la 1 es un arreglo unidimensional con tres elementos (3, 4 y 5).
Creación de arreglos bidimensionales mediante expresiones de creación de arreglos
Un arreglo multidimensional con el mismo número de columnas en cada fila puede crearse mediante una expresión de creación de arreglos. Por ejemplo, en las siguientes líneas se declara el arreglo b y se le asigna una referencia a un arreglo de tres por cuatro:
int b[ ][ ] = new int[ 3 ][ 4 ];

En este caso, utilizamos los valores literales 3 y 4 para especificar el número de filas y columnas, respectivamente, pero esto no es obligatorio. Los programas también pueden utilizar variables para especificar las dimensiones de los arreglos, ya que new crea arreglos en tiempo de ejecución, no en tiempo de compilación. Al igual que con los arreglos unidimensionales, los elementos de un arreglo multidimensional se inicializan cuando se crea el objeto arreglo.
Un arreglo multidimensional, en el que cada fila tiene un número distinto de columnas, puede crearse de la
siguiente manera:
int b[][] = new int[ 2 ][ ]; // crea 2 filas
b[ 0 ] = new int[ 5 ]; // crea 5 columnas para la fila 0
b[ 1 ] = new int[ 3 ]; // crea 3 columnas para la fila 1


ejemplo:


import java.util.Random;

public class arreglos
{
    public static void main(String[]args)
    {
    int arreglo1[][]={{3,44,55},{4,32,54}};
    for(int fila=0; fila<arreglo1.length;fila++)
    {
    for(int columna=0; columna<arreglo1[fila].length;columna++){
    System.out.printf("%d ",arreglo1[fila][columna]);
    }
        System.out.println("");
    }
    }//fin del metodo main
}//fin de la clase