Hola a todos, este es un pequeño tute que explica de forma breve un método que tuve que hacer para la universidad que invierte el orden de una lista sencilla en Java. Bueno empecemos.
El escenario es el siguiente:
Hay una clase
Region.java, la cual posee un nombre, una area, una coordenada a travez de una clase
Coordenada.java y finalmente una referencia tipo
Region hacia la siguiente region para poder tener la lista
, hay una clase llamada
Colombia.java la cual posee la lista de las Regiones, la cantidad, y la referencia tipo
Region hacia la primera:
Clase
Coordenada.java packete
mundo:
package mundo;
import javax.swing.JComponent;
public class Coordenada {
private int x;
private int y;
public Coordenada(int x, int y){
this.x = x;
this.y = y;
}
public int getX(){
return x;
}
public int getY(){
return y;
}
}
La clase
Region.java es la siguiente:
package mundo;
public class Region {
private double area;
private Region siguiente;
private Coordenada miCoordenada;
public void setNombre
(String nombre
){ this.nombre =nombre;
}
return nombre;
}
public void setArea(double area){
this.area =area;
}
public double getArea(){
return area;
}
public void setSiguiente(Region siguiente){
this.siguiente =siguiente;
}
public Region getSiguiente(){
return siguiente;
}
public void setCoordenada(int x, int y){
miCoordenada = new Coordenada(x, y);
}
public Coordenada getCoordenada(){
return miCoordenada;
}
}
Bueno lo unico que tiene esta clase son los metodos usuales
setter y
getters jeje, ahora miremos como esta la clase
Colombia.java:
package mundo;
import javax.swing.JOptionPane;
public class Colombia {
Region primera;
int cantidadRegiones;
public Colombia() {
primera = null;
cantidadRegiones =0;
}
public void agregarRegion
(String nombre,
int x,
int y,
double area
) {
if(buscarRegion(nombre) == null)
{
Region miRegion = new Region();
miRegion.setNombre(nombre);
miRegion.setArea(area);
miRegion.setCoordenada(x, y);
miRegion.setSiguiente(primera);
primera = miRegion;
}
else
JOptionPane.
showMessageDialog(null,
"Esta region ya fue ingresada"); }
public Region buscarRegion
(String nombre
) {
Region miRegion = primera;
while(miRegion !=null)
{
if(miRegion.getNombre().equals(nombre))
return miRegion;
miRegion = miRegion.getSiguiente();
}
return null;
}
public void inicializarColombia() {
agregarRegion("quindio", 10, 20, 230.54);
agregarRegion("valle", 30, 11, 580.32);
agregarRegion("barranquilla", 72, 10, 1520.14);
agregarRegion("bogota", 55, 38, 14554.32);
agregarRegion("pereira", 31, 48, 654.22);
agregarRegion("a", 31, 48, 654.22);
}
public void invertirLista(){
Region miRegion = primera, temp=null;
while(miRegion.getSiguiente() != null)
{
temp = miRegion.getSiguiente();
miRegion.setSiguiente(temp.getSiguiente());
temp.setSiguiente(primera);
primera = temp;
}
}
}
Bueno lo que tiene es un método
agregarRegion el cual como ven primero busca en
buscarRegion(String nombre) que no haya sido ingresada todavía, y si no esta ingresada la inserta creando una nueva
Region y asignandole
primera a su referencia
siguiente, por lo tanto la primera que se ingrese tendra en siguiente una referencia a
null, por ser la última, es decir primera que se ingresa es última que queda jeje.
Bueno, al inicializar la aplicación se llamara al método
inicializarColombia() que lo que hace es tan solo agregar unas cuantas regiones, pero no es el caso mostrar la clase principal
, ahora viene lo interesante y es el método
invertirLista().
Lo que hacemos primeramente es declarar una Región (
miRegion) y le apuntamos a
Primera para poder empezar desde el inicio
, y tambien declaramos una referencia (
temp) que nos servira para el cambio de nodos.
Como bien, la lista es sencilla por lo tanto no tenemos referencia a
Anterior, por eso debemos tener un
auxiliar (
temp)que nos sirva de rescate.
El bucle lo que hace es mientras no estemos en la ultima región
"While(miRegion.getSiguiente() != null)" apuntamos
temp hacia la siguiente de donde estamos parados, para que de esta forma al cambiar la referencia en la que estamos hacia la que sigue de la siguiente, en
temp nos quede la que saltamos (ahora explico bien el mecanismo usado).
Con
"miRegion.setSiguiente(temp.getSiguiente());" lo que hacemos es que donde estamos ponemos en
siguiente la referencia siguiente del elemento que saltamos, de esta forma quedaria en la misma posición de
temp.
Ahora
"temp.setSiguiente(primera);" lo que hace es cambiar la referencia siguiente de
temp para que apunte a la primera, y hecho esto ya pasamos nuestro elemento
miRegion una posición mas en la lista, y con
"primera = temp" indicamos que primera ya no es
miRegion sino
temp, el esquema siguiente ilustra lo que hace el bucle.
Esquema:1. Inicio del escenario:
Region miRegion = primera, temp=null;2. Inicializamos
temp:
temp = miRegion.getSiguiente();3. Saltamos
E2:
miRegion.setSiguiente(temp.getSiguiente());4. Apuntamos
temp a
primera:
temp.setSiguiente(primera);5. Tomamos ya primera como
temp:
primera = temp;6. Ahora ordenamos el esquema para que se vea mejor:
Como ven esto se repite hasta que
miRegion.getSiguiente() != null, eso indicaria que terminamos, ya que los elementos iran quedando uno detrás del otro y asi sucesivamente.
Espero les sirva de algo, cualquier duda comenten
salu2
amerikano
Mostrar Temas
.
, ¿es cuestion de plugins?, no sé.
