Estructuras de Datos
Código fuente de explicaciones
Código fuente online
Clase sobre Excepciones, Genericidad e Interfaces.
* * *
Excepciones
Ejemplo Calculadora
A continuación se puede observar el código fuente utilizado para ejemplificar el manejo de excepciones.
-
Package Calculadora
package Calculadora;
/**
* Modela las operaciones de una calculadora.
* @author Federico Joaquín (federico.joaquin@cs.uns.edu.ar)
*/
public class Calculadora {
/**
* Computa la división real entre dos valores.
* @param dividendo Valor del dividendo de la división.
* @param divisor Valor del divisor de la división.
* @return Resultado de aplicar la división.
* @throws DivisionPorCero en caso que divisor sea cero.
*/
public static float dividir(float dividendo, float divisor) throws DivisionPorCero{
if (divisor == 0) throw new DivisionPorCero("Error");
return dividendo/divisor;
}
/**
* Computa la suma real entre dos valores.
* @param op1 Operando 1 de la suma.
* @param op2 Operando 2 de la suma.
* @return Resultado de aplicar la suma.
*/
public static float sumar(float op1, float op2) {
return op1 + op2;
}
/**
* Computa la resta real entre dos valores.
* @param op1 Operando 1 de la resta.
* @param op2 Operando 2 de la resta.
* @return Resultado de aplicar la resta.
*/
public static float restar(float op1, float op2) {
return op1 - op2;
}
/**
* Computa la multiplicación real entre dos valores.
* @param op1 Operando 1 de la multiplicación.
* @param op2 Operando 2 de la multiplicación.
* @return Resultado de aplicar la multiplicación.
*/
public static float multiplicar(float op1, float op2) {
return op1 * op2;
}
/**
* Método que inicia la ejecución del programa.
* Testea las operaciones suma, resta, multiplicación y división con un caso de prueba simple.
* @param args Argumentos por línea de comandos.
*/
public static void main(String [] args){
float resultado = 0;
try {
resultado = dividir(10, 0);
System.out.println("El resultado de dividir 10 y 0 es: " + resultado);
} catch (DivisionPorCero e) {
System.out.println(e.getMessage());
}
resultado = sumar (10,10);
System.out.println("El resultado de sumar 10 y 10 es: " + resultado);
resultado = restar(25, 15);
System.out.println("El resultado de restar 25 y 15 es: " + resultado);
resultado = multiplicar (105, -2);
System.out.println("El resultado de multiplicar 105 y -2 es: " + resultado);
}
}
package Calculadora;
/**
* Modela la excepción ante una división por cero.
* @author Federico Joaquín (federico.joaquin@cs.uns.edu.ar)
*
*/
@SuppressWarnings("serial")
public class DivisionPorCero extends Exception {
/**
* Inicializa la excepción indicando el origen del error.
* @param msj Especifica información adicional a cerca de la excepción.
*/
public DivisionPorCero(String msj){
super(msj);
}
}
Excepciones
Ejemplo Transferencia
A continuación se puede observar el código fuente utilizado para ejemplificar el manejo de excepciones.
-
Package Transferencia
package Transferencia;
public class Cliente {
private float dinero_disponible;
private float maximo_permitido;
public Cliente(){
dinero_disponible = 0;
maximo_permitido = 5000;
}
public Cliente(float disponible){
dinero_disponible = disponible;
maximo_permitido = 5000;
}
public Cliente(float disponible, float permitido){
dinero_disponible = disponible;
maximo_permitido = permitido;
}
public float getDisponible(){
return dinero_disponible;
}
public void extraer(float monto) throws SinFondosException{
if ((dinero_disponible - monto) < 0)
throw new SinFondosException("No alcanzan los fondos para extraer en esta cuenta");
else
dinero_disponible -= monto;
}
public void depositar(float monto) throws SuperaMaximoException{
if (maximo_permitido < (dinero_disponible + monto))
throw new SuperaMaximoException("Se superó la maxima cantidad de dinero permitido en cuenta");
else
dinero_disponible += monto;
}
}
package Transferencia;
public class Banco {
public void transferir(Cliente CltA, Cliente CltB, float monto){
try {
CltA.extraer(monto);
} catch (SinFondosException e) {
System.out.println(e.getMessage());
}
try {
CltB.depositar(monto);
} catch (SuperaMaximoException e) {
System.out.println(e.getMessage());
}
}
public static void main(String [] args){
Banco b = new Banco();
Cliente cltA, cltB;
float transferir = 0;
//Caso prueba 1
System.out.println("Caso de prueba A:");
cltA = new Cliente(100);
cltB = new Cliente(100);
System.out.println("Inicial A: " + cltA.getDisponible());
System.out.println("Inicial B: " + cltB.getDisponible());
transferir = 50;
System.out.println("Se intentan transferir " + transferir + " pesos");
b.transferir(cltA, cltB, transferir);
System.out.println("Final A: " + cltA.getDisponible());
System.out.println("Final B: " + cltB.getDisponible());
System.out.println("-------------------------------------");
//Caso prueba 2
System.out.println("Caso de prueba 2:");
cltA = new Cliente(100);
cltB = new Cliente(5000);
System.out.println("Inicial A: " + cltA.getDisponible());
System.out.println("Inicial B: " + cltB.getDisponible());
transferir = 60;
System.out.println("Se intentan transferir " + transferir + " pesos");
b.transferir(cltA, cltB, transferir);
System.out.println("Final A: " + cltA.getDisponible());
System.out.println("Final B: " + cltB.getDisponible());
System.out.println("Observar el error en el manejo de excepciones para este caso de prueba");
System.out.println("-------------------------------------");
//Caso prueba 3
System.out.println("Caso de prueba 3:");
cltA = new Cliente(100);
cltB = new Cliente(200);
System.out.println("Inicial A: " + cltA.getDisponible());
System.out.println("Inicial B: " + cltB.getDisponible());
transferir = 150;
System.out.println("Se intentan transferir " + transferir + " pesos");
b.transferir(cltA, cltB, transferir);
System.out.println("Final A: " + cltA.getDisponible());
System.out.println("Final B: " + cltB.getDisponible());
System.out.println("Observar el error en el manejo de excepciones para este caso de prueba");
System.out.println("-------------------------------------");
}
}
package Transferencia;
public class SinFondosException extends Exception {
public SinFondosException(String msg){
super(msg);
}
}
package Transferencia;
public class SuperaMaximoException extends Exception {
public SuperaMaximoException(String msg){
super(msg);
}
}
Genericidad
Ejemplo Encapsulador
A continuación se puede observar el código fuente utilizado para ejemplificar la genericidad paramétrica.
-
Package Encapsulador
package Encapsulador;
public class Encapsulador <E> {
private E elemento;
public E getElemento(){ return elemento;}
public void setElemento(E e){ elemento = e;}
public static void main(String [] arg){
Encapsulador<Integer> encapInt = new Encapsulador<Integer>();
encapInt.setElemento(10);
Encapsulador<Float> encapFloat = new Encapsulador<Float>();
encapFloat.setElemento(10.5f);
System.out.println("Entero encapsulado: " + encapInt.getElemento());
System.out.println("Float encapsulado: " + encapFloat.getElemento());
}
}
Interfaces
Ejemplo Coleccion
A continuación se puede observar el código fuente utilizado para ejemplificar el uso de interfaces.
-
Package Colección
package Coleccion;
public interface Coleccion<E> {
public void insertar(E elemento);
public boolean pertenece (E elemento);
public void eliminar (E elemento);
public void mostrar();
}
package Coleccion;
public class ColeccionConArreglo<E> implements Coleccion<E>{
private E [] arreglo;
private int cantidad;
private final int capacidad_inicial = 100;
@SuppressWarnings("unchecked")
public ColeccionConArreglo(){
arreglo = (E[]) new Object[capacidad_inicial];
cantidad = 0;
}
public void insertar(E elemento) {
// Si el arreglo no tiene más capacidad, debe redimensionarse.
if (cantidad == arreglo.length )
resize();
// Chequeo para evitar elementos duplicados.
if (! pertenece(elemento) )
arreglo[cantidad++] = elemento;
}
public boolean pertenece(E elemento) {
boolean pertenece = false;
for(int i=0; i<cantidad && !pertenece; i++)
pertenece = (arreglo[i].equals(elemento));
return pertenece;
}
public void eliminar(E elemento) {
boolean encontre = false;
for(int i=0; i<cantidad && !encontre; i++){
if (arreglo[i].equals(elemento)) {
desplazar_izquierda_desde(i);
encontre = true;
cantidad--;
}
}
}
public void mostrar(){
for(int i = 0; i<cantidad; i++)
System.out.println("Coleccion["+(i+1)+"]= " + arreglo[i]);
}
@SuppressWarnings("unchecked")
private void resize(){
E [] arreglo_aux = (E[]) new Object[arreglo.length * 2];
for(int i=0; i<cantidad; i++)
arreglo_aux[i] = arreglo[i];
arreglo = arreglo_aux;
}
private void desplazar_izquierda_desde(int indice){
while(indice+1 < arreglo.length){
arreglo[indice] = arreglo[indice+1];
indice++;
}
arreglo[indice] = null;
}
}
package Coleccion;
import java.util.Vector;
public class ColeccionConVector<E> implements Coleccion<E>{
private Vector<E> vector;
public ColeccionConVector(){
vector = new Vector<E>();
}
public void insertar(E elemento) {
if (! vector.contains(elemento) )
vector.add(elemento);
}
public boolean pertenece(E elemento) {
return vector.contains(elemento);
}
public void eliminar(E elemento) {
vector.remove(elemento);
}
public void mostrar(){
for(int i = 0; i<vector.size(); i++)
System.out.println("Coleccion["+(i+1)+"]= " + vector.elementAt(i));
}
}
package Coleccion;
public class Tester {
public static void main(String [] args){
// Colección de enteros
Coleccion<Integer> col = new ColeccionConArreglo<Integer>();
//Coleccion<Integer> col = new ColeccionConVector<Integer>();
// Colección de floats
//Coleccion<Float> col = new ColeccionConArreglo<Float>();
//Coleccion<Float> col = new ColeccionConVector<Float>();
System.out.println("Agrega los elementos 1-10 a la colección");
for (int i=1; i<=10; i++)
col.insertar(i);
System.out.println("Coleccion inicial:");
col.mostrar();
System.out.println("¿Pertenece 5?: "+ col.pertenece(5));
System.out.println("Elimina elemento 5");
col.eliminar(5);
System.out.println("¿Pertenece 5?: "+ col.pertenece(5));
System.out.println("¿Pertenece 1?: "+ col.pertenece(1));
System.out.println("¿Pertenece 10?: "+ col.pertenece(10));
}
}
Código fuente online
Generación de documentación Javadoc.
* * *
Documentación Javadoc
Ejemplo Calculadora
A continuación se puede observar el código fuente utilizado para ejemplificar la documentación de código mediante la herramienta Javadoc.
-
Package Calculadora
package Calculadora;
/**
* Modela las operaciones de una calculadora.
* @author Federico Joaquín (federico.joaquin@cs.uns.edu.ar)
*/
public class Calculadora {
/**
* Computa la división real entre dos valores.
* @param dividendo Valor del dividendo de la división.
* @param divisor Valor del divisor de la división.
* @return Resultado de aplicar la división.
* @throws DivisionPorCero en caso que divisor sea cero.
*/
public static float dividir(float dividendo, float divisor) throws DivisionPorCero{
if (divisor == 0) throw new DivisionPorCero("Error");
return dividendo/divisor;
}
/**
* Computa la suma real entre dos valores.
* @param op1 Operando 1 de la suma.
* @param op2 Operando 2 de la suma.
* @return Resultado de aplicar la suma.
*/
public static float sumar(float op1, float op2) {
return op1 + op2;
}
/**
* Computa la resta real entre dos valores.
* @param op1 Operando 1 de la resta.
* @param op2 Operando 2 de la resta.
* @return Resultado de aplicar la resta.
*/
public static float restar(float op1, float op2) {
return op1 - op2;
}
/**
* Computa la multiplicación real entre dos valores.
* @param op1 Operando 1 de la multiplicación.
* @param op2 Operando 2 de la multiplicación.
* @return Resultado de aplicar la multiplicación.
*/
public static float multiplicar(float op1, float op2) {
return op1 * op2;
}
/**
* Método que inicia la ejecución del programa.
* Testea las operaciones suma, resta, multiplicación y división con un caso de prueba simple.
* @param args Argumentos por línea de comandos.
*/
public static void main(String [] args){
float resultado = 0;
try {
resultado = dividir(10, 0);
System.out.println("El resultado de dividir 10 y 0 es: " + resultado);
} catch (DivisionPorCero e) {
System.out.println(e.getMessage());
}
resultado = sumar (10,10);
System.out.println("El resultado de sumar 10 y 10 es: " + resultado);
resultado = restar(25, 15);
System.out.println("El resultado de restar 25 y 15 es: " + resultado);
resultado = multiplicar (105, -2);
System.out.println("El resultado de multiplicar 105 y -2 es: " + resultado);
}
}
package Calculadora;
/**
* Modela la excepción ante una división por cero.
* @author Federico Joaquín (federico.joaquin@cs.uns.edu.ar)
*
*/
@SuppressWarnings("serial")
public class DivisionPorCero extends Exception {
/**
* Inicializa la excepción indicando el origen del error.
* @param msj Especifica información adicional a cerca de la excepción.
*/
public DivisionPorCero(String msj){
super(msj);
}
}
Código fuente online
Generación de Jar Ejecutables.
* * *
Generación de Jar Ejecutables
Ejemplo GUI Calculadora
A continuación se puede observar el código fuente utilizado para ejemplificar la generación de Jars ejecutables.
-
Packages
package Calculadora;
/**
* Modela las operaciones de una calculadora.
* @author Federico Joaquín (federico.joaquin@cs.uns.edu.ar)
*/
public class Calculadora {
/**
* Computa la división real entre dos valores.
* @param dividendo Valor del dividendo de la división.
* @param divisor Valor del divisor de la división.
* @return Resultado de aplicar la división.
* @throws DivisionPorCero en caso que divisor sea cero.
*/
public static float dividir(float dividendo, float divisor) throws DivisionPorCero{
if (divisor == 0) throw new DivisionPorCero("Error");
return dividendo/divisor;
}
/**
* Computa la suma real entre dos valores.
* @param op1 Operando 1 de la suma.
* @param op2 Operando 2 de la suma.
* @return Resultado de aplicar la suma.
*/
public static float sumar(float op1, float op2) {
return op1 + op2;
}
/**
* Computa la resta real entre dos valores.
* @param op1 Operando 1 de la resta.
* @param op2 Operando 2 de la resta.
* @return Resultado de aplicar la resta.
*/
public static float restar(float op1, float op2) {
return op1 - op2;
}
/**
* Computa la multiplicación real entre dos valores.
* @param op1 Operando 1 de la multiplicación.
* @param op2 Operando 2 de la multiplicación.
* @return Resultado de aplicar la multiplicación.
*/
public static float multiplicar(float op1, float op2) {
return op1 * op2;
}
/**
* Método que inicia la ejecución del programa.
* Testea las operaciones suma, resta, multiplicación y división con un caso de prueba simple.
* @param args Argumentos por línea de comandos.
*/
public static void main(String [] args){
float resultado = 0;
try {
resultado = dividir(10, 0);
System.out.println("El resultado de dividir 10 y 0 es: " + resultado);
} catch (DivisionPorCero e) {
System.out.println(e.getMessage());
}
resultado = sumar (10,10);
System.out.println("El resultado de sumar 10 y 10 es: " + resultado);
resultado = restar(25, 15);
System.out.println("El resultado de restar 25 y 15 es: " + resultado);
resultado = multiplicar (105, -2);
System.out.println("El resultado de multiplicar 105 y -2 es: " + resultado);
}
}
package Calculadora;
/**
* Modela la excepción ante una división por cero.
* @author Federico Joaquín (federico.joaquin@cs.uns.edu.ar)
*
*/
@SuppressWarnings("serial")
public class DivisionPorCero extends Exception {
/**
* Inicializa la excepción indicando el origen del error.
* @param msj Especifica información adicional a cerca de la excepción.
*/
public DivisionPorCero(String msj){
super(msj);
}
}
package GUI_Calculadora;
import java.awt.EventQueue;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import Calculadora.Calculadora;
import Calculadora.DivisionPorCero;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JTextField;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.Font;
import java.awt.Image;
import javax.swing.SwingConstants;
/**
* Modela la GUI de una calculadora con 4 operaciones: sumar, restar, multiplicar, dividir.
* @author Federico Joaquín (federico.joaquin@cs.uns.edu.ar)
*
*/
@SuppressWarnings("serial")
public class VentanaCalculadora extends JFrame {
//Atributos de instancia de clase
private JPanel contentPane;
private JTextField operando1;
private JTextField operando2;
/**
* Método principal de la aplicación.
* Crea una instancia de VentanaCalculadora.
*/
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
VentanaCalculadora frame = new VentanaCalculadora();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
/**
* Inicializa las componentes gráficas de la GUI.
*/
public VentanaCalculadora() {
setResizable(false);
setTitle("ED 2019-2020 || Mini calculadora by F. Joaqu\u00EDn");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 580, 200);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
contentPane.setLayout(null);
JLabel lblMinicalculadoraestructurasDeDatos = new JLabel("Estructuras de Datos 2019-2020");
lblMinicalculadoraestructurasDeDatos.setHorizontalAlignment(SwingConstants.CENTER);
lblMinicalculadoraestructurasDeDatos.setFont(new Font("Corbel", Font.BOLD | Font.ITALIC, 20));
lblMinicalculadoraestructurasDeDatos.setBounds(116, 22, 300, 50);
contentPane.add(lblMinicalculadoraestructurasDeDatos);
JButton btnSumar = new JButton("Sumar");
btnSumar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
float op1, op2, resultado;
if (operandosValidos()) {
op1 = Float.parseFloat(operando1.getText());
op2 = Float.parseFloat(operando2.getText());
resultado = Calculadora.sumar(op1, op2);
JOptionPane.showMessageDialog(null, "El resultado de la operación suma es: " + resultado, "Información de operación", JOptionPane.INFORMATION_MESSAGE);
}else {
JOptionPane.showMessageDialog(null, "Alguno de los operandos ingresados son inválidos", "Error datos entrada", JOptionPane.WARNING_MESSAGE);
}
}
});
btnSumar.setBounds(81, 125, 89, 23);
contentPane.add(btnSumar);
JButton btnRestar = new JButton("Restar");
btnRestar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
float op1, op2, resultado;
if (operandosValidos()) {
op1 = Float.parseFloat(operando1.getText());
op2 = Float.parseFloat(operando2.getText());
resultado = Calculadora.restar(op1, op2);
JOptionPane.showMessageDialog(null, "El resultado de la operación resta es: " + resultado, "Información de operación", JOptionPane.INFORMATION_MESSAGE);
}else {
JOptionPane.showMessageDialog(null, "Alguno de los operandos ingresados son inválidos", "Error datos entrada", JOptionPane.WARNING_MESSAGE);
}
}
});
btnRestar.setBounds(180, 125, 89, 23);
contentPane.add(btnRestar);
JButton btnMultiplicar = new JButton("Multiplicar");
btnMultiplicar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
float op1, op2, resultado;
if (operandosValidos()) {
op1 = Float.parseFloat(operando1.getText());
op2 = Float.parseFloat(operando2.getText());
resultado = Calculadora.multiplicar(op1, op2);
JOptionPane.showMessageDialog(null, "El resultado de la operación multiplicar es: " + resultado, "Información de operación", JOptionPane.INFORMATION_MESSAGE);
}else {
JOptionPane.showMessageDialog(null, "Alguno de los operandos ingresados son inválidos", "Error datos entrada", JOptionPane.WARNING_MESSAGE);
}
}
});
btnMultiplicar.setBounds(279, 125, 89, 23);
contentPane.add(btnMultiplicar);
JButton btnDividir = new JButton("Dividir");
btnDividir.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
float op1, op2, resultado;
if (operandosValidos()) {
op1 = Float.parseFloat(operando1.getText());
op2 = Float.parseFloat(operando2.getText());
try {
resultado = Calculadora.dividir(op1, op2);
JOptionPane.showMessageDialog(null, "El resultado de la operación dividir es: " + resultado, "Información de operación", JOptionPane.INFORMATION_MESSAGE);
} catch (DivisionPorCero e) {
JOptionPane.showMessageDialog(null, "No se puede realizar una división por cero.", "Error datos entrada", JOptionPane.ERROR_MESSAGE);
}
}else {
JOptionPane.showMessageDialog(null, "Alguno de los operandos ingresados son inválidos", "Error datos entrada", JOptionPane.WARNING_MESSAGE);
}
}
});
btnDividir.setBounds(378, 125, 89, 23);
contentPane.add(btnDividir);
operando1 = new JTextField();
operando1.setBounds(186, 94, 86, 20);
contentPane.add(operando1);
operando1.setColumns(10);
JLabel lblOperando = new JLabel("Operando 1:");
lblOperando.setBounds(113, 97, 84, 14);
contentPane.add(lblOperando);
JLabel lblOperando_1 = new JLabel("Operando 2:");
lblOperando_1.setBounds(282, 97, 84, 14);
contentPane.add(lblOperando_1);
operando2 = new JTextField();
operando2.setBounds(353, 94, 86, 20);
contentPane.add(operando2);
operando2.setColumns(10);
JLabel label = new JLabel("");
ImageIcon iconoDCIC = new javax.swing.ImageIcon(getClass().getResource("/Imagenes/DCIC.png"));
Image imagenDCIC = iconoDCIC.getImage();
ImageIcon iconoDCICEscalado = new ImageIcon (imagenDCIC.getScaledInstance(50,50,Image.SCALE_SMOOTH));
label.setIcon(iconoDCICEscalado);
label.setBounds(56, 22, 50, 50);
contentPane.add(label);
JLabel label_1 = new JLabel("");
ImageIcon iconoUNS = new javax.swing.ImageIcon(getClass().getResource("/Imagenes/UNS.png"));
Image imagenUNS = iconoUNS.getImage();
ImageIcon iconoUNSEscalado = new ImageIcon (imagenUNS.getScaledInstance(65,50,Image.SCALE_SMOOTH));
label_1.setIcon(iconoUNSEscalado);
label_1.setBounds(430, 18, 65, 50);
contentPane.add(label_1);
JLabel label_2 = new JLabel("");
ImageIcon iconoCalc = new javax.swing.ImageIcon(getClass().getResource("/Imagenes/Calculadora.png"));
Image imagenCalc = iconoCalc.getImage();
ImageIcon iconoCALCEscalado = new ImageIcon (imagenCalc.getScaledInstance(50,50,Image.SCALE_SMOOTH));
label_2.setIcon(iconoCALCEscalado);
label_2.setBounds(21, 94, 50, 50);
contentPane.add(label_2);
}
/**
* Cheque la correctitud de los operandos ingresados.
* @return True si los operandos ingresados son válidos, false en caso contrario.
*/
private boolean operandosValidos(){
boolean toReturn = true;
//Si no se ingresó el operando 1, el operando 2 o ambos, estos no son válidos
if (operando1.getText().isEmpty() || operando2.getText().isEmpty())
toReturn = false;
else {
//Valida que los operandos ingresados sean valores numéricos.
try {
Float.parseFloat(operando1.getText());
Float.parseFloat(operando2.getText());
//Si al intentar convertir el String a Float existe error de conversión, los operandos no son válidos.
}catch(NumberFormatException e) {
toReturn = false;
}
}
return toReturn;
}
}
Código fuente online
Práctico Pilas y Colas
* * *
Práctico Pilas y Colas
Chequear_formato(...)
A continuación se puede observar el código fuente utilizado para implementar el Ejercicio 10, Inciso a, del Práctico de Pilas y Colas.
-
Packages
package Operaciones;
import TDACola.*;
import TDAPila.*;
public class Operaciones_con_colas {
/**
* Método que chequea si una cola de caracteres cumple el siguiente formato: AxA'A.
* A es una cadena de uno o más caracteres.
* A' corresponde con los caracteres de la cadena A pero en orden inverso.
* x corresponde con un caracter separador.
*
* @param q Cola de caracteres con los que se valida el formato.
* @param x Caracter separador en el formato AxA'A
* @return Verdadero si la cola q cumple con el formato; false en caso contrario.
*
* Ejemplo de cadena válida: q = < a, b, c, $, c, b, a, a, b, c >, con A = abc, A' = cba y x = $.
* Ejemplos de cadenas inválidas: q = < a, b, c, $ >, q = < >, en todos los casos con x = $.
*
*/
public static boolean chequear_formato(Queue<Character> q, char x) {
// Variables auxiliares utilizadas.
Queue<Character> cola_control_a;
Stack<Character> pila_control_a_prima;
boolean respeta_formato = false;
char caracter_de_q, caracter_control_a, caracter_control_a_prima;
// Se instancia una pila y una cola auxiliares que se utilizarán para chequear que la cola q
// cumpla con el formato A'A luego de hallar el caracter separador x.
pila_control_a_prima = new LinkedStack<Character>();
cola_control_a = new LinkedQueue<Character>();
try {
// Teniendo en cuenta que cualquier subcadena A de una cola q que respete el formato tiene
// al menos 1 caracter, entonces la cola q debería tener al menos 4 caracteres para respetar
// el formato q = AxA'A.
respeta_formato = (q.size() >= 4);
if (respeta_formato) {
caracter_de_q = q.dequeue();
// Bucle que consume la primera subcadena A de la cola de caracteres q.
// El bucle finaliza cuando se consume el separador x, o cuando la cola q se quede
// sin caracteres. Cada uno de los caracteres consumidos se guardan tanto en la
// cola_de_control_a y pila_control_a_prima para luego validar que q cumpla el formato
// xA'A luego del separador x.
while (caracter_de_q != x && !q.isEmpty()) {
cola_control_a.enqueue(caracter_de_q);
pila_control_a_prima.push(caracter_de_q);
caracter_de_q = q.dequeue();
}
// Finalizado el bucle while, se validan las siguientes condiciones:
// - Se respeta el formato siempre que se haya consumido el caracter separador x.
// - Se respeta el formato siempre que la longitud de la subcadena A sea mayor a cero.
respeta_formato = (caracter_de_q == x) && !cola_control_a.isEmpty();
if (respeta_formato) {
// Valida que en q ahora aparezca la cadena A'
// Bucle que consume y valida la subcadena A' de la cola de caracteres q.
// El bucle finaliza cuando se detecta que:
// - La cola de caracteres q deja de respetar el formato.
// - La pila_de_control_a_prima se queda sin caracteres.
// - La cola q no tienen más elementos para consumir.
while(respeta_formato && !pila_control_a_prima.isEmpty() && !q.isEmpty()) {
caracter_de_q = q.dequeue();
caracter_control_a_prima = pila_control_a_prima.pop();
respeta_formato = (caracter_de_q == caracter_control_a_prima);
}
// Finalizado el bucle while, se validan las siguientes condiciones:
// - Se respeta el formato siempre que todos los caracteres procesados hayan respetado el formato.
// - Se respeta el formato siempre que la pila_control_a_prima no tenga más caracteres a procesar.
// - Se respeta el formato siempre que la cola q aún tenga elementos para procesar la subcadena A luego de A'.
respeta_formato = respeta_formato && pila_control_a_prima.isEmpty() && !q.isEmpty();
// El bucle finaliza cuando se detecta que:
// - La cola de caracteres q deja de respetar el formato.
// - La cola_de_control_a se queda sin caracteres.
// - La cola q no tienen más elementos para consumir.
while(respeta_formato && !q.isEmpty() && !cola_control_a.isEmpty()) {
caracter_de_q = q.dequeue();
caracter_control_a = cola_control_a.dequeue();
respeta_formato = (caracter_de_q == caracter_control_a);
}
// Finalizado el bucle while, se validan las siguientes condiciones:
// - Se respeta el formato siempre que todos los caracteres procesados hayan respetado el formato.
// - Se respeta el formato siempre que la cola_control_a no tenga más caracteres a procesar.
// - Se respeta el formato siempre que en la cola q no queden elementos extras a procesar.
respeta_formato = respeta_formato && cola_control_a.isEmpty() && q.isEmpty();
}
}
}catch(EmptyQueueException e) {
}catch(EmptyStackException e1) {
}
return respeta_formato;
}
public static void main(String [] args) {
Queue<Character> cola = new LinkedQueue<Character>();
String cola_prueba;
int i;
// Caso de prueba: cadena válida
cola_prueba = "abc$cbaabc";
for(i=0; i<cola_prueba.length(); i++) {
cola.enqueue(cola_prueba.charAt(i));
}
System.out.println("chequear_formato("+cola_prueba+",$): " + chequear_formato(cola, '$') );
// Caso de prueba: cadena inválida
cola_prueba = "bccabc$cbaccbbccabc";
for(i=0; i<cola_prueba.length(); i++) {
cola.enqueue(cola_prueba.charAt(i));
}
System.out.println("chequear_formato("+cola_prueba+",$): " + chequear_formato(cola, '$') );
// Caso de prueba: cadena inválida
cola_prueba = "bccbaabc";
for(i=0; i<cola_prueba.length(); i++) {
cola.enqueue(cola_prueba.charAt(i));
}
System.out.println("chequear_formato("+cola_prueba+",$): " + chequear_formato(cola, '$') );
// Caso de prueba: cadena inválida
cola_prueba = "abc$cbaabcc";
for(i=0; i<cola_prueba.length(); i++) {
cola.enqueue(cola_prueba.charAt(i));
}
System.out.println("chequear_formato("+cola_prueba+",$): " + chequear_formato(cola, '$') );
// Caso de prueba: cadena inválida
cola_prueba = "a";
for(i=0; i<cola_prueba.length(); i++) {
cola.enqueue(cola_prueba.charAt(i));
}
System.out.println("chequear_formato("+cola_prueba+",$): " + chequear_formato(cola, '$') );
// Caso de prueba: cadena inválida
cola_prueba = "$cbaabcc";
for(i=0; i<cola_prueba.length(); i++) {
cola.enqueue(cola_prueba.charAt(i));
}
System.out.println( "chequear_formato("+cola_prueba+",$): " + chequear_formato(cola, '$') );
// Agregar casos de prueba ...
}
}
Código fuente online
Iterable vs. Iterator
* * *
Iterable vs. Iterator
Implementación de iteradores
A continuación se puede observar el código fuente utilizado para implementar dos iteradores de lista: uno que itera sobre la lista original, otro que clona el contenido de la lista para implementar las iteraciones.
-
Packages
package TDALista;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* Clase que modela un iterador de lista. </br>
* El iterador se modela internamente con <i>punteros</i> a los elementos de lista original.</br>
* Provee la funcionalidad de un iterador, realizando toda la operatoria sobre la ED original. </br>
* <b>No asegura</b> un correcto funcionamiento si durante el proceso de iteración la lista es modificada.</br>
* @author FJoaquin (federico.joaquin@cs.uns.edu.ar)
*
* @param <E> Tipo de dato de los elementos de la lista a iterar.
*/
public class IteradorListaSobreEdOriginal<E> implements Iterator<E>{
private PositionList<E> lista;
private Position<E> cursor;
/**
* Inicializa la ED interna considerando incialmente el primer elemento de la lista.
* @param lista Contiene los elementos a ser iterados.
*/
public IteradorListaSobreEdOriginal(PositionList<E> l){
try {
lista = l;
if (lista != null && !lista.isEmpty())
cursor = l.first();
}catch (EmptyListException e) {
cursor = null;
}
}
@Override
public boolean hasNext() {
// COMPLETAR
return false;
}
@Override
public E next() throws NoSuchElementException{
// COMPLETAR
return null;
}
}
package TDALista;
import java.util.Iterator;
import java.util.NoSuchElementException;
import TDACola.*;
/**
* Clase que modela un iterador de lista. </br>
* El iterador se modela internamente con una <i>ED Auxiliar</i> a la lista, esto es, se realiza una clonación de los elementos de la lista sobre una ED Auxiliar.</br>
* Provee la funcionalidad de un iterador, realizando toda la operatoria sobre la ED Auxiliar. </br>
* <b>Requiere:</b> <i>TDACola</i>.
* @author FJoaquin (federico.joaquin@cs.uns.edu.ar)
*
* @param <E> Tipo de dato de los elementos de la lista a iterar.
*/
public class IteradorListaSobreEdAuxiliar<E> implements Iterator<E>{
private Queue<E> cola;
/**
* Clona en una estructura auxiliar todos los elementos de lista.
* @param lista Contiene los elementos a ser iterados.
*/
public IteradorListaSobreEdAuxiliar(PositionList<E> lista) {
cola = new LinkedQueue<E>();
try {
Position<E> cursor = lista.isEmpty() ? null : lista.first();
while(cursor != null) {
cola.enqueue(cursor.element());
cursor = (cursor == lista.last()) ? null : lista.next(cursor);
}
}
catch(EmptyListException e) { cola = new LinkedQueue<E>();}
catch(InvalidPositionException e1) { cola = new LinkedQueue<E>();}
catch(BoundaryViolationException e2) { cola = new LinkedQueue<E>();}
}
@Override
public boolean hasNext(){
// COMPLETAR
return false;
}
@Override
public E next() throws NoSuchElementException{
// COMPLETAR
return null;
}
}
Iterable vs. Iterator
Implementación de positions
A continuación se puede observar el código fuente utilizado para implementar el método positions().
-
Packages
package TDALista;
public class DoubleLinkedList<E> implements PositionList<E>{
protected DNode<E> header, trailer;
// Implementación de lista
public Iterable<Position<E>> positions() {
PositionList<Position<E>> iterable;
iterable = new DoubleLinkedList<Position<E>>();
DNode<E> actual = header.getNext();
while(actual != trailer) {
iterable.addLast(actual);
actual = actual.getNext();
}
return iterable;
}
}
Iterable vs. Iterator
Eliminando elementos de una lista
A continuación se puede observar el código fuente utilizado eliminar elemento de una lista, cuando esta se recorre "manualmente" y mediante un iterable de posiciones.
-
Packages
package Operaciones_con_listas;
import TDALista.BoundaryViolationException;
import TDALista.DoubleLinkedList;
import TDALista.EmptyListException;
import TDALista.InvalidPositionException;
import TDALista.Position;
import TDALista.PositionList;
/**
* Clase que encapsula dos métodos para eliminar los elementos pares de una lista de valores enteros.</br>
* Los métodos se distinguen por la forma en la que se recorren las listas a modificar:
* <ul>
* <li> <i>Con recorrido "manual"</i>: se utilizan los métodos first(), last(), next() de la lista.</li>
* <li> <i>Con método positions()</i>: se utiliza la instrucción for-each y el iterable de posiciones retornado por el método positions() de lista.</li>
* </ul> </br>
*
* <b>Requiere:</b> <i>TDALista2</i>.
* @author FJoaquin (federico.joaquin@cs.uns.edu.ar)
*/
public class Operaciones_con_listas{
/**
* Elimina los números pares de una lista, recorriéndola de forma "manual".
* @param l Lista a modificar, eliminándole los números pares.
*/
public static void eliminar_con_recorrido_manual(PositionList<Integer> l){
int elemento;
try{
Position<Integer> actual = l.isEmpty() ? null : l.first();
Position<Integer> aux;
while(actual != null && actual != l.last()){
elemento = actual.element();
aux = l.next(actual);
if (elemento % 2 == 0){
l.remove(actual);
}
actual = aux;
}
if (actual != null){
if (actual.element() % 2 == 0)
l.remove(actual);
}
}catch(EmptyListException e){
}catch(InvalidPositionException e1){
}catch(BoundaryViolationException e2){
}
}
/**
* Elimina los números pares de una lista, recorriéndola mediante el uso de un iterable de posiciones.
* @param l Lista a modificar, eliminándole los números pares.
*/
public static void eliminar_con_positions(PositionList<Integer> l){
try{
for(Position<Integer> pos : l.positions()){
if (pos.element() % 2 == 0)
l.remove(pos);
}
}catch(InvalidPositionException e){}
}
/**
* Método que inicia la ejecución del programa. Testea el funcionamiento de <i>eliminar_con_recorrido_manual</i> y <i>eliminar_con_positions</i> con dos listas prueba.
* @param args Argumentos por línea de comandos.
*/
public static void main(String [] args){
PositionList<Integer> l1 = new DoubleLinkedList<Integer>();
PositionList<Integer> l2 = new DoubleLinkedList<Integer>();
//Inicializa L1 con elementos enteros en el rango [20-40]
//Inicializa L2 con elementos enteros en el rango [50-70]
for(int i=0; i<=20; i++) {
l1.addLast(20 + i);
l2.addLast(50 + i);
}
//Muestra el contenido de L1 y L2 haciendo uso de dos iteradores.
System.out.println("Elementos de L1 antes de eliminar:");
for(Integer i : l1) System.out.print(i + " - ");
System.out.println("\nElementos de L2 antes de eliminar:");
for(Integer i : l2) System.out.print(i + " - ");
//Elimina los elementos pares de L1 y L2.
eliminar_con_recorrido_manual(l1);
eliminar_con_positions(l2);
//Muestra el contenido de L1 y L2 haciendo uso de dos iteradores.
System.out.println("\nElementos de L1 luego de eliminar:");
for(Integer i : l1) System.out.print(i + " - ");
System.out.println("\nElementos de L2 luego de eliminar:");
for(Integer i : l2) System.out.print(i + " - ");
}
}
Fin de la presentación
Slides generadas mediante la herramienta Open Source @webslides.
-
Copyright © 2019-2024 Federico Joaquín
-
Actualizado al: 15-05-2020 - 19:00:20