Implementar pilas

Si lo que tienes es que implementar una cola de peticiones que realicen acciones, te recomiendo 2 cosas.
1. Crea una clase que herede de thread y que puedas lanzar en un hilo de ejecución independiente.
En el método init() inicia una variable a true.
En run() un bucle while (variable) y dentro del bucle llamas a 3 funciones.
En el método stop() la variable a false.
Esta clase debe contener un Hashtable para almacenar peticiones.
2. En el primer método accede a las peticiones (si están en una base de datos la lees, lees fichero externos, etc) y las almacenas en la hastable.
3. En el segundo proceso procesas las peticiones (enviando e-mail o lo que hagas) por lo que dentro del bucle habrá otro que recorra la lista.
4. El tercer método tiene de entrada un check de petición procesada o no. Si la petición es OK la borras de la hashtable y de tablas, fichero, etc. Si es KO controlas el número de intentos para descartarla en caso de superar un límite.
Por último la clase run tiene un método sleep para parar cuando la lista esté vacía.
El Run es independiente, debes arrancarlo y pararlo desde otra clase (por ejemplo desde el método init() y destroy() de un servlet si estás en un entorno web).

Necesito implementar estructuras de datos para los TDA pila, cola y lista Circular utilizando una lista como estructura que almacene los datos y ver que funcionan con algún ejm sencillo.
Parece ser fácil pero soy incapaz, según me dicen que hay que usar el borrar vacía insertar sacer,,,, Es decir no crear la cola, parece ser que hay que usar la lista y solo definir esas operaciones y que la cola, pila lista circular se basen en la lista
ES UN LIO

¿No eres capas de crear las estructuras o los algoritmos?

Necesito implementar estructuras de datos para los TDA pila, cola y lista Circular utilizando una lista como estructura que almacene los datos y ver que funcionan con algún ejm sencillo.
Parece ser fácil pero soy incapaz, según me dicen que hay que usar el borrar vacía insertar sacer,,,, Es decir nocrearlacola, parece ser que hay que usar la lista y solo definir esas operaciones y que la cola, pila lista circular se basen en la lista
ES UN LIO

¿Puedes listarme las cosas que hay que hacer?

Necesito un programa que sea una pila pero no creada como tal sino que use la pila, supongo que hay que crear la pila haciendo llamadas a la lista, lo mismo para la cola y para la lista circular

Uups

Me dicen que es fácil, pero mi java es pésimo
no hay que crear la pila como tal, solo definirlas funciones de añadir, insertar ... y haciendo llamadas a la pila que es donde esta creada la estructura
me parece que es usando el interfaz pila o algo así

Debes tener definida tu estructura del nodo. ¿Puedes enviármela?

import lista.*;
/*************************************************************************************
* Ejemplo de uso de una lista implementada sobre un vector. *
* En el paquete lista (importado en la primera línea) se encuentran las clases: *
* Lista: un interfaz para la lista. *
* ListaSecuencial: una clase que implementa el interfaz lista. *
* Verificar: una clase que lanza excepciones de tipo IllegalArgumentException. *
* *
* Las funciones de la interfaz Lista que se utilizan en este ejemplo son: *
* añadir (Object): añade un objeto al final de la lista. *
* imprimir (): vuelca el contenido de la lista en la pantalla. *
* mover (int): mueve el cursor a la posición inidicada. *
* insertar (Object): inserta el objeto en la posición actual del cursor. *
* eliminar (): elimina el objeto de la posición actual de la lista. *
* ppio (): mueve el cursor al primer elemento de la lista. *
* dentro (): comprueba si el cursor apunta a un elemento de la lista. *
* siguiente (): avanza una posición el cursor, al siguiente elemento de la lista. *
* borrar (): borra el contenido de la lista. *
* *
* Otras funciones utilizadas en el programa: *
* System.out.println (Object): muestra el contenido del objeto por pantalla. *
* En este caso se ha utilizado para mostrar, *
* cadenas explicativas por pantalla. *
*************************************************************************************/
public class prueba {
public static void main (String [] args) {
Lista lista = new ListaSecuencial ();
System.out.println (">> Tenemos una lista vacia.");
System.out.println (">> La imprimimos para comprobarlo.");
lista.imprimir ();
System.out.println (">> A la lista vacia le añadimos elementos.");
lista.añadir ("Uno"); // adicción de un elemento, al final de la lista
lista.añadir ("Dos");
lista.añadir ("Tres");
System.out.println (">> Imprimimos la lista para ver que contiene ahora.");
lista.imprimir ();
System.out.println (">> Añadimos un nuevo elemento.");
lista.añadir ("Cuatro");
lista.imprimir ();
System.out.println (">> Insertamos un elemento mas al principio.");
lista.mover (0);
lista.insertar ("Cinco");
lista.imprimir ();
System.out.println (">> Y otro mas al final.");
lista.añadir ("Seis");
lista.imprimir ();
System.out.println (">> Mover el cursor no afecta. Siempre se puede añadir al final.");
System.out.println (">> Ahora probamos a eliminar el elemento de indice 1 de la lista.");
lista.mover (1);
lista.eliminar ();
lista.imprimir ();
System.out.println (">> Recorremos la lista. Para demostrarlo imprimimos cada elemento por separado");
for (lista.ppio (); lista.dentro (); lista.sgte ())
System.out.println ("\t" + lista.obtener ());
System.out.println (">> Para terminar la prueba la borramos.");
lista.borrar ();
lista.imprimir ();
}
}

Te anticipo que no soy un megaexperto de Java precisamente, pero creo que puedo ayudarte.
Para hacer una pila (LIFO) en java, tengo aquí tu ejercicio resuelto:
http://enterprise.eui.upm.es/grupos/EjercicioJava.pdf
Para una cola (FIFO), creo que esto te vale:
import java.io.*;
interface Queue {
public void enqueue(Object o);
public Object dequeue();
}
class LinkedQueue implements Queue {
Node top, bottom;
public void enqueue(Object o) {
Node n = new Node(o);
if (bottom != null) {
bottom.next = n;
bottom = n;
} else
top = bottom = n;
}
public Object dequeue() throws NullPointerException {
Object o = top.elem;
top = top.next;
if (top == null)
bottom = null;
return o;
}
class Node {
private Object elem;
private Node next;
public Node(Object o) {
this.elem = o;
}
}
}
class MyMain1 {
public static void main(String args[]) {
FileReader f;
StringWriter g = new StringWriter();
LinkedQueue h = new LinkedQueue();
try {
f = new FileReader(args[0]);
} catch(FileNotFoundException e) {
return;
}
for (int c = 0; c != -1; ) {
try {
c = f.read();
} catch (IOException e) {
c = -1;
}
switch (c) {
case -1 : if (g.getBuffer().length() > 0) {
h.enqueue(g.getBuffer().toString());
g.getBuffer().setLength(0);
}
break;
case '\n': h.enqueue(g.getBuffer().toString());
g.getBuffer().setLength(0);
continue;
default : g.write(c);
continue;
}
}
while (true) {
String s;
try {
s = (String)h.dequeue();
System.out.println(s);
} catch(NullPointerException e) {
break;
}
}
}
}
Para una lista circular, creo que en este largísimo enlace tienes lo que necesitas:
http://mailweb.udlap.mx/~ccastane/Syllabus_Estructura_Datos/Notas_Estr_Datos/Ejemplos/TercerParcial/Ejem_ListasLigCircular.html
Puede que estas cosas, aunque tengo la sospecha de que no he entendido bien la pregunta. ¿Quieres crear todas estas estructuras a partir de una lista? Es decir, ¿Quieres usar la pila, lista y cola como interface para manejar una lista? Si es así, puedo ayudarte algo más de lo que he hecho.

Necesito implementar estructuras de datos para los TDA pila, cola y lista Circular utilizando una lista como estructura que almacene los datos y ver que funcionan con algún ejm sencillo.
Parece ser fácil pero soy incapaz, según me dicen que hay que usar el borrar vacía insertar sacer,,,, Es decir nocrearlacola, parece ser que hay que usar la lista y solo definir esas operaciones y que la cola, pila lista circular se basen en la lista
ES UN LIO, creo que es lo del interfaz

Parece ser que es algo parecido a esto o que se basa en esto
eSTO ES LA BASE DE LO QUE TENGO QUE HACER,ESTRUCTURA DE UNA PILA BASANDOME EN ESTA LISTA YA CREADAimport lista.*;
/*************************************************************************************
* Ejemplo de uso de una lista implementada sobre un vector. *
* En el paquete lista (importado en la primera línea) se encuentran las clases: *
* Lista: un interfaz para la lista. *
* ListaSecuencial: una clase que implementa el interfaz lista. *
* Verificar: una clase que lanza excepciones de tipo IllegalArgumentException. *
* *
* Las funciones de la interfaz Lista que se utilizan en este ejemplo son: *
* añadir (Object): añade un objeto al final de la lista. *
* imprimir (): vuelca el contenido de la lista en la pantalla. *
* mover (int): mueve el cursor a la posición inidicada. *
* insertar (Object): inserta el objeto en la posición actual del cursor. *
* eliminar (): elimina el objeto de la posición actual de la lista. *
* ppio (): mueve el cursor al primer elemento de la lista. *
* dentro (): comprueba si el cursor apunta a un elemento de la lista. *
* siguiente (): avanza una posición el cursor, al siguiente elemento de la lista. *
* borrar (): borra el contenido de la lista. *
* *
* Otras funciones utilizadas en el programa: *
* System.out.println (Object): muestra el contenido del objeto por pantalla. *
* En este caso se ha utilizado para mostrar, *
* cadenas explicativas por pantalla. *
*************************************************************************************/
public class prueba {
public static void main (String [] args) {
Lista lista = new ListaSecuencial ();
System.out.println (">> Tenemos una lista vacia.");
System.out.println (">> La imprimimos para comprobarlo.");
lista.imprimir ();
System.out.println (">> A la lista vacia le añadimos elementos.");
lista.añadir ("Uno"); // adicción de un elemento, al final de la lista
lista.añadir ("Dos");
lista.añadir ("Tres");
System.out.println (">> Imprimimos la lista para ver que contiene ahora.");
lista.imprimir ();
System.out.println (">> Añadimos un nuevo elemento.");
lista.añadir ("Cuatro");
lista.imprimir ();
System.out.println (">> Insertamos un elemento mas al principio.");
lista.mover (0);
lista.insertar ("Cinco");
lista.imprimir ();
System.out.println (">> Y otro mas al final.");
lista.añadir ("Seis");
lista.imprimir ();
System.out.println (">> Mover el cursor no afecta. Siempre se puede añadir al final.");
System.out.println (">> Ahora probamos a eliminar el elemento de indice 1 de la lista.");
lista.mover (1);
lista.eliminar ();
lista.imprimir ();
System.out.println (">> Recorremos la lista. Para demostrarlo imprimimos cada elemento por separado");
for (lista.ppio (); lista.dentro (); lista.sgte ())
System.out.println ("\t" + lista.obtener ());
System.out.println (">> Para terminar la prueba la borramos.");
lista.borrar ();
lista.imprimir ();
}
}

Por lo que veo, tienes la clase ListaSecuencial, con la que tienes que trabajar, y que tiene los métodos siguientes:
Añadir(elemento) -> Añade al final de la lista
mover(indice) -> Mueve el apuntador a la posición indicada
insertar(elemento) -> Inserta un elemento en la posición de apuntador
eliminar() -> Elimina el elemento apuntado
ppio() -> Mueve el apuntador al principio de la lista, como mover(0)
Dentro() -> Devuelve True si el apuntador está dentro de la lista
siguiente() -> Mueve el apuntador al siguiente elemento
imprimir() -> Imprime la lista completa
obtener() -> Devuelve el elemento apuntado
borrar() -> Elimina la lista completa
Imagino que también habrá un método fin() que mueva el apuntador al último elemento de la lista.
Con esto es relativamente fácil crear las estructuras que indicas. La clave está sólo en mantener una serie de índices o apuntadores correctamente.
Te lo implemento en algo parecido a Java, ya no soy un experto en Java y puedo cometer errores. Para coger la idea te debe valer:
Pila FIFO: (cola)
La pila fifo no tiene complicación, ya que los elementos siempre se sacan comenzando por el principio (0), y se agregan al final.
class PilaFIFO {
Lista lista = new ListaSecuencial();
void Mete(String elemento) {
lista.añadir(elemento); // Agrego al final
}
String Saca() {
// Siempre saca el primer elemento (0), y luego lo borra, así que el elemento 1 pasa a ser el 0, es decir, el siguiente
lista.mover(0);
String ret=lista.obtener();
lista.eliminar(0);
return ret;
}
};
Lista LIFO: (pila)
En la lista LIFO, siempre se saca en orden inverso a la entrada, por lo que añado al principio, y también saco del principio
class ListaLIFO {
Lista lista=new ListaSecuencial();
void Mete(String elemento) {
lista.mover(0);
lista.insertar(elemento); // Agrego al principio
}
String Saca() {
lista.mover(0);
String ret=lista.obtener();
lista.eliminar(0);
return ret;
}
}
Como verás, la única diferencia es dónde añado.
Lista Circular:
En la lista circular, la única diferencia con una lista normal, es que al llegar al final se vuelve al principio:
class ListaCircular {
Lista Lista=new ListaSecuencial();
void Sgte(){
lista.sgte();
if(!lista.dentro())lista.mover(0);
}
}
El resto de los métodos son fáciles de implementar

Lo voy a intentar así, por lo menos ya como van las cosas, muchas gracias