Comparación

de Atributos

Taller de
Algoritmos y
Estructuras
de Datos I

1
 Comparación de atributos,
implementación de métodos de Java
Teniendo en cuenta que las listas enlazadas tienen orden lógico distinto al
orden físico, o sea se muestran de acuerdo al orden del criterio establecido
no por el orden de ingreso en memoria, por ejemplo, si se quiere almacenar
los datos de los alumnos ordenados por legajo, es posible que la lista a
cargar sea: 10, 23, 4, 15.

 El primer legajo en entrar será el 10.

 Cuando ingrese el 23 lo compara con el 10, como es mayor se ubica

después, quedando 10, 23

 Cuando ingresa el 4, lo compara con el 10 y corresponde que es < al

primero, por lo que lo ubica delante del 10, quedando: 4, 10, 23.

 Cuando ingresa el 15 lo compara con 4, no es menor, lo compara con

el 23, no es mayor, por lo que está en el medio 4 < 15 < 23. El
algoritmo debe buscar el lugar dónde debe insertarlo, quedando: 4,
10, 15, 23.

En este caso, lo estamos ordenando por legajo, si hacemos un algoritmo

para este caso no servirá para otra situación distinta, por ejemplo para
ordenar clientes por apellido y nombre.

Como la programación Orientada a Objetos busca reutilizar el código es

importante generalizar estos algoritmos y que sirvan para todos los objetos,
para ello tenemos que utilizar los métodos equals() y compareTo() de Java.

El método equals()

El método equals() permite comparar 2 cadenas o 2 objetos, es una función

booleana que nos devuelve true cuando son iguales y false cuando son
distintos. Recuerde que este método es de la clase String del package
java.lang, por lo tanto no es necesario importar el paquete en el programa.
//equals

String s1 = “Hola";

String s2 = “hola";

if (s1.equals(s2)){

// s1 y s2 tinen el mismo contenido, devuelve true

if (s1 == s2) {

// compara si s1 y s2 tienen la misma referencia

El método compareTo()

Para comparar dos objetos es posible hacerlo con el método compareTo(),

de la clase String del paquete java.lang.
Este método permite comparar por igual, mayor y menor valor,
devolviendo 0, 1 ó -1 respectivamente. Veamos un ejemplo muy simple:

//compareTo(Object object)

String s1 = “Hola";

String s2 = “hola";

if (s1.compareTo(s2) > 0) {

// s1 es más grande que s2

else if (s1.compareTo(s2) == 0 {

// s1 y s2 son iguales

else

// s1 es menor a s2
 Teniendo en cuenta su funcionamiento deberíamos conocer dónde se tiene
que escribir el método para luego poder usarlo.

Si la comparación de dos cadenas u objetos con

equals() devolvió true, la misma comparación
con compareTo() tiene que devolver 0 (cero).

¿Qué tenemos que tener en cuenta para usar el método

compareTo()?

Para usar correctamente el método compareTo() se tiene que tener en

cuenta:

 El método lo define en la clase del objeto que tiene el atributo a

comparar, por ejemplo si queremos comparar la edad de dos
alumnos, en la clase Alumno, que tiene el atributo edad es donde
coloca el método.

 La clase donde define el método debe implementar la interfaz

Comparable.

 La interfaz Comparable puede ser usada la que tiene definida en

Java o redefinirla.

Supongamos que tenemos que almacenar Médicos ordenados por código en

una lista simplemente enlazada, necesitamos las siguientes clases:

 Médico, clase del modelo

 Nodo, para almacenar el objeto Médico y el enlace

 ListaSimple, con 2 nodos auxiliares primero y último, además tiene

las operaciones

 ILista, interfaz con las operaciones.

Veamos el código del ejemplo:

package modelo;
import estructuras.*;

@SuppressWarnings("unchecked")
public class Medico implements Comparable {

private String Nombre;

private String Apellido;
private Integer CodigoDeMedico;
private Integer NumeroDeMatricula;

public Medico() {
}

public String getNombre() {

return Nombre;
}
public void setNombre(String nombre) {
Nombre = nombre;
}

//se completa con los getxx() y setXX() de los demás

atributos

public String toString(){

return "Nombre: " + this.getNombre() +
"\nApellido: " + this.getApellido() +
"\nCodigo Identificatorio: " +
this.getCodigoDeMedico() +
"\nNumero De Matricula: " +
this.getNumeroDeMatricula();
}

//método para comparer el objeto active con el recibido por

código de médico, devuelve 0, 1 ó -1
public int compareTo(Object m) {
Medico medico = (Medico)m;
return
this.getCodigoDeMedico().compareTo(medico.getCodigoDeMedico())

}
}
package com.estructuras;

public class Nodo<T extends Object> {

private T dato; //cualquier tipo de valor,

private Nodo<T> sig;

public Nodo() {
this.dato = null;
this.sig = null;
}

public Nodo(T dato) {

this.dato = dato;
}

public Nodo(T dato, Nodo sig) {

this.dato = dato;
this.sig = sig;
}

public T getDato() {
return dato;
}

public void setDato(T dato) {

this.dato = dato;
}

public Nodo getSig() {

return sig;
}

public void setSig(Nodo sig) {

this.sig = sig;
}
}
 package com.estructuras;

public interface ILista {

public void Vaciar();

public void Insertar(Comparable dato);
public boolean EsVacia();
public boolean Buscar(Comparable dato);
public Object Eliminar(Comparable dato);
public String ListarAscendente();
public String ListarDescendente();
}

package com.estructuras;

public class Lista<T extends Object> implements ILista {

private Nodo cabecera;

private Nodo ultimo;

public Lista () {
this.cabecera = null;
this.ultimo = null;
}
public Nodo getCabecera() {
return cabecera;
}
public void setCabecera(Nodo primero) {
this.cabecera = primero;
}
public Nodo getUltimo() {
return ultimo;
}
public void setUltimo(Nodo ultimo) {
this.ultimo = ultimo;
}
………………………………………………..

Continuamos con el código de cada operación definida en la Interfaz

ILista.

Comprobamos si está vacía con:

public boolean EsVacia() {

if (this.cabecera == null && this.ultimo == null){
return true;
}
return false;
}
Vaciamos la Lista con:

public void Vaciar() {

this.cabecera = null;
this.ultimo = null;
}

Listamos de forma ascendente, o sea del primero al último con:

public String ListarAscendente() {

String salida = "";

Nodo auxiliar = this.cabecera;

while(auxiliar != null){
salida += auxiliar.getDato().toString()+"\n";
auxiliar = auxiliar.getSiguiente();
}

return salida;
}

Listamos de forma descendente, o sea del último al primero con:

public String ListarDescendente() {

String salida = "";
Nodo auxiliar = this.ultimo;

while(auxiliar != null){
salida += auxiliar.getDato().toString()+"\n";
auxiliar = auxiliar.getAnterior();
}

return salida
}
 Insertamos un nuevo elemento en la Lista, en este caso un objeto
Médico ordenado por código

public void Insertar(Comparable dato) {

Nodo nuevo = new Nodo (dato);

Nodo auxiliar = this.cabecera;
Nodo auxAnterior = this.cabecera;

//enlazamos con el único nodo que hay en la lista

if(this.EsVacia()){
this.cabecera = nuevo;
this.ultimo = nuevo;
}

//si el nuevo código es menor al que estaba primero

else if (nuevo.getDato().compareTo(this.getCabecera().getDato())<0){
//enlaza el nuevo nodo con el que estaba primero
nuevo.setSiguiente(this.getCabecera());
//enlaza la cabecera con nuevo para indicar que es el primero
this.setCabecera(nuevo);
}
else //si el nuevo código es mayor al último
if (nuevo.getDato().compareTo(this.getUltimo().getDato())> 0){
//enlaza el último con el nuevo
this.ultimo.setSiguiente(nuevo);
//siguiente del nuevo es Null por ser ahora el último dato
nuevo.setSiguiente(null);
//enlaza con nuevo para indicar que es el último nodo
this.setUltimo(nuevo);
}
else{ //está en el medio
while(auxiliar != null &&
nuevo.getDato().compareTo(auxiliar.getDato()) > 0){
auxAnterior = auxiliar;
auxiliar = auxiliar.getSiguiente();
}
//sale del while cuando encuentra su lugar, con auxiliar
parado en el que le sigue al nuevo nodo y auxAnterior en el anterior
nodo
//enlaza el anterior con el nuevo
auxAnterior.setSiguiente(nuevo);
//enlaza el nuevo con el siguiente
nuevo.setSiguiente(auxiliar);
}
}
 Buscamos un médico por código en la lista:

public boolean Buscar(Comparable dato) {

//declaramos un auxiliar para buscar el dato
NodoDoble auxiliar = this.cabecera;
boolean salida = false;
//recorre la lista
while(auxiliar != null){
//compara el código del nodo visitado con el ingresado
if(auxiliar.getDato().compareTo(dato) == 0){
salida = true;
}
auxiliar = auxiliar.getSiguiente();
}
return salida;
}

Eliminamos un Médico de acuerdo a un código ingresado:

public Object Eliminar(Comparable dato) {

Nodo auxiliar = this.cabecera;
Object salida = null;

if (this.EsVacia()){
Mostrar.mostrar("Lista Vacia");
}
else //compara con el primero, si es igual
if(dato.compareTo(this.getCabecera().getDato()) == 0){

salida = this.cabecera.getDato();
//cambia cabecera enlazando con el segundo
this.cabecera = this.cabecera.getSiguiente();
}
else //busca si está en la lista
while(auxiliar != null &&
dato.compareTo(auxiliar.getDato()) != 0){
auxAnterior = auxiliar;
auxiliar = auxiliar.getSiguiente();
}
If(auxiliar ¡= null){
salida = auxiliar.getDato();
//enlaza el anterior con el siguiente, eliminando el nodo
auxAnterior.setSiguiente(auxAnterior.getSiguiente());

}
return salida;
}
}
Referencia Bibliográfica
Mark Allen Weiss, “Estructuras de Datos en Java”, ed. Addison Wesley. 2000

Deitel y Deitel, “Java cómo programar ”, séptima edición, ed. Pearson, 2008.

Pressman Roger, (2006), “Ingeniería de Software. Un enfoque práctico” 6ta.

edición, Ed. McGraw Hill

ORACLE, Oracle 10g: Programación Java, Guía del Alumno, 2003

www.uesiglo21.edu.ar