Curso

Programación en Java

Funciones Procedimientos–
Arrays – cadenas

Correo: Victor.Barrientos.rodriguez@gmail.com
Asunto: BCI01_JAVA_PRAC_02
Programa en Java - Funciones
import java.util.Scanner;
public class EJERCICIO_02
{
public static int SUMA(int NUM_01, int NUM_02)
public static Scanner TECLADO;
{
public static void main(String[] ARGUMENTOS) int SUMA;
{ SUMA = NUM_01 + NUM_02;
return SUMA;
TECLADO = new Scanner(System.in);
}
int NUMERO_01,NUMERO_02,OP_SUMA,OP_RESTA,OP_MULTIPLICACION; public static int RESTA(int NUM_01, int NUM_02)
float OP_DIVISION; {
int RESTA;
RESTA = NUM_01 - NUM_02;
NUMERO_01 = LEER_NUMERO("NUMERO 01");
return RESTA;
NUMERO_02 = LEER_NUMERO("NUMERO_02"); }
public static int MULTIPLICACION(int NUM_01, int NUM_02)
OP_SUMA = SUMA(NUMERO_01,NUMERO_02); {
int MULTIPLICACION;
OP_RESTA = RESTA(NUMERO_01,NUMERO_02);
MULTIPLICACION = NUM_01 * NUM_02;
OP_MULTIPLICACION = MULTIPLICACION(NUMERO_01,NUMERO_02); return MULTIPLICACION;
OP_DIVISION = DIVISION(NUMERO_01,NUMERO_02); }
public static float DIVISION(int NUM_01, int NUM_02)
{
float DIVISION;
IMPRIMIR_RESULTADOS(OP_SUMA,OP_RESTA,OP_MULTIPLICACION,OP_DIVISION);
DIVISION = (float)(NUM_01/NUM_02);
} return DIVISION;
}
public static int LEER_NUMERO(String NOMBRE_NUMERO) public static void IMPRIMIR_RESULTADOS(int S,int R,int M,float D)
{
{
System.out.println("LOS RESUTLADOS SON : \n");
int NUMERO;
System.out.println("SUMA : " + S);
System.out.println("RESTA : " + R);
System.out.print("INDIQUE EL " + NOMBRE_NUMERO + " : ");
System.out.println("MULTIPLICACION : " + M);
NUMERO = TECLADO.nextInt(); System.out.println("DIVISION : " + D);
}
return NUMERO; }
}
2
 Programa en Java
import java.util.Scanner;
public class TestArreglos {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
float promedio = 0;
float suma = 0;
int mayor = 0;
int menor = 0;
int[] miArreglo = new int[10];
for (int i = 0; i < 10; i++) {
System.out.print("Ingrese el número en la posición " + (i) + " :");
miArreglo[i] = entrada.nextInt();
}
// realizar la suma, promedio y el mayor
for (int i = 0; i < miArreglo.length; i++) {
suma += miArreglo[i];
if (mayor < miArreglo[i]) {
mayor = miArreglo[i];
}
System.out.println(String.format("Posición [%d] Elemento: %d", i, miArreglo[i]));
}
menor = mayor; 3
 Programa en Java

promedio = suma / miArreglo.length;

System.out.println("***Salida***");
// contar las veces que se repite cada número
int cont;
for (int i = 0; i < miArreglo.length; i++) {
cont = 0;
for (int j = i; j < miArreglo.length; j++) {
if (miArreglo[i] == miArreglo[j]) {
cont++;
}
}
System.out.println(String.format("El número %d se repite %d veces", miArreglo[i], cont));
}
System.out.println(String.format("La suma es %.2f, el promedio es %.2f, el mayor es %d, el menor es %d", suma, promedio, mayor, menor));
}

4
Arrays y colecciones

 Hay dos formas de guardar varias referencias a objetos:

 Arrays
 Más eficiente.
 Tamaño limitado.
 Sólo puede almacenar referencias de un tipo.
 Colecciones.
 Menos eficiente.
 Tamaño variable.
 Almacena objetos sin tipo específico.
 Clases más utilizadas: Vector y ArrayList. Guardan objetos de
cualquier tipo, crecen dinámicamente.
 Clases genéricas List, Set y Map.
Declaración de arrays

 Declaración.
modificadores tipo[] identificador;
 Los modificadores se aplican al array, no a los elementos.
 Asignar espacio de almacenamiento creando una instancia mediante
new.
int[] a = new int[5];
int b[];
b = new int[3];
 length, indica el número de elementos.
 Los índices van de 0 hasta length – 1.
 Cualquier otro valor lanza la excepción ArrayIndexOutOfBoundException.

 En Java los arrays no son un tipo de dato, sino una clase que extiende
la clase Object (superclase base).
Inicialización de arrays (I)

 Inicialización a los valores por omisión.

 Un array de tipos primitivos inicializa los elementos a sus valores
por omisión.
 Un array de referencias inicializa los elementos a referencias nulas
(null).
 Un array de referencias no guarda el contenido del objeto, sino una
referencia a la instancia.

0 1 2 3 4 0 1 2 3 4
0 0 0 0 0 null null null null null

a palabras
int a[] = new int[5]; String palabras[] = new String[5];
Inicialización de arrays (II)

 Llenar el array.
 Mediante asignaciones:
int[] a = new int[5];
//Carga de elementos en el array
//con números aleatorios entre 0 y 19.
for (int i=0;i<=a.length-1;i++)
a[i] = (int) (Math.random() * 20);
 En arrays de referencia.
String [] palabras = new String[5];

H o l a

0 1 2 3 4
null null null null

palabras
palabras[3] = "Hola";
Inicialización de arrays (III)

 Inicialización de arrays en la declaración.

 Sólo se puede hacer en la declaración.
 No se debe poner el tamaño del array.
 Se crea espacio de almacenamiento y se rellena en la misma
declaración
char b[] = {'a','b','c'};.
Integer números[] = { new Integer(1),
new Integer(2),
new Integer(3)};
int ab[][] = {{11},
{12, 13}
{14, 15, 16}};
Asignación de arrays

 Cuando se asigna un array H o l a

palabras2
a otro array se copia la 0 1 2 3 4

referencia. null null null null

 Copiar un array supone String palabras2[] = palabras;

palabras

asignar los elementos a

otro array. x x x x
palabras2
0 1 2 3 4
null null null null

palabras
palabras2[3] = “xxxx”

 La clase System contiene un método para copiar arrays.

public static void arraycopy(Object origen, int posOrig,
Object dest, int posDest,
int length)
Copia de arrays
 En la copia de arrays hay que tener la precaución de que el array
destino tenga posiciones de memoria suficientes para la copia.
Ejemplo:
double fuente [] = {-4.0,0.5, -7.0, ...};
double destino[] = new double[fuente.length];
// copia completa;
System.arraycopy(fuente, 0, destino, 0, fuente.length);
// copia de segunda mitad;
System.arraycopy(fuente, fuente.length/2, destino, 0,
fuente.length/2);
Arrays y métodos
 Arrays y métodos.
 Los métodos también pueden devolver arrays.
static int[] cargaArray(int n)
{
int[] a = new int[n];
for (int i=0;i<=a.length-1;i++)
a[i] = (int) (Math.random() * 20);
return a;
}
 O recibir arrays como argumentos
 En este caso, el array se pasa por referencia (como todos los objetos).
static void imprimirArray(Object[] v)
{
//Muestra los elementos del array
for (int i=0;i<=v.length-1;i++)
System.out.println("Elemento " + i + ": " + v[i]);
}
Arrays multidimensionales (I)
null null
 Declaración.
String [][] cad = new String[3][2];
null null

null null
cad

String cad[][] = new String[3][];

null
cad[1] = new String[3];
null null null
String otra[] = {“hola”,”adios”};
cad[2] = otra; hola adios
cad

otra
Arrays multidimensionales (II)

 El atributo length en arrays multidimensionales.

 a.length, devolvería el tamaño de la primera dimensión.
 a[i].length, devolvería el tamaño de la fila i.

for(int i=0;i <= cad.length-1;i++)

{
System.out.println("Línea " + i );
if(cad[i] == null)
System.out.println("vacía");
else
for(int j=0;j<=cad[i].length-1;j++)
System.out.println(cad[i][j]);
};
El array args

 Contiene los argumentos pasados mediante la línea de órdenes.

class HolaMundo {
public static void main(String args[]) {
// Muestra "¡Hola mundo, hoy es dd-mm-aa!"
int conta = args.length;
System.out.print("!Hola ");
if(conta>0){
for(int i=0;i<=conta-1;i++)
System.out.print(args[i] + ", ");
System.out.println();
}
else
System.out.println("anónimo");
}
}
La clase Arrays (I)

 La bibilioteca java.utils contiene la clase Arrays con

funciones (métodos) de utilidad para los arrays.
 Es necesario incorporar import java.utils.*; o bien
import java.utils.Arrays al comienzo del archivo fuente.

 Comparar arrays (método equals de Arrays)

public static boolean equals(tipo[] a, tipo[] a2)

int v1[] = {1,2,3};

int v2[] = {1,2,3};
System.out.println(Arrays.equals(v1,v2));
La clase Arrays (II)

 Rellenar arrays.
 Rellenar el array a con el valor del segundo argumento.
public static void fill(tipo[] a, tipo val)
 Rellenar el array a entre dos posiciones dadas con el valor del
segundo argumento.
public static void fill(tipo[] a, int desde, int hasta,
tipo val)

 Ordenar arrays.
public static void sort(tipo[] a)

 Buscar en arrays
public static int binarySearch( tipo[] a, tipo elemento)
 Buscar el elemento en el array. Si lo encuentra devuelve su posición, si no
devuelve un número negativo con la posición donde debería estar.
Cadenas
 Dos tipos de clases para almacenar cadenas.
 String (java.lang). Cadenas inmodificables.
 Consume menos recursos.
 StringBuffer(java.lang). Cadenas modificables.
 StringBuilder (java.lang). Cadenas modificables, mas eficiente que
StringBuffer.

h o l a a b c
cad1 cad2
String cad1 = “hola”; StringBuffer cad2 = “abc”;

h o l a a d i o s a b c d e f
cad1 cad2
cad1 = “adios” cad2.append(“def”);
import java.util.Scanner;
public class UsoDe_IndexOf
{
public static void main(String[] ARGUMENTOS)
{
Scanner TECLADO = new Scanner(System.in);
String PALABRA_01;
int POCICION;
System.out.print("INGRESE UNA CADENA : ");
PALABRA_01 = TECLADO.nextLine();
POSICION = PALABRA_01.indexOf("JAVA");
if(POSICION == -1)
{
System.out.println("NO EXISTEN LETRAS \"a\" EN LA CADENA");
}
else
{
System.out.println("LA PRIMERA LETRA \"a\" ESTA EN LA POSICION : " + (POSICION));
}
}
}
import java.util.Scanner;
public class UsoDe_Substring
{
public static void main(String[] ARGUMENTOS)
{
Scanner TECLADO = new Scanner(System.in);
String PALABRA,PALABRA_02;

System.out.print("INGRESE UNA PALABRA : ");

PALABRA = TECLADO.nextLine();

PALABRA_02 = PALABRA.substring(2,5);

System.out.println("RECORTANDO LA PALABRA DE LA POSICION 2 HASTA 5 ES : " + PALABRA_02);

}
}
import java.util.Scanner;
public class UsoDe_Equals
{
public static void main(String[] ARGUMENTOS)
{
Scanner TECLADO = new Scanner(System.in);
String PALABRA_01;
String PALABRA_02;

System.out.print("INGRESE CADENA 01 : ");

PALABRA_01 = TECLADO.nextLine();

System.out.print("INGRESE CADENA 02 : ");

PALABRA_02 = TECLADO.nextLine();

if(PALABRA_01.equals(PALABRA_02))
{
System.out.println("LAS CADENAS SON IGUALES...");
}
else
{
System.out.println("LAS CADENAS NO SON IGUALES...");
}
}
}
Constructores de String y StringBuffer
 Se puede construir un objeto de la clase String como si se tratara de
un tipo de dato primitivo.
String cad1 = “hola”;

 Constructores de String:
 String(), crea una nueva cadena vacía.
 String(String valor). Crea una nueva cadena a con el contenido de
valor.
 String(StringBuffer sb). Crea una nueva cadena a partir de un
StringBuffer.
 Constructores de StringBuffer:
 StringBuffer(), crea una nueva cadena vacía con una capacidad inicial
de 16 caracteres.
 StringBuffer(int longitud). Crea una nueva cadena vacía con una
capacidad inicial de longitud caracteres.
 StringBuffer(String str). Crea un nuevo StringBuffer a partir
de una valor de tipo String.
Comparación de cadenas (I)

 El operador de igualdad sólo compara si las referencias son

iguales.
String c1 = "hola";
String c2;
String c3 = new String(c1);
c2 = c1;
System.out.println(c1 == c2); //Devuelve true
System.out.println(c1 == c3); //Devuelve false

 Método equals.
 public boolean equals(String str)
System.out.println(c1.equals(c3)); //Devuelve true
Comparación de cadenas (II)

 Método equalsIgnoreCase.
 public boolean equalsIgnoreCase(String str)
c3 = "Hola";
System.out.println(c1.equalsIgnoreCase(c3)); //Devuelve true

 Método compareTo.
 public int compareTo(String str)
 Devuelve 0 si las cadenas son iguales; mayor que 0 si la cadena que
invoca es mayor que str o menor que 0 si la cadena que invoca es
menor que str.
 El número que devuelve es la direfencia entre los códigos del primer
carácter de la cadena.
c3 = "Hola"; c1 = "hola";
System.out.println(c1.compareTo(c3)); //Devuelve 32
c3 = "Adios";
System.out.println(c3.compareTo(c1)); //Devuelve -39
Comparación de cadenas (III)

 Método compareToIgnoreCase.
 public int compareToIgnoreCase(String str)
c3 = "Hola";
System.out.println(c1.compareToIgnoreCase(c3)); //Devuelve 0
c3 = "Adios";
System.out.println(c3.compareToIgnoreCase(c2)); //Devuelve -7

 Comparar con StringBuffer.

 public boolean contentEquals(StringBuffer sb)
StringBuffer sb1 = new StringBuffer(“hola”);
System.out.println(c1.contentEquals(sb1)); //Devuelve true
Métodos de String (I)

 Otros métodos:
 public int length()
 public char charAt(int i)
 Devuelve el carácter contenido en la posición i. El argumento debe ser
mayor o igual que 0 y menor que length() -1.
 public int indexOf(int c)
 Devuelve la posición de la primera ocurrencia del carácter c o -1 si no
está.
 public int indexOf(int c, int inicio)
 Devuelve la posición de la primera ocurrencia del carácter c a partir de
la posición inicio o -1 si no está.
c1 = "cocodrilo";
System.out.println(c1.indexOf('o')); //Devuelve 1
System.out.println(c1.indexOf('o',5)); //Devuelve 8
Métodos de String (II)
 public int lastIndexOf(int c)
 Devuelve la posición de la última ocurrencia del carácter c o -1 si no está.
 public int indexOf(int c, int inicio)
 Devuelve la posición de la última ocurrencia del carácter c a partir de la posición
inicio (contando desde el final) o -1 si no está.
c1 = "cocodrilo";
System.out.println(c1.lastIndexOf('o')); //Devuelve 8
System.out.println(c1.lastIndexOf('o',7)); //Devuelve 3
 public String toUpperCase()
 public String toLowerCase()
 public String substring(int inicio)
 public String substring(int inicio, int fin)
 Devuelve una subcadena formada a partir del carácter inicio hasta el carácter fin.
 public String[] split(String expr)
 Devuelve un array de cadenas formado por subcadenas separadas a partir del
separador expr.
Métodos de StringBuffer (I)

 métodos:
 public int length()
 public char charAt(int i)
 public int indexOf(int c)
 public int indexOf(int c, int inicio)
 public int lastIndexOf(int c)
 public int indexOf(int c, int inicio)
 public String toUpperCase()
 public String toLowerCase()
 public String substring(int inicio)
 public String substring(int inicio, int fin)
 public String[] split(String expr)
Métodos de StringBuffer (II)

 Gestión de la capacidad de la cadena.

 public int capacity()
 Devuelve la capacidad del buffer (no su longitud).
 public void ensureCapacity(int minimo)
 Asegura una capacidad mínima al buffer.
 public void setLength(int nuevaLong)
 Modifica la longitud de la cadena (no su capacidad).
Métodos de StringBuffer (III)

 Modificación de caracteres
 public void setCharAt(int pos, char car)
 Sustituye el carácter de la posición pos por el carácter car.
 public StringBuffer replace(int inicio,
int fin, String str)
 Reemplaza los caracteres comprendidos entre inicio y fin por str.
 La clase String tiene además el método replace(char car1,char
car2) que sustituye todas las apariciones de car1 por car2.
 public StringBuffer append(tipo valor)
 Añade una representación de valor al final del StringBuffer.
 public StringBuffer insert(int pos, tipo valor)
 Inserta una representación de valor en la posición pos.
 public StringBuffer delete(int inicio, int fin)
 Borra los caracteres situados entre la posición inicio y fin.
Conversiones de cadenas de texto
Tipo A String De String

boolean String.valueOf(boolean) new Boolean(String).booleanValue()

byte String.valueOf(int) Byte.parseByte(String, int base)
Byte.parseByte(String)
short String.valueOf(int) Short.parseShort(String, int base)
Short.parseShort(String)
int String.valueOf(int) Integer.parseInt(String, int base)
Integer.parseInt(String)
long String.valueOf(long) Long.parseLong(String, int base)
Long.parseLong(String)
float String.valueOf(float) new Float(String).floatValue();
Float.valueOf(String).floatValue();
Float.parseFloat(String);
double String.valueOf(double) new Double(String).doubleValue();
Double.valueOf(String).doubleValue();
Double.parseDouble(String);
Conversiones a/de arrays de char
 Constructores
 String(char[] caracts, int inicio, int longitud)
 String(char[] caracts)
 Métodos que devuelven cadenas a partir de arrays de char.
 public static String copyValueOf(char[]caracts)
 public static String copyValueOf(char[]caracts int
inicio, int longitud)
 Devuelve una cadena formada por los caracteres de caracts.

 Métodos que devuelven arrays de char a partir de una cadena

 public char[] toCharArray()
 Devuelve un array de char a partir de la cadena que invoca.
 public void getChars(int ini, int fin,
char[] dest,int destInicio)
 Copia caracteres desde la posición ini a la posición fin al array dest a partir de la
posición destInicio.
Conversiones a/de arrays de byte

 Constructores
 String(byte[] bytes, int inicio, int longitud)
 String(byte[] bytes)

 Métodos que devuelven arrays de byte a partir de una

cadena
 public byte[] getBytes()
COLECCIONES
 COLECCIONES EN JAVA
 Una colección es una agrupación de objetos relacionados que forma un única
entidad, por ejemplo un array de objetos, un conjunto.... .
Puerto [] col2 = new Puerto [100];
LinkedList <String> conCad =
new LinkedList <String>(); // Lista de cadenas (Java5)

 Las colecciones incluyen clases contenedoras para almacenar objetos,

iteradores para acceder a los objetos en el interior de los contenedores y
algoritmos para manipular los objetos (métodos de clases) .
 Las clases Colección guardan objetos de cualquier tipo, de hecho el elemento
base es Object y por consiguiente, debido a conversión automática, se podrá
añadir a la colección un objeto de cualquier tipo.
 Cuando se vaya a trabajar con tipos de datos simples, o cuando se conozca el
tipo de dato de los elementos y el tamaño final, resulta muy eficiente utilizar
arrays. En cualquier otro caso, será conveniente utilizar alguna de las
colecciones proporcionadas en java.util.
 TIPOS DE COLECCIONES
 En las primeras versiones del JDK, Java 1.0 y 1.1, se incorporan colecciones
básicas, aunque en la mayoría de las ocasiones suficientes. Las mas
importantes son Vector, Stack, Dictionary, HashTable y el interface
Enumeration para recorrer los elementos de una colección.

 Java 2 (versiones 1.2 y posteriores) incorpora nuevas clases colección, dentro

del paquete java.util (API de las colecciones). Hay tres tipos generales de
colecciones: conjuntos, listas y mapas; los interfaces Set, List y Map
describen las características y comportamientos generales de estos .
 COMPARACIÓN DE OBJETOS: COMPARABLE Y
COMPARATOR
 Numerosas operaciones con colecciones exigen que sus elementos sean
comparables, es decir, que se pueda determinar que un elemento es menor,
igual o mayor que otro. Esta propiedad se establece a nivel de clase,
implementando el interface Comparable, o bien el interface Comparator
 Comparable se utiliza para establecer un orden natural entre los objetos de una
misma clase. La declaración del interfaz es la siguiente (paquete java.lang):
public interface Comparable
{
public int compareTo(Object ob);
}
 Si compareTo() devuelve un negativo significa que el objeto que llama al
método es menor que el pasado en el argumento; si devuelve 0 significa que
son iguales, y si devuelve un positivo el objeto que llama al método es mayor
que el pasado en el argumento.
 EJEMPLO DE CLASE QUE IMPLEMENTA COMPARABLE
public class Racional implements Comparable
{
private int numerador, denominador;

public int compareTo(Object x) // método del interface

{
Racional r;
r = (Racional) x;
if (valorReal() < r.valorReal())
return -1;
else if (valorReal() > r.valorReal())
return 1;
else
return 0;
}
 EJEMPLO COMPARABLE (II)
public Racional()throws Exception { this(0,1); }
public Racional(int n, int d) throws Exception
{
numerador = n;
denominador = d;
if (denominador == 0) throw new Exception("Denominador 0");
}
public String toString()
{
return numerador + "/" + denominador;
}
private double valorReal()
{
return (double)numerador/(double)denominador;
}
// ...
}
 EJEMPLO COMPARABLE (III)
// clase principal, crea los objetoS de manera aleatoria
public class OrdenaRacional
{
static int MR = 7;
public static void main(String[] a)
{
Racional [] ar = new Racional[MR];
try {
for (int i = 0; i < MR; i++)
{
int n, d;
n = (int)(Math.random()* 21 +1);
d = (int)(Math.random()* 21 +1);
ar[i] = new Racional(n, d);
}
}
catch (Exception e) {;}
 EJEMPLO COMPARABLE (IV)
// listado de los objetos creados
System.out.println(" Lista de numeros racionales: ");
escribe(ar);
// ordenación del array
Arrays.sort(ar); // se puede ordenar ya que los objetos
// de ar[] implementan interface Comparable
// listado de los objetos ordenados
System.out.println(" Lista ordenada de numeros racionales: ");
escribe(ar);
}
static void escribe(Racional [] r)
{
for (int i = 0; i < r.length; i++)
System.out.print(r[i] + " ");
System.out.println();
}
}
 COLECCIÓN VECTOR
 El comportamiento de un contenedor de tipo Vector (java.util) se asemeja al de
un array, con la bondad de que no es necesario controlar su tamaño,
automáticamente, si fuera necesario, aumenta su capacidad.
 A partir de Java 2 la clase Vector implementa el interfaz List para que forme
parte de las colecciones de Java.
 Java 5 permite establecer el tipo concreto de elemento que puede guardar una
colección, y en particular un vector.
Vector<String> vc = new Vector<String>();
vc.addElement("Lontananza");
vc.addElement (new Integer(12)); // error de compilación
Sin embargo, si la declaración es la siguiente:
Vector vc = new Vector ();
Se puede añadir cualquier tipo de elemento, no hay comprobación de tipo:
vc.addElement("Lontananza");
vc.addElement (new Integer(12)); // correcto
 CREAR UN VECTOR
 La clase Vector dispone de diversos constructores:
public Vector() crea un vector vacío.
public Vector(int capacidad) crea un vector con una capacidad inicial.
public Vector(Collection org) crea un vector con los elementos de org

Por ejemplo:
Vector v1 = new Vector();
Vector v2 = new Vector(100);
Vector v3 = new Vector(v2);// v3 contiene los mismo elementos que v2
 AÑADIR, INSERTAR EN UN VECTOR
 Los elementos que se meten en el vector deben ser objetos, no pueden ser datos de
tipos primitivos (int, char ... ).
 Los métodos son:
boolean add (Object ob); añade el objeto a continuación del último elemento del vector.
void addElement(Object ob); añade el objeto a continuación del último elemento del vector.
void insertElement(Object ob, int p); inserta el objeto en la posición p; los
elementos posteriores a p se desplazan.

 Por ejemplo:
Vector num = new Vector();
for(int i = 1; i <= N; i++)
{
Numero q;
q = new Racional(3 * i, 3 * i % 7 + 1);
num.addElement(q);
q = new Complejo(3 * i % 7, 3 * i - 5);
num.addElement(q);
}
 ACCESO A UN ELEMENTO DE UN VECTOR
 Los métodos de acceso devuelven el elemento con el tipo Object, entonces es
posible que sea necesario realizar una conversión al tipo del objeto.
 Los métodos son:
Object elementAt(int p); devuelve el elemento cuya posición es p.
Object get(int p); devuelve el elemento cuya posición es p.
int size(); devuelve el número de elementos

 Por ejemplo:
int k;

k = num.size();// número de elementos

for (int i = 1; i <= k; i++)
{
Numero q;
q = (Numero) num.elementAt(i);
q.mostrar();
}
 ELIMINAR y BUSCAR UN ELEMENTO
 Los métodos para eliminar son:
void removeElementAt(int indice); elimina elemento índice y el resto serenumera.
boolean removeElement (Object op); elimina la primera aparición de op; devuelve true si
realiza la eliminación.
void removeAll(Collection gr); elimina los elementos que están en gr.
void removeAllElements() elimina todos los elementos.

 Los diversos métodos de búsqueda de Vector devuelven la posición de la

primera ocurrencia del objeto buscado, o bien verdadero-falso según el éxito de
la búsqueda, son:

boolean contains(Object op); devuelve true si encuentra op.

int indexOf(Object op); devuelve la primera posición de op, -1 si no está
 ITERADOR ENUMERATION(I)
 Un iterador permite acceder a cada elemento de una colección sin necesidad de tener que
conocer la estructura de esta.
 Java 1.0 incorpora el iterador Enumeration, posteriormente Java 2 desarrolla dos
nuevos iteradores: Iterator y ListIterator. Todos ellos están definidos como
interface.
 Enumeration forma parte del paquete java.util, su declaración es la siguiente:
public interface Enumeration
{
boolean hasMoreElements();
Object nextElement();
}
 nextElement()devuelve el siguiente elemento. Levanta la excepción
NoSuchElementException si no hay mas elementos. La primera llamada devuelve el
primer elemento.
 hasMoreElements() devuelve true si no se ha accedido a todos los elementos de la
colección.
 ITERADOR ENUMERATION(II)
 Las colecciones históricas: Vector, Stack, Dictionary, HashTable disponen del
método elements() que devuelve un Enumeration, a partir del cual se puede
recorrer la colección. La declaración del método es la siguiente:
Enumeration elements()
 El esquema que se sigue para acceder a cada elemento de una colección consta de los
siguientes pasos:
1. Declarar una variable Enumeration.
Enumeration enumera;
2. Llamar al método elements() de la colección.
enumera = coleccion.elements()
3. Diseñar el bucle que obtiene y procesa cada elemento.
while (enumera.hasMoreElements())
{
elemento = (TipoElemento) enumera.nextElement();
<proceso de elemento>
}
 EJEMPLO ENUMERATION(I)
 Se crea una pila de diferentes objetos, posteriormente, se recorre con un iterador
Enumeration y con métodos de Stack .
 Programa:
import java.util.*;
import java.io.*;
public class EnumeradorPila
{
public static void main(String[] args)
{
final int N = 8;
Stack pila = new Stack();
String [] palabra = {"Urbion", "Magina", "Abantos", "Peralte", "Citores" };
for (int i = 0; i < N; i++)
{
int n;
n = (int)(Math.random()*N*2);
if (n < palabra.length)
pila.push(palabra[n]);
 else if (n < N+2)
pila.push(new Double(Math.pow(n, 2)));
else
pila.push(new Integer(n * 3));
}
// crea un enumerador de la pila
Enumeration enumera = pila.elements();
System.out.println("Elementos de la pila " +
"en el orden establecido por el enumerador:");
while (enumera.hasMoreElements())
{
Object q;
q = enumera.nextElement();
System.out.print(q + " ");
}
System.out.println("\nElementos de la pila en orden LIFO:");
while (!pila.empty())
{
Object q;
q = pila.pop();
System.out.print(q + " ");
}
}
}
 COLECCIÓN DE TIPO LISTA
 Una lista es una agrupación lineal de elementos, que pueden duplicarse. A una
lista se añade elementos por la cabeza, por el final, en general por cualquier
punto. También, se permite eliminar elementos de uno en uno, o bien todos
aquellos que estén en una colección.
 La estructura jerárquica:
 LISTAS
 El concepto general de lista está representado por el interface List, este
interface es la raíz de la jerarquía y por conversión automática toda colección
de tipo lista se puede tratar con una variable de tipo List.
List lista;
lista = new ArrayList();
lista = new LinkedList();
 AbstractList es una clase abstracta que se utiliza como esqueleto para
implementar clases concretas con la característica de acceso aleatorio a los
elementos, como un array.
 La clase ArrayList es una clase concreta que deriva de AbstractList, se
utiliza para almacenar cualquier tipo de elementos, incluso está recomendado
su uso en lugar de Vector.
 AbstractSequentialList es la clase abstracta utilizada para implementar
clases concretas de acceso secuencial, es decir para clases que representen a
listas enlazadas. LinkedList es una clase concreta que permite agrupar
objetos y organizarlos en forma de lista doblemente enlazada.
 MÉTODOS DE LISTAS(I)
 Métodos para añadir:
boolean add(Object ob); // añade al final
void add (int índuce, Object ob); // inserta y desplaza
boolean addAll(Collection c);
Object set (int i, Object ob); // devuelve elemento i-ésimo
// y lo reemplaza por ob

 Métodos para eliminar:

boolean remove(Object o);
Object remove(int índice); // devuelve elemento índice y lo elimina
boolean removeAll(Collection c);
void clear();

 Método para recuperar:

Object get (int índice);
 MÉTODOS DE LISTAS(II)
 Métodos de búsqueda:
Devuelven true si la colección contiene al elemento o elementos argumento.
boolean contains(Object o);
boolean containsAll(Collection c);
boolean equals(Object o);
 Métodos de colección
Todas las colecciones implementan el método iterator() que devuelve un
objeto Iterator para recorrer la colección. El método toArray() devuelve
un array con los elementos de la colección.
Object[] toArray();
Iterator iterator();
boolean isEmpty();
int size();
 COLECCIÓN ArrayList
 Esta clase agrupa elementos como un array. Es equivalente a Vector, pero
con las mejoras introducidas por Java 2. Se puede acceder a cualquier
elemento, insertar o borrar a partir del índice en cualquier posición.
 La clase ArrayList tiene tres constructores:
public ArrayList();
public ArrayList(int capacidad);
public ArrayList(Collection c);
Por ejemplo, se crea una colección con los elementos de un vector:
Vector v = new Vector();
ArrayList al = new ArrayList(v);
 ArrayList implementa los métodos del interface List, también el método
clone() del interface Cloneable para poder crear una copia independiente
de la colección.
 EJEMPLO DE ArrayList
 Se realizan las operaciones de añadir, eliminar, buscar y reemplazar con una colección de
tipo ArrayList. La colección va a estar formada por cadenas (String) leídas del
teclado. Una vez formada la colección es eliminada una cadena concreta y se reemplaza
el elemento que ocupa la posición central.
Análisis
Para realizar una búsqueda se utiliza el método indexOf() que devuelve la posición que
ocupa, o bien -1, a partir de esta posición se crea un iterador llamando al método
listIterator() con el fin de recorrer y, a la vez, escribir los elementos.

ListaArray .java
import java.util.*;
import java.io.*;
public class ListaArray
{
public static void main(String[] args)
{
BufferedReader entrada = new BufferedReader( new
InputStreamReader(System.in)); (continúa)
List av = new ArrayList();
String cd;
System.out.println("Datos de entrada (adios para acabar)");
try {
do {
cd = entrada.readLine();
if (! cd.equalsIgnoreCase("adios"))
av.add(cd);
else break;
} while (true);
System.out.println("Lista completa:" + av);
// elimina una palabra
System.out.println("Palabra a eliminar: ");
cd = entrada.readLine();
if (av.remove(cd))
System.out.println("Palabra borrada, lista actual: + av");
else
System.out.println("No esta en la lista la palabra");
// reemplaza elemento que está en el centro
(continúa)
 av.set(av.size()/2, "NuevaCadena");
System.out.println("Lista completa:" + av);
// busqueda de una palabra
System.out.println("Búsqueda de una palabra: ");
cd = entrada.readLine();
int k = av.indexOf(cd);
// crea iterador y recorre la lista hacia adelante
if(k >= 0)
{
System.out.println("Recorre la lista a partir de k: "+k);
ListIterator ls = av.listIterator(k);
while(ls.hasNext())
{
System.out.print((String)ls.next() + " ");
}
}
}
catch(Exception e) {;}
}
}
 ITERATOR
 Java 2 desarrolla nuevas colecciones y el iterador común Iterator. Todo objeto
colección se puede recorrer con este iterador. Todas las colecciones disponen del método
iterator() que devuelve un objeto Iterator.
 El interface Iterator permite no solo acceder a los elementos, también
eliminarlos. Pertenece al paquete java.util, la declaración es la siguiente:
public interface Iterator
{
boolean hasNext();
Object next();
void remove();
}

hasNext()devuelve true si quedan elementos no visitados.

next() desvuelve el siguiente elemento, la primera llamada devuelve el primer
elemento.
remove()elimina de la colección el elemento obtenido por la última llamada a next()
 EJEMPLO ITERATOR
 Dada una lista de puntos del plano se quiere eliminar de la lista aquellos cuya coordenada
x esté fuera del rango [2, 12].
Análisis
Se supone declarada la clase Punto con el método int getX(), y que la lista ya está
creada. La lista es del tipo ArrayList. El fragmento de código escrito declara la lista y
el iterador; realiza un bucle controlado por hasNext() para acceder a cada elemento y
si la coordenada x no está en el rango [2, 12] lo elimina llamando al método remove().
Codificación
class Punto{...}
List lista = new ArrayList();

Iterator iter;
iter = lista.iterator();
(continúa)
 while (iter.hasNext())
{
Punto q;
q = (Punto)iter.next();
if (q.getX() < 2 || q.getX() > 12)
{
System.out.println("Punto: " + q + " se elimina");
iter.remove();
}
}
 Con Java 1.5 se puede parametrizar el tipo de los elementos, de tal forma que no es necesario
realizar la conversión y, además, el compilador verifica el tipo de los elementos añadidos. A
continuación se escribe el código con esta característica.
List<Punto> lista = new ArrayList<Punto>();
Iterator<Punto> iter;
iter = lista.iterator();
while (iter.hasNext()){
Punto q;
q = iter.next(); // no es necesario una conversión(cast)
....
 COLECCIONES PARAMETRIZADAS(I)
 Las colecciones históricas y las desarrolladas en Java 2 guardan, internamente, los elementos en
arrays de tipo Object. Con esto se consigue la máxima generalización ya que Object es la clase
base de cualquier objeto. Al recuperar elementos de la lista es necesario discernir el tipo concreto
de elemento. Por ejemplo:
LinkedList lis = new LinkedList();
lis.add (new Racional(2,9));
lis.addLast(new String("Mi globo"));

Al recuperar elementos de la lista:

Object q;
Racional t;

q = lis.getFirst();
if (q instanceof Racional)
t = (Racional) q;

...
 COLECCIONES PARAMETRIZADAS(II)
 En muchas aplicaciones de colecciones los elementos son del mismo tipo. Por esta razón, y otras
como que el compilar pueda realizar comprobaciones de tipo, Java 1.5 amplía la declaración de
todas las clases e interfaces relacionados con colecciones para dotarlas de la posibilidad de
parametrizar el tipo que va a tener los elementos de una colección.
Por ejemplo:
Vector<Complex> zz;
zz = new Vector<Complex>(19);
ArrayList<Bebida> aa = new ArrayList<Bebida> ();
aa.add(new Empleado()); // error

Sintaxis
Coleccion<tipo1...> var;
Para crear instancias,
new Coleccion<tipo1...>();
Por ejemplo:
Set<Integer> cn = new TreeSet<Integer>();