Colecciones Java (estructura LIFO)

Question

Estoy buscando en el marco Colecciones de Java para una estructura LIFO (pila) sin éxito. Básicamente quiero una pila realmente simple; mi opción perfecta sería un Deque, pero estoy en Java 1.5.

me gustaría no tener que agregar otra clase de mi estructura, pero me pregunto si eso es posible:

1. ¿Hay alguna clase en el marco de las colecciones (1.5) que hace el trabajo?

2. Si no, ¿hay alguna manera de convertir una cola en una cola LIFO (también conocida como pila) sin volver a implementarla?

3. En caso negativo, ¿qué interfaz o clase debo extender para esta tarea? Supongo que mantener el camino que los tipos de Sun han hecho con el Deque es un buen comienzo.

Muchas gracias.

EDIT: Olvidé decir sobre la clase Stack: tengo mis dudas sobre esta clase cuando vi que implementa la clase Vector, y la clase Vector es un poco obsoleta, ¿no?

Answer 1

De hecho, hay una clase de pila: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Stack.html

Si no desea utilizar eso, la clase LinkedList (http://java.sun.com/j2se/1.5.0/docs/api/java/util/LinkedList.html) tiene addFirst y addLast y removeFirst y removeLast métodos, por lo que es perfecto para su uso como una pila o clase de cola.

Answer 2

Hay un Stack class in the API. ¿Esto satisfará tus necesidades?

Answer 3

Pila clase es lenta: métodos están sincronizadas + Stac k se extiende sincronizado vector

Answer 4

Soy consciente de que estoy tarde a la fiesta aquí, pero java.util.Collections Java (7) tiene un 'asLifoQueue' estático que toma un argumento Deque y devuelve (obviamente) una vista de cola LIFO del deque. No estoy seguro de qué versión se agregó.

http://docs.oracle.com/javase/7/docs/api/java/util/Collections.html#asLifoQueue(java.util.Deque)

Answer 5

Si bien esto se le preguntó hace un tiempo que podría ser aconsejable proporcionar una respuesta JDK6 +, que ahora ofrece una interfaz (cubierta) Deque que se realiza mediante la estructura de datos ArrayDeque y la LinkedList fue actualizado para implementar este interfaz. También existen formularios especializados para el acceso concurrente y están implementados por ConcurrentLinkedDeque y LinkedBlockingDeque.

Lo bueno de una deque es que proporciona compatibilidad con LIFO (pila) y FIFO (cola), ya que puede causar confusión en cuanto a qué métodos son para operaciones de cola y cuáles son para operaciones de pila para recién llegados.

mi humilde opinión el JDK debe tener una interfaz Stack y una interfaz de Queue que aún podría ser implementado por los gustos de ArrayDeque pero sólo exponer el subconjunto de métodos necesarios para que la estructura, es decir,LIFO podría definir pop(), push() y peek(), a continuación, en el contexto de

LIFO<String> stack = new ArrayDeque<>(); 

única pila operaciones están expuestas que se detiene a alguien accidentalmente llamar add(E) cuando push(E) que se pretendía.

Answer 6

Solo para completar, proporciono un ejemplo Dequeue y un LinkedList puro.

Mediante la interfaz de quitar de la cola en combinación con un LinkedList (recomendado):

Deque<String> dequeue = new LinkedList<>(); 
    dequeue.add("first"); 
    dequeue.add("last"); 

    // returns "last" without removing it 
    System.out.println(dequeue.peekLast()); 

    // removes and returns "last" 
    System.out.println(dequeue.pollLast()); 

Copia de seguridad de un quitar de la cola por un LinkedList es grande para el rendimiento, ya que la inserción y eliminación de elementos de ella se realiza en un tiempo constante (O (1)).

El uso de un solo LinkedList:

LinkedList<String> list = new LinkedList<>(); 
    list.add("first"); 
    list.add("last"); 

    // returns "last" without removing it 
    System.out.println(list.getLast()); 

    // removes and returns "last" 
    System.out.println(list.removeLast()); 

Answer 7

respuesta más simple sería utilizar un ArrayList, y sólo tiene que añadir objetos en el índice 0.

List<String> arrayList = new ArrayList<>(); 
arrayList.add(0, "three"); 
arrayList.add(0, "two"); 
arrayList.add(0, "one"); 

// Prints: [one, two, three] 
System.out.println(arrayList); 

agregar objetos en el índice 0 se agregará a la parte superior de la lista, y cambia el resto de la lista. Ahora tiene una estructura de datos LIFO simple y funcional.

EDITAR: Usar una lista enlazada es más rápido que usar una lista de arreglos. Entonces, usar LinkedList.addFirst() es mejor.