Collections Java (structure LIFO ))

Pile la classe est lente: les méthodes sont synchronisées + Stack s'étend synchronisés vecteur

je me rends compte que je suis en retard à la fête ici, mais java.util.Collections (Java 7) a une 'asLifoQueue' statique qui prend un argument Deque et renvoie (évidemment) une vue de la file D'attente LIFO de la deque. Je ne sais pas quelle version a été ajoutée.

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

il y a un Stack class dans L'API. Sera-ce répondre à vos besoins?

alors que cela a été demandé il y a un certain temps, il pourrait être sage de fournir une réponse JDK6+ qui fournit maintenant un Deque interface (deck) qui est implémentée par Arraydequeque structure des données et la LinkedList a été mis à jour pour implémenter cette interface. Spécialisé formes pour l'accès simultané existent également et sont mis en œuvre par ConcurrentLinkedDeque et LinkedBlockingDeque.

La seule chose qui est formidable à propos de un deque est qu'il fournit à la fois le support LIFO (stack) et le support FIFO (queue) il peut causer de la confusion quant aux méthodes qui sont pour les opérations de file d'attente et qui sont pour les opérations de pile pour les nouveaux venus.

IMHO le JDK devrait avoir un Stack interface et a Queue interface qui pourrait encore être implémentée par des personnes comme Arraydequeque mais seulement exposer le sous-ensemble de méthodes nécessaires pour cette structure, c.-à-d. un LIFO pourrait définir pop(),push() et peek(), puis dans le contexte

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

seules les opérations de pile sont exposées qui empêchent quelqu'un d'appeler accidentellement add(e) quand push (E) a été prévu.

juste par souci d'exhaustivité, je vous propose un exemple de "Dequeue" et de "Pure LinkedList".

utilisation de L'interface Dequeue en combinaison avec une LinkedList (recommandé):

    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());

sauvegarder une série par une LinkedList est parfait pour la performance, puisque l'insertion et la suppression des éléments de celle-ci se font en temps constant (O(1)).

à l'Aide d'une LinkedList seul:

    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());

réponse la plus Simple serait d'utiliser un ArrayList, et juste ajouter des objets à l'indice 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);

ajouter des objets à l'index 0 ajoutera en haut de la liste, et déplace le reste de la liste. Vous disposez maintenant d'une structure de données LIFO simple et fonctionnelle.

EDIT: utiliser une LinkedList est plus rapide que d'utiliser un ArrayList. Donc, en utilisant LinkedList.addFirst () est mieux.