63 – Java - Ejemplos

63 – REPASO DE JAVA CON EJERCICIOS RESUELTOS

1. Ejemplo de programa en Java

public class PrimerPrograma

{
public static void main(String[ ] args)
{
// visualizar un mensaje de saludo
System.out.println("¡ Hola, Mundo !");
} // fin del método main
} // fin de la clase PrimerPrograma

2. Declaración de constantes

final double VALOR_DESCUENTO = 14.50;

final double IVA = 16;
final double EURO = 166.67;

public class MercadoValores

{
// métodos
...
// constantes
public static final double PESO = 0.55;
public static final double EURO = 1.55;
}

3. Concatenación de cadenas.

String nombre = "Sierra de Horche";

String frase;
frase = nombre + " es muy bella";
System.out.println(frase);

4. Uso de cadenas en Java

String saludo = "Hola Mackoy";

String cad = saludo.substring(0,4);

String saludo = "hola Mortimer";

System.out.println("La longitud es " + saludo.length ( ));

s.equals(t); //devuelve true si las cadenas s y t son iguales; false

en caso contrario.
"Hola".equals(saludo) //sentencia válida.

//Otras comparaciones realizadas con equals:

String saludo = "Hola";
saludo.equals("Hola"); //devuelve true

saludo.equals("Adios"); //devuelve false

saludo.equals("hola"); //devuelve false ya que Hola y hola no son
iguales

1
 FJCM

5. Métodos de la clase String

String saludo = "¡Hola Mackoy!";

saludo.charAt(0); //devuelve ¡
saludo.charAt(1); //devuelve H

String entrada = "albaricoque";

entrada.compareTo("margarita"); //devuelve un número negativo
entrada.compareTo("albaricoque "); //devuelve cero
entrada.compareTo("amnesia "); //devuelve un número positivo

String entrada = "albaricoque";

entrada.compareToIgnoreCase("margarita"); //devuelve un número
negativo
entrada. compareToIgnoreCase("Albaricoque "); //devuelve cero
"Margarita".compareToIgnoreCase(entrada);
//devuelve un número positivo

6. Salida a la consola

System.out.print("Veracruz ");
System.out.print(" Puerto La Cruz");
System.out.println(" y ");
System.out.print("Playa del Cura ");

7. Entrada

Scanner entrada = new Scanner(System.in);

/*A continuación se pueden utilizar diferentes métodos de la clase
Scanner para leer la entrada: nextInt
o nextDouble leen el siguiente entero y siguiente valor de coma
flotante.*/
System.out.print("Introduzca cantidad: ");
int cantidad;
cantidad = entrada.nextInt( );
System.out.print("Introduzca precio: ");
double precio = entrada.nextDouble( );

8. Ejemplo de programa que realiza entrada y salida por consola

import java.util.Scanner;
/**Este programa muestra la entrada por consola
y ha sido creado el 24 de marzo*/
public class EntradaTest
{
public static void main(String [ ] args)
{
Scanner entrada = new Scanner(System.in);
// obtener la primera entrada
System.out.print("¿ Cual es su nombre?");
String nombre = entrada.nextLine ( );
// leer la segunda entrada
System.out.print("¿ Cual es su edad?");
int edad = entrada.nextInt( );
// visualizar salida
System.out.println("Buenos días " + nombre + "; años " +
edad);
}
}

2
 63 – Java - Ejemplos

9. Si se desea hacer que cada array tenga una longitud diferente, se puede crear un array irregular.
Las siguientes declaraciones crean un arreglo irregular num1 en el que cada fila tiene una
longitud (columnas) diferente.

double [ ][ ] num1;
num = new double [3][ ];
num1[0] = new double [5];
num2[1] = new double [6];
num3[2] = new double [7];

10. Uso de ArrayLIst. la clase ArrayList permite reunir (coleccionar) objetos como si fueran tipos de
datos básicos. La lista de array ofrece dos ventajas:
• La lista de arrays puede crecer y reducirse a medida que se necesita.
• La clase ArrayList proporciona métodos para las tareas comunes.

//El siguiente arreglo calcula el valor total de todas las cuentas

de un banco.
ArrayList <CuentaBanco> cuentas = new ArrayList <CuentaBanco>( );
double suma = 0.0;
for (CuentaBanco c : cuentas)
{
suma = suma + c.leerSaldo( );
}
//Este bucle es equivalente al siguiente bucle ordinario:
double suma = 0.0;
for (int j = 0; j < cuentas.size ( ); j++) {
CuentaBanco c = cuentas.get( j );
suma = suma + c.leerSaldo( );
}

11. Definición de una clase llamada Punto que contiene las coordenadas x y y de un punto en
un plano.

class Punto {
private int x; // coordenada x
private int y; // coordenada y
public Punto(int x_,int y_) // constructor
{
x = x_;
y = y_;
}
public Punto( ) // constructor sin argumentos
{
x = y = 0;
}
public int leerX( ) // devuelve el valor de x
{
return x;
}
public int leerY( )[ // devuelve el valor de y
return y;
}
void fijarX(int valorX){ // establece el valor de x
x = valorX;
}
void fijarY(int valorY) // establece el valor de y
{
y = valorY;
}
}

3
 FJCM

12. Declaración de la clase Edad.

class Edad {
private int edadHijo, edadMadre, edadPadre ; //datos
public Edad( ) {...} //método especial: constructor
public void iniciar(int h,int e,int p) {...} ⎯⎯ métodos
public int leerHijo( ) {...}
public int leerMadre( ) {...}
public int leerPadre( ) {...}
}

13. Declaración de la clase Foto y Marco con miembros declarados con distinta visibilidad.
Ambas clases forman parte del paquete soporte.

package soporte;
class Foto {
private int nt;
private char opd;
String q;
public Foto(String r) // constructor
{
nt = 0;
opd = 'S';
q = new String(r);
}
public double mtd( ){...}
}

class Marco {
private double p;
String t;
public Marco( ) {...}
public void poner( ){
Foto u = new Foto("Paloma");
p = u.mtd( );
t = "**" + u.q + "**";
}
}

14. La clase Racional define el numerador y denominador característico de un número racional. Por
cada dato se proporciona un método miembro que devuelve su valor y un
método que asigna numerador y denominador. Tiene un constructor que inicializa
un objeto a 0/1.

class Racional
{
private int numerador;
private int denominador;
public Racional( )
{
numerador = 0;
denominador = 1;
}
public int leerN( ) { return numerador; }
public int leerD( ) { return denominador; }
public void fijar (int n, int d)
{
numerador = n;
denominador = d;
}

4
 63 – Java - Ejemplos

15. La clase EquipoSonido se define con tres constructores; un constructor por defecto, otro
con un argumento de tipo cadena y el tercero con tres argumentos.

public class EquipoSonido

{
private int potencia;
private int voltios;
private int numCd;
private String marca;
public EquipoSonido( ) // constructor por defecto
{
marca = "Sin marca";
System.out.println("Constructor por defecto");
}
public EquipoSonido(String mt)
{
marca = mt;
System.out.println("Constructor con argumento cadena ");
}
public EquipoSonido(String mt, int p, int v)
{
marca = mt;
potencia = p;
voltios = v;
numCd = 20;
System.out.println("Constructor con tres argumentos ");
}
public double factura( ){...}
};

16. La clase SumaSerie define tres variables static, y un método static que calcula la
suma cada vez que se llama.

class SumaSerie
{
private static long n;
private static long m;
static
{
n = 0;
m = 1;
}
public static long suma( )
{
m += n;
n = m − n;
return m;
}
}

5
 FJCM

17. La clase Conjunto implementa el TAD Conjunto. Las operaciones que define son: añadir un
elemento, retirar un elemento, pertenencia de un elemento y unión. Se puede enriquecer la clase
con la operación intersección, diferencia de conjuntos y otras operaciones típicas de los
conjuntos. La clase representa los datos de forma genérica, utiliza un arreglo para almacenar los
elementos, de tipo Object.

package conjunto;
public class Conjunto
{
static int M = 20; // aumento de la capacidad
private Object [ ] cto;
private int cardinal;
private int capacidad;
// operaciones
public Conjunto( )
{
cto = new Object[M];
cardinal = 0;
capacidad = M;
}
public boolean esVacio( )
{
return (cardinal == 0);
}
public void annadir(Object elemento)
{
if (!pertenece(elemento))
{
/* verifica si hay posiciones libres,
en caso contrario amplía el conjunto */
if (cardinal == capacidad)
{
Object [ ] nuevoCto;
nuevoCto = new Object[capacidad + M];
for (int k = 0; k < capacidad; k++)
nuevoCto[k] = cto[k];
capacidad += M;
cto = nuevoCto;
System.gc( ); // devuelve la memoria no referenciada
}
cto[cardinal++] = elemento;
}
}
public void retirar(Object elemento)
{
if (pertenece(elemento))
{
int k = 0;
while (!cto[k].equals(elemento))
k++;
/* desde el elemento k hasta la última posición
mueve los elementos una posición a la izquierda */
for (; k < cardinal ; k++)
cto[k] = cto[k+1];
cardinal−−;
}
}

6
 63 – Java - Ejemplos

public boolean pertenece(Object elemento)

{
int k = 0;
boolean encontrado = false;
while (k < cardinal && !encontrado)
{
encontrado = cto[k].equals(elemento);
k++;
}
return encontrado;
}
public int cardinal( )
{
return this.cardinal;
}
public Conjunto union(Conjunto c2)
{
Conjunto u = new Conjunto( );
// primero copia el primer operando de la unión
for (int k = 0; k < cardinal; k++)
u.cto[k] = cto[k];
u.cardinal = cardinal;
// añade los elementos de c2 no incluidos
for (int k = 0; k < c2.cardinal; k++)
u.annadir(c2.cto[k]);
return u;
}
public Object elemento(int n) throws Exception
{
if (n <= cardinal)
return cto[−−n];
else
throw new Exception("Fuera de rango");
}
}

18. El programa crea un conjunto de números racionales y realiza operaciones definidas en la clase
Conjunto. Se añade una operación complementaria para visualizar los elementos del conjunto.
También se declara la clase Racional para representar a este tipo de números.

import java.io.*;
import conjunto.*;
import java.util.Random;
class Racional{
private int n, d;
public Racional(int num, int den)throws Exception
{
if (den == 0)
throw new Exception("Error: denominador 0");
n = num;
d = den;
}
public Racional( ) {
n = 0; d = 1;
}
public String toString( ){
String racs;
racs = n + "/" + d;
return racs;
}
};

7
FJCM

class ConjuntoRacional
{
public static void main(String [ ] ar)
{
final int NELEM = 10;
Conjunto cn1, cn2, t;
Racional r;
int n, d;
cn1 = new Conjunto( );
cn2 = new Conjunto( );
Random a = new Random( );
try {
for (int j = 1; j <= NELEM; j++)
{
n = a.nextInt(15); // numerador;
d = a.nextInt(15); // denominador;
if (d != 0)
{
r = new Racional(n,d);
cn1.annadir(r);
}
}
mostrar(cn1);
// se crea un segundo conjunto
for (int j = 1; j <= NELEM; j++)
{
n = a.nextInt(15); // numerador;
d = a.nextInt(15); // denominador;
if (d != 0)
{
r = new Racional(n,d);
cn2.annadir(r);
}
}
mostrar(cn2);
// union de conjuntos
System.out.println(" Conjunto unión");
t = cn1.union(cn2);
mostrar(t);
}
catch (Exception er)
{
System.err.println("Error en ejecución: " + er);
}
}
static void mostrar(Conjunto c) throws Exception
{
System.out.println("\t\tElementos del conjunto ");
for (int k = 1; k <= c.cardinal( ); k++)
{
System.out.print(c.elemento(k) + " ");
if (k % 10 == 0) System.out.println( );
}
System.out.println( );
}
}

8
 63 – Java - Ejemplos

19. Uso de herencia en Java. Declaración de las clases Programador y Triangulo.

class Programador extends Empleado

{
public miembro público
// miembros públicos
private miembro privado
// miembros privados
}

// Otro ejemplo
class Triangulo extends Figura
{
public
// miembros públicos
protected
// miembros protegidos
...
}

20. Considerar una clase Prestamo y tres clases derivadas de ella: PagoFijo, PagoVariable e
Hipoteca.

La clase Prestamo es la clase base de la PagoFijo, PagoVariable e Hipoteca, se considera

que es una clase abstracta, en ella se agrupan los métodos comunes a todo tipo de préstamo:
hipoteca, ... . La declaración de Prestamo:

abstract class Prestamo

{
final int MAXTERM = 22;
protected float capital;
protected float tasaInteres;
public void prestamo(float p, float r) { ...}
abstract public int crearTablaPagos(float mat [ ] [ ]);
}
/* Las variables capital y tasaInteres no se repiten en la clase
derivada.
La declaración de las clases derivadas: */
class PagoFijo extends Prestamo
{
private float pago; // cantidad mensual a pagar por cliente
public PagoFijo (float x, float v, float t) { ... }
public int crearTablaPagos(float mat [ ] [ ] ) { ... }
}
class PagoVariable extends Prestamo
{
private float pago; // cantidad mensual a pagar por cliente
public PagoVariable (float x, float v, float t) { ...}
public int crearTablaPagos(float mat [ ][ ] ) { ...}
}

9
 FJCM

class Hipoteca extends Prestamo

{
private int numRecibos;
private int recibosPorAnyo;
private float pago;
public Hipoteca(int a, int g, float x, float p, float r) { ...}
public int crearTablaPagos(float mat [ ] [ ] ){ ...}
}

21. Se declara una clase base con el método escribe( ) y una clase derivada con el mismo
nombre del método pero distintos argumentos. La clase con el método main( ) crea objetos y
realiza llamadas a los métodos sobrecargados de la clase derivada.

class BaseSobre
{
public void escribe(int k)
{
System.out.print("Método clase base, argumento entero: ");
System.out.println(k);
}
public void escribe(String a)
{
System.out.print("Método clase base, argumento cadena: ");
System.out.println(a);
}
}
class DerivSobre extends BaseSobre
{
public void escribe(String a, int n)
{
System.out.print("Método clase derivada, dos argumentos: ");
System.out.println(a + " " + n);
}
}
public class PruebaSobre
{
public static void main(String [ ] ar)
{
DerivSobre dr = new DerivSobre ( );
dr.escribe("Cadena constante ",50);
dr.escribe("Cadena constante ");
dr.escribe(50);
}
}

22. Se declaran dos clases base, una clase derivada de una clase base y una clase derivada de
una clase base que a su vez es derivada

class B1
{
public B1( ) { System.out.println("Constructor-B1"); }
}
class B2
{
public B2( ) { System.out.println("Constructor-B2");}
}
class D extends B1{
public D( ) { System.out.println("Constructor-D”); }
}

10
 63 – Java - Ejemplos

class H extends B2
{
public H( ) { System.out.println("Constructor-H"); }
}
class Dh extends H
{
public Dh( ) { System.out.println("Constructor-Dh"); }
}
class Constructor
{
public static void main(String [ ] ar)
{
D d1 = new D( );
System.out.println("_______________\n");
Dh d2 = new Dh( );
}
}

23. La clase Punto3D es una clase que deriva de la clase Punto.

En la clase Punto3D se definen dos constructores, el primero sin argumentos, que
inicializa un objeto al punto tridimensional (0,0,0); esto lo hace en dos etapas, primero
llama al constructor por defecto de Punto, y a continuación asigna 0 a z (tercera coordenada). El
segundo constructor llama, con super(x1, y1), al constructor de Punto.

class Punto
{
public Punto ( )
{
x = y = 0;
}
public Punto(int xv, int yv)
{
x = xv;
y = yv;
}
protected int x, y;
}
class Punto3D extends Punto
{
public Punto3D ( )
{
// llamada implícita al constructor por defecto de Punto
// Se podría llamar explícitamente: super(0,0);
fijarZ(0);
}
public Punto3D(int x1, int y1, int z1)
{
super(x1,y1);
fijarZ(z1);
}
private void fijarZ(int z) {this.z = z;}
private int z;
}

11
 FJCM

24. La clase Fecha define el método escribir( ), la clase FechaJuliana hereda de la clase Fecha y
sobreescribe el método.

class Fecha
{
private int d, m, a;
public Fecha(int dia, int mes, int anyo)
{
d = dia;
m = mes ;
a = anyo;
}
public Fecha( ) { }
public void escribir( )
{
System.out.println("\n" + d +" / " + m + " / " + a);
}
}
class FechaJuliana extends Fecha
{
private int numDias;
public FechaJuliana(int dia, int mes, int anyo){...}
public void escribir( )
{
super.escribir( ); // llamada al método de la clase Fecha
System.out.println("Dias transcurridos: " + numDias);
}
}

25. Se declara la interfaz Bolsa y clases que implementan la interfaz.

interface Bolsa
{
Bolsa insertar(Object elemento);
}
public class Bolsa1 implements Bolsa
{
public Bolsa insertar(Object e) { ... }
}
public class Bolsa2 implements Bolsa
{
public Bolsa insertar(Object e) { ... }
}

/*En un método se puede definir una variable del tipo interface Bolsa
y asignar un objeto Bolsa1, o bien un objeto Bolsa2. */
Bolsa q;
q = new Bolsa1( );
q.insertar("Manzana");
...
q = new Bolsa2 ( );
q.insertar (Racional(2.5));

12
 63 – Java - Ejemplos

26. Considerar una aplicación en la que se debe almacenar n objetos del tipo Punto2D, Punto3D y
PuntoPolar. Se realiza un almacenamiento secuencial, para ello se declara una arreglo de tipo
Object. De esa forma se puede asignar cualquier objeto. El problema surge al recuperar los
elementos del arreglo, se debe hace un cast al tipo clase, que puede ser Punto2D, Punto3D y
PuntoPolar.

class Punto2D { ... }

class Punto3D { ... }
class PuntoPolar { ... }

//Declaración y creación del array de N elementos:

final int N = 99;
Object [ ] rr = new Object[N];
int i = 0;

//Asignación secuencial de objetos:

mas = true;
while (mas && (i < N))
{
int opc;
opc = menu( );
if (opc == 1)
rr[i++] = new Punto2D( );
else if (opc == 2)
rr[i++] = new Punto3D( );
if (opc == 3)
rr[i++] = new PuntoPolar( );
else mas = false;
}

27. Declarar la clase Racional para representar un número racional (numerador, denominador) y
llenar un array de objetos de esa clase. A continuación, ordenar de forma creciente el arreglode
números racionales.La clase Racional tiene dos atributos de tipo int: numerador y denominador.
Implementa lainterfaz Comparable para poder realizar la ordenación con el método Arrays.sort (
). Por elloes necesaro definir el método int compareTo ( ) de tal forma que devuelva -1, 0, 1 si el
número racional primer operando (this) es menor, igual o mayor, respectivamente que el número
racionalpasado como argumento.

import java.util.*;
class Racional implements Comparable
{
private int numerador, denominador;
public Racional ( ) throws Exception 2
{
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;
}

13
FJCM

public int compareTo(Object x) // método de interfaz

{
Racional r;
r = (Racional) x;
if (valorReal ( ) < r.valorReal ( ))
return −1;
else if (valorReal ( ) > r.valorReal ( ))
return 1;
else
return 0;
}
private double valorReal ( )
{
return (double)numerador/(double)denominador;
}
// ...
}
// clase principal, crea los objetos de manera aleatoria,
// se escriben en pantalla, a continuación se ordena, y por último
// se vuelve a escribir.
public class OrdenaRacional
{
static int MR = 7;
public static void main(String [ ] a)
{
Racional [ ] ar = new Racional[MR];
try {
// numerador y denominador se genera aleatoriamente
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) {;}
// listado de los objetos creados
System.out.println(" Lista de numeros racionales: ");
escribe(ar);
// ordenación del array
Arrays.sort(ar);
// 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 ( );
}
}

14
 63 – Java - Ejemplos

28. Definir un arreglo de enteros, inicializar la primera mitad a -1 y la segunda mitad a +1.
Además, inicializar un arreglo de caracteres a la letra ‘a’ y un arreglo de cadenas a “Paloma”.
Se definen arreglos de los tipos pedidos y de tamaño constante. Para inicializar la primera mitad
del array a[ ] hay que especificar el índice inicio = 0 y final = a.length/2; la otra mitad
tiene como inicio el anterior final.

static final int N = 10;

int [ ] iv = new int[N];
char [ ] cv = new char [N];
String [ ] sv = new String [N];
// llenado de los arrays
Arrays.fill (iv, 0, iv.length/2, −1);
Arrays.fill (iv, iv.length/2, iv.length 1);
Arrays.fill (cv, 'a');
Arrays.fill (sv, "Paloma");

29. Se realizan diversas operaciones utilizando métodos de la clase Collections: crear una
lista a partir de la copia n veces de una cadena, ordenar una lista de objetos Integer, buscar el
máximo, etcétera Se escribe el método main ( ) con las operaciones nCopies ( ), sort ( ), max ( ),
min ( ) y reverse ( ). La declaración de la lista de objetos especifica que el tipo de los elementos
es Integer. De esa forma el compilador realiza comprobaciones de tipo. También se puede
realizar de forma genérica: List lista = new ArrayList ( ); de tal forma que se podría añadir
cualquier tipode objeto.

public static void main(String [ ] args)

{
int n = 11;
List lista1;
// Crea una lista formada por n copias de "Marga"
lista1 = Collections.nCopies(n, "Marga");
System.out.println (lista1);
// Crea una lista de objetos Integer, se ordena y se invierte
List<Integer> lista2 = new ArrayList<Integer>( );
for (int i = 1; i <= n ; i++)
lista2.add (new Integer ((int)(Math.random( )*100 +1)));
System.out.println (lista2);
System.out.println ("Máximo: " + Collections.max(lista2)
+ " \t Mínimo: " +
Collections.min(lista2));
Collections.sort (lista2);
System.out.println (lista2);
Collections.reverse (lista2);
System.out.println (lista2);
}

30. El método compare ( ) relaciona dos objetos, no necesariamente del mismo tipo. Devolverá un
negativo si el objeto ob1 es menor que el segundo objeto, cero si son iguales, y positivo si ob1
es mayor
que ob2. El comportamiento de compare ( ) tiene que ser compatible con el resultado del método
equals ( ), es decir, si este devuelve true, compare ( ) tendrá que devolver 0. Por ejemplo:

class Cuadro
{
int largo;
int ancho;
...
}

15
 FJCM

class Compara implements Comparator

{
public int compare (Object ob1, Object ob2)
{
Cuadro c1 = (Cuadro) ob1;
Cuadro c2 = (Cuadro) ob2;
if (c1.largo == c2.largo && c1.ancho == c2.ancho)
return 0;
else
// c1 es menor que c2 si, en superficie, c1 es menor
return (c1.largo * c1.ancho) − (c2.largo * c2.ancho);
}

/*Se puede ordenar un array, o una lista, de cuadros pasando al método

sort ( )
el objeto comparador:

Cuadro [ ] vcdos = new Cuadro[N];

Arrays.sort (vcdos, new Compara ( )); */

31. Mediante una pila se analiza si una palabra o frase es palíndromo.Se lee la palabra del teclado
y a la vez cada carácter se guarda en una pila. Los elementos de la pila han de ser de tipo
Character, por consiguiente su declaración es: Stack<Character> pila.

import java.util.*;
import java.io.*;
public class Palindromo {
public static void main(String [ ] args) {
Scanner entrada = new Scanner (System.in)
Stack<Character> pila;
String palabra;
boolean pal;
pila = new Stack<Character> ( );
try {
System.out.println("Palabra o frase: ");
while ((palabra = entrada.nextLine ( )) != null)
{
for (int i = 0; i < palabra.length ( ); i++)
{
pila.push (new Character(palabra.charAt (i)));
}
pal = true;
int i = 0;
while (pal && !pila.empty ( ))
{
Character q;
q = pila.pop ( );
pal = q.charValue ( ) == palabra.charAt (i++);
}
if (pal && pila.empty ( ))
System.out.println (palabra + " es un
Palíndromo");
else
System.out.println (palabra + " no es un
palíndromo");
}
}
catch (Exception e) {;}
}
}

16
 63 – Java - Ejemplos

32. Se crea una pila de diferentes objetos, posteriormente, se recorre con un iterador Enumeration y
con métodos de Stack. La pila se llena de objetos String, Integer y Double, sin un orden
establecido. Para recorrer la pila se crea un enumerador y un bucle hasta que no queden más
elementos sin visitar. También se recorre aplicando la operación pop ( ) y controlando que no
esté vacía.

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 ( );
// bucle para recorrer la pila
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 + " ");
}
// bucle para recorrer la pila
System.out.println ("\nElementos de la pila en orden LIFO:");
while (!pila.empty ( ))
{
Object q;
q = pila.pop ( );
System.out.print (q + " ");
}
}
}

33. Dada una lista de puntos del plano se quiere eliminar de la lista aquellos cuya coordenadax esté
fuera del rango [2, 12].Se da por declarada la clase Punto con el método int getX ( ), y que la lista
de puntos 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 noestá en el rango [2, 12] lo elimina llamando al método remove ( ).

class Punto {...}

List lista = new ArrayList ( );
Iterator iter;
// se llena la lista de objetos Punto

17
 FJCM

iter = lista.iterator ( );
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 ( );
}
}

34. 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. Para realizar una búsqueda se utiliza el método indexOf ( ) que devuelve la
posición queocupa, o bien -1; a partir de esta posición se crea un iterador llamando al método
iterator( ) conel fin de recorrer y, a la vez, escribir los elementos.

import java.util.*;
import java.io.*;
public class ListaArray {
public static void main(String [ ] args){
Scanner entrada = new Scanner (System.in));
List av = new ArrayList ( );
String cd;
System.out.println ("Datos de entrada (adios para acabar)");
try {
do {
cd = entrada.nextLine ( );
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.nextLine( )
if (av.remove (cd) )
System.out.println ("Palabra borrada,lista actual: +
v");
else
System.out.println ("No esta en la lista la palabra");
// reemplaza elemento que está en el centro
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.nextLine( );
int k = av.indexOf (cd);
// crea iterador y recorre la lista hacia adelante
if (k >= 0){
System.out.println ("Recorre la lista ");
Iterator ls = av.iterator ( );
while (ls.hasNext ( ) ){
System.out.print ((String)ls.next ( ) + " ");
}
}
}
catch(Exception e) {;}
}
}

18