Java 1.5 Tipos de datos II

Una vez vistos los tipos de datos básicos, ampliamos un poco el repertorio con:

- Array (vectores y matrices)
- List (listas ordenadas)
- Set (conjuntos)
- Otras clases

Arrays: son los vectores y matrices del lenguaje Java, tienen dimensión conocida, es decir, que cuando los inicializamos hay que darles un tamaño.
Pros:
- Están ordenados por índice, desde 0 hasta tamaño-1.
- Se puede acceder de forma indexada, por índices (vector[0] = 4).
- Son simples en la declaración, simplemente añadiendo [].
- Funcionan con cualquier tipo de clase sin operaciones adicionales.
Contras:
- Hay que darles un tamaño en el momento de la inicialización.
- No tienen operaciones.



/*Ejemplos de declaración e inicialización de Arrays*/
/*Podemos usar 3 metodos*/

// declaración
int[] v;

// declaración y inicializacion a la vez
int[] v = new int[4];

// declaración, inicializacion y asignacion de contenido a la vez
// el tamaño esta implicito en el numero de elementos asignados
int[] v = {1,2,3,4}

/*Si tenemos un array ya declarado para darle tamaño hay que hacer
la instruccion new reserva espacio en memoria para el array*/
boolean[] v;
v = new boolean[10];

/*Para asignar el contenido del array tenemos diferentes formas*/

//Asignacion por indice, acdedemos a la posicion del array que indica []
int[] v = new int[10];
v[0] = 25;
v[4+5] = 32;

//Asignacion por recorrido

int tam = 25;
int[] v = new int[tam];
for (int i=0; i<tam; i++) v[i] = 4687;


List: la listas son estructuras de datos dinámicas, es decir, su tamaño puede ser variable, crecer y decrecer en memoria, además son estructuras ordenadas. Por suerte Java nos evita el engorroso trabajo de programar una lista enlazada y nos proporciona una clase List con la cual implementar este tipo de estructura.
Pros:
- Tamaño indefinido, infinito si es necesario.
- Esta ordenada.
- Permite el acceso indexado.
- Funciona con cualquier tipo de clase sin operaciones adicionales.
- Proporciona operaciones muy útiles.
Contras:
- Un poco mas difíciles de declarar que los arrays.
- Recorrido mas complicado ya que es necesario el uso de iteradores.
- Necesario saber las operaciones(no es problema con NetBeans).

/*Declaración de una lista*/

/*Se han de utilizar las clases envolventes de los tipos basicos*/
List<Integer> listaEnteros;
List<Boolean> listaBooleanos;
List<String> listaString;

/*Inicializacion, aquí iniciare con ArrayList aunque existen otras formas*/
listaEnteros = new ArrayList<Integer>();
listaBooleanos = new ArrayList<Boolean>();
listaString = new ArrayList<String>();

/*Una vez creada la lista tenemos diferentes operaciones*/

/*Añadir un elemento, se mantiene el orden de insercion. El primer elemento
sera el 4 y el ultimo sera el 4*8*9+6-3 */
Integer a = 4;
listaEnteros.add(a);
listaEnteros.add(4);
listaEnteros.add(-898564);
listaEnteros.add(4*8*9+6-3);

/*Borrar un elemento de la lista, borra el elemento que esta en la posicion indicada, en este caso borraria el 4*/
int posicion = 0;
listaEnteros.remove(posicion);

/*Borrar todos los elementos*/
listaEnteros.clear();

/*Obtener un elemento de la lista, en este caso nos retornaria el 4*/
int posicion = 0;
int elemento = listaEnteros.get(posicion);

/*Comprobar si la lista esta vacia*/
boolean vacia = listaEnteros.isEmpty();

/*Obtener el tamaño de la lista*/
listaEnteros.size();

/*Recorrer una lista es un poco especial ya que es una estructura dinamica, para ello se ha de definir un iterador, una especie de indice que recorre la lista, la estructura de un recorrido de una lista que imprime por pantalla su contenido seria esta*/

/*Bucle for*/
for (Iterator<Integer> it = lista.iterator(); it.hasNext();) {
Integer elemento = it.next();
System.out.println(elemento);
}

/*Bucle while*/
Iterator<Integer> it = lista.Iterator();
while(it.hasNext()) {
Integer elemento = it.next();
System.out.println(elemento);
}



Sets: proximamente.
Cualquier duda dejar un comentario.