Arreglos de Objetos

10 -Arreglos de Objetos - ArrayList
Programación Orientada a Objetos
Proyecto Curricular de Ingeniería de Sistemas
Arreglos de Objetos
Un arreglo es una colección de objetos numerados del mismo tipo, en
donde cada variable o celda en el arreglo tiene un índice. Las celdas están
numeradas del 0 al N-1, donde N es el número de celdas del arreglo es
decir su capacidad.
Los índices de un arreglo en Java deben estar dentro de los límites, 0 – N1, de lo contrario se generará un error durante la ejecución.
Java implementa los arreglos como objetos que pueden ser tratados como
cualquier otro objeto. Para utilizar un arreglo en Java:
1. Declare una variable para que contenga el arreglo
2. Cree un nuevo arreglo de objeto y asígnelo a la variable de arreglo
3. Almacene información en ese arreglo
4. Realice operaciones de almacenamiento y recuperación con los
elementos del arreglo
Declaración:
Se agrega un par de corchetes vacíos [ ] al objeto o tipo de datos, o al
nombre de variable.
Ejemplos:
String palabrasDificiles [ ];
Point hits [ ];
int donaciones [ ];
O bien:
String [ ] palabrasDificiles;
Point [ ] hits;
int [ ] donaciones;
Creación de objetos de arreglos:
Después de haber declarado la variable arreglo, el siguiente paso es crear
un arreglo de objetos y asignarlo a esa variable. Las formas de hacerlo
son:
• a través del operador new
• inicializando directamente el contenido del arreglo
String [ ] nombreJugadores = new String [10];
int [ ] temps = new int [99];
Todas las posiciones se inicializan automáticamente (0 para arreglos
numéricos, false para booleanos, ‘\0’ para arreglos de carácter y null para
objetos) También se puede crear e inicializar un arreglo al mismo tiempo.
Encierre los elementos del arreglo entre llaves, separándolos con comas:
String [ ] chiles = { “jalapeno”, “de árbol”, “serrano”,
“habanero”};
Al crear elementos con valores iniciales, el arreglo es del mismo tamaño
que la cantidad de elementos que ha incluido en las llaves.
Ejemplo:
class ArregloNombres {
String[] nombres = { "Pedro", "Jorge", "Carlos", "Luis"};
String[] apellidos = new String[nombres.length];
void imprime() {
int i = 0;
System.out.println(nombres[i] + " " + apellidos[i]);
i++;
System.out.println(nombres[i] + " " + apellidos[i]);
i++;
System.out.println(nombres[i] + " " + apellidos[i]);
i++;
System.out.println(nombres[i] + " " + apellidos[i]);
}
public static void main (String arguments[]) {
ArregloNombres a = new ArregloNombres();
a.imprime();
System.out.println("-----");
a.apellidos[0] = "Perez";
a.apellidos[1] = "Isaac";
a.apellidos[2] = "Valderrama";
a.apellidos[3] = "Garzon";
a.imprime();
}
}
El tamaño de un arreglo se almacena en la variable length, que puede ser
accesada a través del operador punto (.) y el nombre del arreglo:
nombreArreglo.length
El manejo de arreglos multidimencionales funciona de la misma forma que
en C++.
Nota: Recuerde que en los arreglos se puede almacenar cualquier tipo de
objeto siempre y cuando este sea del mismo tipo.
La clase ArrayList Explicada:
Las aplicaciones frecuentemente necesitan almacenar un grupo de datos
en un sólo objeto. Los arrays sirven bien para este propósito, pero algunas
veces necesitamos incrementar o reducir dinámicamente el número de
elementos del array, o hacer que contenga distintos tipos de datos.
Esto es común entre las aplicaciones como las tiendas online. Un cliente
añade una mercancía a su carro de la compra, y detrás de la escena, los
ítems son almacenados y eliminados automáticamente.
Para esta clase de grupos de datos crecientes y menguantes, podemos
usar la clase Vector, o la reciente clase ArrayList del paquete java.util.
Un ArrayList contiene tantos objetos como necesitemos.
ArrayList tiene varios constructores, dependiendo de cómo necesitemos
construir el ArrayList. Los siguientes dos constructores nos ayudarán a
empezar:
•
ArrayList() construye un ArrayList con capacidad cero por defecto,
pero crecerá según le vayamos añadiendo:
ArrayList al = new ArrayList();
•
ArrayList(int initialCapacity) construye un ArrayList vacío con una
capacidad inicial especificada:
ArrayList al2 = new ArrayList(5);
Un objeto ArrayList sólo contiene referencias a objetos. Para almacenar
tipos primitivos como double, long, o float, usamos una clase envoltura,
como se muestra abajo. Para añadir objetos al ArrayList, llamamos a sus
métodos con el operador punto:
al.add("Java es un Lenguaje de POO"); //adiciona un String
al.add(new Double(40.00)); //Adiciona un double en una clase
//envoltura Double como Object
System.out.println(al.size()); //imprime el tamano del ArryList
Si necesitamos circular a través de los elementos del ArrayList, usamos la
clase Iterator y sus métodos hasNext y next:
Iterator alIt = al.iterator();
while (alIt.hasNext()) {
System.out.println(alIt.next() + " ");
}
ArrayList es una de las muchas clases del Collection Framework, que
proporciona un conjunto de interfaces y clases bien-diseñados para almacenar y
manipular grupos de datos como una sola unidad, una coleccion.
Programa Ejercicio
Hemos aprendido sóbre las clases, los objetos y los constructores, y sobre la
clase ArrayList. Pon estos conceptos juntos para crear la siguiente aplicación:
•
Crea una clase llamada ItemsListing.
•
Crea un constructor para ItemsListing que tome un parámetro: item.
•
En la clase ItemsListing, usa el siguiente método para convertir un
dato variable en un String:
public String toString() {
String s = "Item: " + item;
return s;
}
•
Crea una clase pública llamada ArrayListItems que contenga el
método main.
•
En el método main, ejemplariza tres objetos de ItemsListing,
proporcionando los datos para el constructor.
•
Crea un ArrayList.
•
Rellena el ArrayList con los tres objetos, usando el método add.
•
Pasa el ArrayList a un Iterator.
•
Usa un bucle while y el método hasNext para imprimir el contenido
del ArrayList.
•
Graba el fichero como ArrayListItems.java compilalo y ejecutalo.
El resultado debería ser similar a este:
Item: Balon
Item: De
Item: Futbol
Un poco de Java
¿Por qué los Argumentos de la Línea de Comandos no son Tecnología
100% Pura Java?
Las aplicaciones que requieren argumentos de la línea de comandos no son
100% Puro Java porque no todos los sistemas tienen disponible una línea de
comandos.
Si tienes una línea de comandos en tu sistema, usar argumentos de línea de
comandos durante el desarrollo de la aplicación es útil para probar la lógica del
código, o leer ficheros. De otra forma, debes considerar el utilizar propiedades
para que tu aplicación sea portable.
Solución al Programa de Ejercicio
Esta es una posible solución al Programa del Ejercicio:
//ArrayList
//java.util package
import java.util.*;
class ItemsListing {
private String item;
public ItemsListing (String item) {
this.item = item;
}
public String toString() {
String s = "Item: " + item;
return s;
}
}
public class ArrayListItems {
public static void main(String []args) {
ArrayList items = new ArrayList();
items.add(new ItemsListing("Balon"));
items.add(new ItemsListing("De"));
items.add(new ItemsListing("Futbol"));
Iterator iterateItems = items.iterator();
while (iterateItems.hasNext()) {
System.out.println(iterateItems.next());
}
}
}
Resultados:
Balon
De
Futbol