UNIVERSIDAD DE CARTAGENA

INGENIERÍA DE SOFTWARE
Unidad 2

ASIGNATURA:
ESTRUCTURA DE DATOS - C1

TUTORA: DOMINGO GALEANO PUCHE

ESTUDIANTE:
JOSE ANDRES AYCARDI GALINDO

CERETE – CORDOBA
14/09/2019
 Actividad 2

 Cuales son y para que se utilizan los Métodos definidos por Vector

Para usar la clase Vector hemos de poner al principo del archivo del código fuente la
siguiente sentencia import

import java.util.*;

Cuando creamos un vector u objeto de la clase Vector, podemos especificar su dimensión

inicial, y cuanto crecerá si rebasamos dicha dimensión.

Vector vector=new Vector(20, 5);

Tenemos un vector con una dimensión inicial de 20 elementos. Si rebasamos dicha

dimensión y guardamos 21 elementos la dimensión del vector crece a 25.

Al segundo constructor, solamente se le pasa la dimensión inicial.

Vector vector=new Vector(20);

Si se rebasa la dimensión inicial guardando 21 elementos, la dimensión del vector se

duplica. El programador ha de tener cuidado con este constructor, ya que si se pretende
guardar un número grande de elementos se tiene que especificar el incremento de la
capacidad del vector, si no se quiere desperdiciar inútilmente la memoria el ordenador.

Con el tercer constructor, se crea un vector cuya dimensión inicial es 10.

Vector vector=new Vector();

La dimensión del vector se duplica si se rebasa la dimensión inicial, por ejemplo, cuando se
pretende guardar once elementos.

 Uso de Array de caracteres y cadenas de texto (String y StringBuffer).

Mencione además con que métodos puede trabajar cada una
Una cadena es una secuencia de caracteres. Las cadenas son una parte fundamental de
la mayoría de los programas, así pues Java tiene varias características incorporadas que
facilitan la manipulación de cadenas. Java tiene una clase incorporada en el paquete
java.lang que encapsula las estructuras de datos de una cadena. Esta clase, llamada String
es la representación como objeto de una matriz de caracteres que no se puede cambiar.
Hay una clase que la acompaña, llamada StringBuffer, que se utiliza para crear cadenas
que pueden ser manipuladas después de ser creadas.
String y StringBuffer
El paquete java.lang contiene dos clases de cadenas: String y StringBuffer. La clase String
se utiliza cuando se trabaja con cadenas que no pueden cambiar. Por otro lado,
StringBuffer, se utiliza cuando se quiere manipular el contenido de una cadena. El entorno
de desarrollo Java proporciona dos clases para manipular y almacenar datos del tipo
carácter: String, para cadenas constantes, y StringBuffer, para cadenas que pueden
cambiar.
Como son constantes, los Strings son más económicos (utilizan menos memoria) que los
StringBuffers y pueder ser compartidos. Por eso es importante utilizar String siempre que
sea apropiado.

 ¿Cómo Copiar y Comparar Arreglos en Java?

Forma correcta de copiar un array

Existen varias formas para poder realizar la copia de una array, utilizando un bucle que
recorra el primer array e ir asignando los valores al segundo, utilizando el método estático
arraycopy que está contenido en la clase System y por último utilizando el método clone,
sin embargo este último es un poco más avanzado de lo que estamos viendo acá.

Muchas veces nos vamos a encontrar ante la disyuntiva de tener que copiar los elementos
de un array en otros. Normalmente será para manipular el contenido del mismo guardando
en uno de los arrays los datos originales.
Asumida ya la situación, lo primero que se nos ocurriría, independientemente del lenguaje
en el que nos encontremos, será el montar un algoritmo que recorriendo el
primer array vaya copiando dichos elementos en el segundo.

En Java nos quedaría un código como este:

1. for (int x=0;x<aOrigen.length;x++)

2. aDestino[x] = aOrigen[x];

En este sentido nada que objetar, ya que es muy buena práctica de programación. Pero
todo buen programador tiene que tener en mente el concepto de "reutilización". No
"reutilización" cómo copia (o fusilamiento -argot de muchos programadores-) del código.
Sino "reutilización" pensando en que alguien ya puede haberse encontrado el problema y
haberle dado ya una solución.
Para poder reutilizar tenemos que ser conscientes de lo que el entorno en el que estamos
nos ofrece. Y en el caso de Java, es la librería del sistema la que nos ofrece una función
para la copia de arrays. Como vemos en el siguiente código:
 1. System.arrayCopy(aOrigen,inicioArrayOrigen,aDestino,
2. inicioArrayDestino,numeroElementosACopiar);

Hay que tener cuidado la función arrayCopy ya que esta nos puede devolver las siguientes
excepciones: IndexOutOfBoundsException si intentamos copiar fuera del área reservado
para el array, ArrayStoreException si intentamos copiar arrays de diferente tipo
o NullPointerException si alguno de los array es nulo (vamos, no inicializado).

Al trabajar con arrays de tipos primitivos o de objetos se nos puede plantear la necesidad
de copiar arrays. La copia de arrays está permitida pero conviene ser cauto cuando
realicemos procesos de este tipo. Recordar que un array es un objeto (aunque sea especial)
y por tanto la variable que lo nombra en realidad contiene un puntero al objeto, no el objeto
en sí mismo.

Al hacer una operación del tipo array1 = array2, el puntero de array1 apunta al mismo objeto
que array2 mientras que el objeto al que apuntaba array1 queda inaccesible. A partir de ese
momento existe identidad entre los arrays y la comparación usando == nos devolverá true.
A través de código, vamos a plantearnos distintas situaciones y a comentar cuáles son los
resultados.

EJERCICIO EJEMPLO RESUELTO 1. COPIAR ESTABLECIENDO UNA RELACIÓN DE

IDENTIDAD ENTRE ARRAYS (aplicable a arrays de tipos primitivos y a arrays de
objetos)

//Test de copia de arrays aprenderaprogramar.com

public class TestCopiaArrays {
public static void main (String [ ] Args) {
int [ ] miArray1 = {2, -4, 3, -7};
for (int i=0; i<miArray1.length; i++) {
System.out.print ("miArray1[" + i +"]= " + miArray1[i]+"; ");
}
System.out.println("");
int [ ] otroArray = {1, 2, 4, 8};
for (int i=0; i<otroArray.length; i++) {
System.out.print ("otroArray[" + i +"]= " + otroArray[i]+"; ");}
System.out.println("");
 System.out.println ("¿Son el mismo objeto? ... " + (miArray1==otroArray)
);
System.out.println("");
otroArray = miArray1; //otroArray pasa a ser el mismo objeto que
miArray1
for (int i=0; i<otroArray.length; i++) {
System.out.print ("otroArray[" + i +"]= " + otroArray[i]+"; ");}
System.out.println("");
System.out.println ("¿Son el mismo objeto? ... " + (miArray1==otroArray)
);
} //Cierre del main
} //Cierre de la clase

Trata de predecir tú mismo el resultado y compáralo con el que ofrecemos. Resultado:

miArray1[0]= 2; miArray1[1]= -4; miArray1[2]= 3; miArray1[3]= -7;

otroArray[0]= 1; otroArray[1]= 2; otroArray[2]= 4; otroArray[3]= 8;
¿Son el mismo objeto? ... false
otroArray[0]= 2; otroArray[1]= -4; otroArray[2]= 3; otroArray[3]= -7;
¿Son el mismo objeto? ... true

EJERCICIO EJEMPLO RESUELTO 2. INTENTO DE COMPARAR ARRAYS (RELACIÓN

DE IGUALDAD)

Supongamos que queremos comparar la igualdad entre dos arrays. Una idea (mala idea)
podría ser aplicar el método equals directamente sobre el array. Un código de prueba podría
ser este:

//Test uso incorrecto de equals aprenderaprogramar.com

public class TestUsoIncorrectoEquals {
public static void main (String [ ] Args) {
 int [ ] miArray1 = {2, -4, 3, -7};
for (int i=0; i < miArray1.length; i++) {
System.out.print ("miArray1[" + i +"]= " + miArray1[i]+"; ");
}
System.out.println();
int [ ] otroArray = {2, -4, 3, -7};
for (int i=0; i < otroArray.length; i++) {
System.out.print ("otroArray[" + i +"]= " + otroArray[i]+"; ");
}
System.out.println ("¿Son el mismo objeto? ... " + (miArray1==otroArray) );
System.out.println ("¿Tienen el mismo contenido (relación de igualdad)? ... " +
(miArray1.equals(otroArray) ) );
otroArray = miArray1; //otroArray pasa a ser el mismo objeto que miArray1
for (int i=0; i<otroArray.length; i++) { System.out.print ("otroArray[" + i +"]= " + otroArray[i]+"; "); }
System.out.println ("¿Son el mismo objeto? ... " + (miArray1==otroArray) );
System.out.println ("¿Tienen el mismo contenido (relación de igualdad)? ... " +
(miArray1.equals(otroArray) ) );
} //Cierre del main
} //Cierre de la clase

Trata de predecir tú mismo el resultado y compáralo con el que ofrecemos. Resultado:

miArray1[0]= 2; miArray1[1]= -4; miArray1[2]= 3; miArray1[3]= -7;

otroArray[0]= 2; otroArray[1]= -4; otroArray[2]= 3; otroArray[3]= -7; ¿Son el mismo objeto? ...
false
¿Tienen el mismo contenido (relación de igualdad)? ... false
otroArray[0]= 2; otroArray[1]= -4; otroArray[2]= 3; otroArray[3]= -7; ¿Son el mismo objeto? ...
true
¿Tienen el mismo contenido (relación de igualdad)? ... true

Con este ejemplo comprobamos que el método equals aplicado directamente sobre arrays
no funciona ya que en el primer caso teniendo el mismo contenido nos dice que la relación
de igualdad es falsa. ¿Por qué? Porque ya dijimos en su momento que los arrays son unos
objetos especiales que no tienen una clase que los implemente. Si no tienen clase, no tienen
métodos (al menos directamente), y el método que se aplica es el usado por defecto por
Java con resultados imprevisibles o no deseados. La solución para comparar arrays es usar
otra clase que permite realizar operaciones con arrays. Esta clase es la clase Arrays. Una
vez más la terminología Java nos puede inducir a confusión: hablamos de array como
colección de tipos primitivos u objetos, y al mismo tiempo Arrays (con mayúsculas) es el
nombre de una clase Java que sirve para manipular arrays.

 Uso de la Clase arrays del API de Java

3. En la documentación de la clase Arrays del API de Java podemos encontrar, entre

otras cosas, lo siguiente:
4. java.util
5. Class Arrays
6. java.lang.object
7. |------ java.util.Arrays
8.
9.
10.
11. Esta clase contiene varios métodos para manipular arrays (por ejemplo para
ordenar un array o buscar un valor u objeto dentro de él) y para comparar arrays.
12. Dado que pertenece al package util, para poder usar esta clase habremos de incluir
en cabecera import java.util.Arrays; o bien import java.util.*;. Al igual que los arrays
son unos objetos que hemos dicho son especiales (al carecer de métodos),
podemos decir que la clase Arrays es una clase un tanto especial por cuanto carece
de constructor. Digamos que directamente al cargar la clase con la sentencia
import correspondiente automáticamente se crea un objeto denominado Arrays que
nos permite realizar manipulaciones con uno o varios arrays (p. ej. ordenar un array,
comparar dos arrays, etc.). Dicho objeto podemos utilizarlo directamente: no es
necesario declararlo ni crearlo, eso es automático en Java, y por eso decimos que
esta clase es una clase especial. La clase Arrays tiene muchos métodos, entre ellos
varios métodos equals (sobrecarga del método) que hacen que equals sea aplicable
tanto a arrays de los distintos tipos primitivos como a arrays de objetos. En concreto
el método aplicable a arrays de enteros primitivos es:

static boolean equals (int[ ] a,int[ ] a2)

Devuelve true si los dos arrays especificados tienen relación de igualdad

entre sí.

13.
14.
15. Vamos a aplicar este método para comparar el contenido de dos arrays de enteros
(relación de igualdad). La aplicación al resto de tipos primitivos y objetos es análoga.
La sintaxis en general es: Arrays.equals (nombreArray1, nombreArray2).
16.
17.
18. EJERCICIO EJEMPLO RESUELTO 3. COMPARAR ARRAYS (RELACIÓN DE
IGUALDAD) USANDO LA CLASE ARRAYS
import java.util.Arrays;
//Test comparar arrays relación de igualdad aprenderaprogramar.com
public class TestCompararArrays {
public static void main (String [ ] Args) {
int [ ] miArray1 = {2, -4, 3, -7};
for (int i=0; i<miArray1.length; i++) {
System.out.print ("miArray1[" + i +"]= " + miArray1[i]+"; ");}
System.out.println ("");
int [ ] otroArray = {2, -4, 3, -7};
for (int i=0; i<otroArray.length; i++) {
System.out.print ("otroArray[" + i +"]= " + otroArray[i]+"; ");}
System.out.println ("¿Son el mismo objeto? ... " + (miArray1==otroArray) );
System.out.println ("¿Tienen el mismo contenido (relación de igualdad)? ... " + Arrays.equals(miArray1,
otroArray) );
otroArray = miArray1; //otroArray pasa a ser el mismo objeto que miArray1
for (int i=0; i<otroArray.length; i++) { System.out.print ("otroArray[" + i +"]= " + otroArray[i]+"; "); }
System.out.println ("¿Son el mismo objeto? ... " + (miArray1==otroArray) );
System.out.println ("¿Tienen el mismo contenido (relación de igualdad)? ... " + Arrays.equals(miArray1,
otroArray) );
} //Cierre del main
} //Cierre de la clase

19.
20.
21. Trata de predecir tú mismo el resultado y compáralo con el que ofrecemos.
Resultado:

miArray1[0]= 2; miArray1[1]= -4; miArray1[2]= 3; miArray1[3]= -7;

otroArray[0]= 2; otroArray[1]= -4; otroArray[2]= 3; otroArray[3]= -7; ¿Son el mismo objeto? ...
false
¿Tienen el mismo contenido (relación de igualdad)? ... true
otroArray[0]= 2; otroArray[1]= -4; otroArray[2]= 3; otroArray[3]= -7; ¿Son el mismo objeto? ...
true
¿Tienen el mismo contenido (relación de igualdad)? ... true

22.
23.
24. El resultado ahora sí es correcto, porque hemos usado correctamente la clase
Arrays para realizar la comparación entre dos arrays.
25.
26.
 27. EJERCICIO EJEMPLO RESUELTO 4. COPIAR CONTENIDOS ENTRE ARRAYS
SIN ESTABLECER RELACIÓN DE IDENTIDAD ( “manual”, aplicable a tipos
primitivos y a objetos).
28. Antes vimos cómo asignar el contenido de un array a otro haciendo que la variable
apunte al mismo objeto. Vamos a ver ahora cómo copiar el contenido entre dos
arrays pero manteniendo que cada variable denominadora del array apunte a un
objeto diferente:

import java.util.Arrays;
//Test copia arrays con igualdad sin identidad aprenderaprogramar.com
public class TestCopiaConIgualdadSinIdentidad {
public static void main (String [ ] Args) {
int [ ] miArray1 = {2, -4, 3, -7};
for (int i=0; i<miArray1.length; i++) {
System.out.print ("miArray1[" + i +"]= " + miArray1[i]+"; ");}
System.out.println();

int [ ] otroArray = {1, 2, 4, 8};

for (int i=0; i<otroArray.length; i++) {
System.out.print ("otroArray[" + i +"]= " + otroArray[i]+"; ");}

System.out.println ("¿Son el mismo objeto? ... " + (miArray1==otroArray) );

System.out.println ("¿Tienen el mismo contenido (relación de igualdad)? ... " + Arrays.equals(miArray1,
otroArray) );

//Realizamos una asignación elemento a elemento

for (int i=0; i < otroArray.length; i++) {
otroArray[i] = miArray1[i];}
for (int i=0; i < otroArray.length; i++) {
System.out.print ("otroArray[" + i +"]= " + otroArray[i]+"; ");}

System.out.println ("¿Son el mismo objeto? ... " + (miArray1==otroArray) );

System.out.println ("¿Tienen el mismo contenido (relación de igualdad)? ... " + Arrays.equals(miArray1,
otroArray) );
} //Cierre del main
} //Cierre de la clase

29.
30.
31. Trata de predecir tú mismo el resultado y compáralo con el que ofrecemos.
Resultado:
 miArray1[0]= 2; miArray1[1]= -4; miArray1[2]= 3; miArray1[3]= -7;
otroArray[0]= 1; otroArray[1]= 2; otroArray[2]= 4; otroArray[3]= 8; ¿Son el mismo objeto? ...
false
¿Tienen el mismo contenido (relación de igualdad)? ... false
otroArray[0]= 2; otroArray[1]= -4; otroArray[2]= 3; otroArray[3]= -7; ¿Son el mismo objeto? ...
false
¿Tienen el mismo contenido (relación de igualdad)? ... true

32.
33.
34. EJERCICIO EJEMPLO RESUELTO 5. COPIAR CONTENIDOS ENTRE ARRAYS
SIN ESTABLECER RELACIÓN DE IDENTIDAD (Usando el método copyOf de la
clase Arrays, aplicable a tipos primitivos y a objetos).
35. El método copyOf de la clase Arrays nos permite:
36. a) Copiar un array manteniendo el número de elementos.
37. b) Copiar un array agrandando el número de elementos que tiene, quedando los
nuevos elementos rellenos con valores cero o nulos.
38. c) Copiar un array empequeñeciendo el número de elementos que tiene; los
elementos que no caben en el nuevo array, dado que tiene menor capacidad, se
pierden (el array queda truncado).
39.
40. copyOf es un método sobrecargado. En el caso de arrays de enteros su signatura
es la siguiente:

static int[ ] copyOf (int[ ] original, int newLength)

Copia el array especificado, truncando o rellenando con ceros (si fuera necesario)
de manera que la copia tenga el tamaño especificado.

41.
42.
43. Para el resto de tipos primitivos su sintaxis es análoga: Arrays.copyOf
(nombreDelArray, n) siendo n un entero que define la nueva longitud del array (n
puede ser mayor, menor o igual que la longitud del array original). El código de
ejemplo sería este (usamos el copyOf sin variar la longitud del array):

import java.util.Arrays;
//Test uso de copyOf método clase Arrays aprenderaprogramar.com
public class TestUso_copyOf_1 {
public static void main (String [ ] Args) {
int [ ] miArray1 = { 2, -4, 3, -7 };
for (int i=0; i<miArray1.length; i++) {
System.out.print ("miArray1[" + i +"]= " + miArray1[i]+"; ");
}
 System.out.println ("");
int [ ] otroArray = { 1, 2, 4, 8 };
for (int i=0; i<otroArray.length; i++) {
System.out.print ("otroArray[" + i +"]= " + otroArray[i]+"; ");
}
System.out.println ("¿Son el mismo objeto? ... " + (miArray1==otroArray) );
System.out.println ("¿Tienen el mismo contenido (relación de igualdad)? ... " + Arrays.equals(miArray1,
otroArray) );

//Copiamos el array utilizando el método copyOf de la clase Arrays

otroArray = Arrays.copyOf(miArray1, miArray1.length);

for (int i=0; i<otroArray.length; i++) {

System.out.print ("otroArray[" + i +"]= " + otroArray[i]+"; "); }

System.out.println ("¿Son el mismo objeto? ... " + (miArray1==otroArray) );

System.out.println ("¿Tienen el mismo contenido (relación de igualdad)? ... " + Arrays.equals(miArray1,
otroArray) );
} //Cierre del main
} //Cierre de la clase

44.
45.
46. Trata de predecir tú mismo el resultado y compáralo con el que ofrecemos.
Resultado:

miArray1[0]= 2; miArray1[1]= -4; miArray1[2]= 3; miArray1[3]= -7;

otroArray[0]= 1; otroArray[1]= 2; otroArray[2]= 4; otroArray[3]= 8; ¿Son el mismo objeto? ...
false
¿Tienen el mismo contenido (relación de igualdad)? ... false
otroArray[0]= 2; otroArray[1]= -4; otroArray[2]= 3; otroArray[3]= -7; ¿Son el mismo objeto? ...
false
¿Tienen el mismo contenido (relación de igualdad)? ... true

47.
48.
49. Hemos comprobado que el método copyOf de la clase Arrays realiza una copia
elemento a elemento entre los contenidos de dos arrays pero no hace que los
punteros apunten al mismo objeto. Prueba a variar la longitud que se le pasa como
parámetro al método copyOf, por ejemplo:
50. otroArray = Arrays.copyOf(miArray1, miArray1.length+2); //Resto del código igual
51. otroArray = Arrays.copyOf(miArray1, miArray1.length-2); //Resto del código igual
52.
 53. Comprueba que los resultados son el alargamiento del array y su relleno con ceros,
o el acortamiento con pérdida de los datos (truncamiento) que no caben debido al
recorte de la longitud. En el caso de alargamiento o expansión del array cuando se
trata de un array que no sea de enteros, si son tipos numéricos se rellenan los
excedentes con ceros, si son booleanos se rellenan los excedentes con false, si son
char se rellenan de caracteres vacío, y si son objeto se rellenan los excedentes con
null.
54.
55.
56. RELLENAR UN ARRAY CON UN VALOR U OBJETO. MÉTODO FILL DE LA
CLASE ARRAYS
57. La clase Arrays tiene un método, denominado fill, sobrecargado, que permite
rellenar un array con un determinado valor u objeto. En el caso de arrays de enteros
la signatura es:

static void fill (int[ ] a, int val)

Asigna el valor entero especificado a cada elemento del array de enteros
indicado.

58.
59.
60. En general la sintaxis será: Arrays.fill (nombreDelArray, valor con el que se rellena).
El valor con el que se rellena depende del tipo del array. Por ejemplo, si es un array
de tipo booleano, tendremos que rellenarlo bien con true o bien con false, no
podremos rellenarlo con un tipo que no sea coherente. Ejemplos de uso:
61. Arrays.fill (resultado, ‘9’); Como rellenamos con un carácter, resultado habrá de ser
un array de caracteres, ya que en caso contrario no habría coincidencia de tipos.
62. Arrays.fill (permitido, true); Como rellenamos con un true, resultado será un array de
booleanos. De otra manera, no habría coincidencia de tipos. Ejemplo de código:

import java.util.Arrays;
public class TestMetodoFillArrays {
public static void main (String [ ] Args) { //main cuerpo del programa ejemplo
aprenderaprogramar.com
int [ ] miArray = new int[10];
Arrays.fill(miArray, 33);
for (int tmp: miArray) { System.out.print (tmp + ","); } //Recorrido del array con un for
each
} } //Cierre del main y de la clase

63.
64.
65. Ejecuta el código y comprueba que el resultado es: 33,33,33,33,33,33,33,33,33,33,.
Es decir, el array queda relleno en todos sus elementos con 33.
66. En caso de que el array tenga contenidos previos al aplicarle el fill, todos sus
elementos quedarán reemplazados por el elemento de relleno. No obstante, hay
 otro método que permite especificar los índices de relleno de modo que se pueda
preservar parte del contenido previo del array:

static void fill (int[ ] a, int fromIndex, int toIndex, int val)

Asigna el valor entero especificado a cada elemento del rango indicado para el array
especificado.

 ¿Cómo Recorrer Arreglos en Java?

Con un array como:

String[] elementos = new String[2];
names[0] = "elemento1";
names[1] = "elemento2";
Podrías recorrer los elementos así:
for (int i = 0; i < elementos.length; i++) {
System.out.println(elementos[i]);
}

Una mejor forma no existe, pero hay distintas formas para sus casos de uso. Como el
tamaño de una arreglo no cambia en Java después de haber sido creado, la forma clasica
es por una iteración sobre los indices:

// ejemplo de arreglo
Object[] arreglo = new Object[10];
//...
for (int i = 0; i < arreglo.length; i++){
// aqui se puede referir al objeto con arreglo[i];
}
Este método usa un bucle simple con un primitivo como indice así no es muy costoso, y se
usa cuando es necesario de saber el indice junto con el objeto del arreglo.

Otra forma si no hay importancia cuantos elementos existen en el arreglo o no se necesita

referencia al indice es:

for (Object o : arreglo){

// en cada iteración "o" se refiere a un objeto del arreglo para todos objetos en el arreglo
}
Ambas formas necesitan pocos recursos y hay que recordar que no tiene mucho sentido en
Java de sobrepensar la optimisación de código, porque se invertió una tremenda
inteligencia de optimizar la ejecución del bytecode en la maquina virtual desde el JIT-
compilador (just in time).

Solamente hay que recordar que es recomendable en contexto de rendimiento de evitar

funciones muy altas para casos simples si se quiere minimizar el cabezero. El proximo
ejemplo usa más recursos, porque involucra instar varios objetos extra, que siempre
significa uso de más recursos en tiempo de ejecución y memoria:

Iterator i = Arrays.asList(arreglo).iterator();
while(i.hasNext()){
// trabajar con Objeto o = i.next()
}

 Uso del Bucle for-each para recorrido de arreglos y colecciones.

Una de las cosas que incorporó Java 5 fue el bucle for-each en Java. Esta estructura nos
permite recorrer una Colección o un array de elementos de una forma sencilla. Evitando el
uso de Iteradores o de un bucle for normal.
De la forma tradicional podríamos recorrer un array de la siguiente forma:

1. String a[] = {"Avila", "Burgos", "León", "Palencia", "Salamanca", "Segovia", "Soria",

"Valladolid", "Zamora"};
2.
3. for (int x=0;x<a.length;x++)
4. System.out.println(a[x]);
5.

En este caso nos estamos apoyando en el tamaño del array, con la propiedad length y en
una variable contador, la cual vamos incrementando hasta que llegue a el tamaño del array.
Para recorrer una Colección, una lista en este caso, podríamos hacerlo con un Iterador de
la siguiente forma:

1. List<String> list = new ArrayList<String>();

2.
3. // Añadimos elementos
4. list.add("Victor");
5. list.add("Amaya");
6. list.add("Julio");
7.
8. // Obtenemos un Iterador y recorremos la lista.
9. ListIterator<String> iter = list.listIterator(list.size());
10. while (iter.hasPrevious())
11. System.out.println(iter.previous());

Para la colección hemos creado un Iterador que nos permite recorrer los elementos de la
colección.
El bucle for-each en Javanos permite realizar estas mismas operaciones de una forma muy
sencilla. La estructura del bucle for-each sería de la siguiente forma:
 1. for (TipoBase variable: ArrayDeTiposBase) {..}

Así, para recorrer un array, tendríamos lo siguiente:

1. String array[] = {"Avila", "Burgos", "León", "Palencia", "Salamanca", "Segovia", "Sor

ia", "Valladolid", "Zamora"};
2.
3. for (String elemento: array)
4. System.out.println(elemento);
5.

Y para la colección, esto otro:

1. List<String> list = new ArrayList<String>();

2.
3. // Añadimos elementos
4. list.add("Victor");
5. list.add("Amaya");
6. list.add("Julio");
7.
8. for (String nombre: list)
9. System.out.println(nombre);
10.

Vemos que se unifica la forma de listar los elementos y se simplifica el código.