Est-il fixe la taille de la file d'attente qui supprime les éléments excessives?

Il n'y a pas de mise en œuvre existantes dans le Langage Java et de l'Exécution. Toutes les Files d'attente s'étendre AbstractQueue, et sa doc stipule clairement que l'ajout d'un élément à une pleine file d'attente se termine toujours par une exception. Il serait préférable ( et très simple ) pour envelopper une File d'attente dans une classe de votre choix pour avoir les fonctionnalités dont vous avez besoin.

Une fois de plus, parce que toutes les files d'attente sont des enfants de AbstractQueue, il suffit de l'utiliser comme votre intérieur type de données et vous devriez avoir une mise en œuvre souple cours d'exécution dans pratiquement pas de temps 🙂

Mise à JOUR:

Comme indiqué ci-dessous, il y a deux implémentations disponibles (cette réponse est assez vieux, les gens!), voir cette réponse pour plus de détails.

Oui, Deux

De mon propre double question avec cette réponse correcte, j'ai appris de deux:

• EvictingQueue dans Google Goyave
• CircularFifoQueue dans Apache Commons

J'ai fait de l'utilisation productive de la Goyave EvictingQueue, a bien fonctionné.

C'est ce que j'ai fait avec Queue enveloppé avec LinkedList, Il est résolu de taille moyenne dont je donne ici est 2;

public static Queue<String> pageQueue;

pageQueue = new LinkedList<String>(){
            private static final long serialVersionUID = -6707803882461262867L;

            public boolean add(String object) {
                boolean result;
                if(this.size() < 2)
                    result = super.add(object);
                else
                {
                    super.removeFirst();
                    result = super.add(object);
                }
                return result;
            }
        };


....
TMarket.pageQueue.add("ScreenOne");
....
TMarket.pageQueue.add("ScreenTwo");
.....

Cette classe ne comprend le travail à l'aide de la composition à la place de l'héritage (d'autres réponses ici) qui supprime la possibilité de certains effets secondaires (couvertes par Josh Bloch, pour l'Essentiel, Java). Le découpage de la sous-jacentes LinkedList se produit sur les méthodes add,addAll et à offrir.

import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
public class LimitedQueue<T> implements Queue<T>, Iterable<T> {
private final int limit;
private final LinkedList<T> list = new LinkedList<T>();
public LimitedQueue(int limit) {
this.limit = limit;
}
private boolean trim() {
boolean changed = list.size() > limit;
while (list.size() > limit) {
list.remove();
}
return changed;
}
@Override
public boolean add(T o) {
boolean changed = list.add(o);
boolean trimmed = trim();
return changed || trimmed;
}
@Override
public int size() {
return list.size();
}
@Override
public boolean isEmpty() {
return list.isEmpty();
}
@Override
public boolean contains(Object o) {
return list.contains(o);
}
@Override
public Iterator<T> iterator() {
return list.iterator();
}
@Override
public Object[] toArray() {
return list.toArray();
}
@Override
public <T> T[] toArray(T[] a) {
return list.toArray(a);
}
@Override
public boolean remove(Object o) {
return list.remove(o);
}
@Override
public boolean containsAll(Collection<?> c) {
return list.containsAll(c);
}
@Override
public boolean addAll(Collection<? extends T> c) {
boolean changed = list.addAll(c);
boolean trimmed = trim();
return changed || trimmed;
}
@Override
public boolean removeAll(Collection<?> c) {
return list.removeAll(c);
}
@Override
public boolean retainAll(Collection<?> c) {
return list.retainAll(c);
}
@Override
public void clear() {
list.clear();
}
@Override
public boolean offer(T e) {
boolean changed = list.offer(e);
boolean trimmed = trim();
return changed || trimmed;
}
@Override
public T remove() {
return list.remove();
}
@Override
public T poll() {
return list.poll();
}
@Override
public T element() {
return list.element();
}
@Override
public T peek() {
return list.peek();
}
}

Sonne comme une banale Liste de où la méthode add contient une séquence supplémentaire qui tronque la liste si elle devient trop long.

Si c'est trop simple, alors vous devrez probablement modifier la description du problème.

Il n'est pas tout à fait clair quelles sont les exigences que vous avez qui vous a amené à poser cette question. Si vous avez besoin d'une taille fixe structure de données, vous pouvez également regarder les différentes stratégies de mise en cache. Cependant, puisque vous avez une file d'attente, ma meilleure supposition est que vous êtes à la recherche d'un certain type de fonctionnalité de routeur. Dans ce cas, j'irais avec un anneau de la mémoire tampon: un tableau qui a un prénom et un index. Chaque fois qu'un élément est ajouté, vous avez juste incrémenter le dernier élément de l'index, et lorsqu'un élément est supprimé, incrémenter le premier index de l'élément. Dans les deux cas, l'addition est effectuée modulo la taille du tableau, et assurez-vous d'incrémenter l'indice lorsque cela est nécessaire, c'est à dire lorsque la file d'attente est vide ou plein.

Aussi, si c'est un routeur de type application, vous pouvez également expérimenter avec un algorithme tel que Random Early Tomber (en ROUGE), ce qui tombe des éléments de la file d'attente de manière aléatoire, même avant qu'il soit rempli. Dans certains cas, le ROUGE a été trouvé pour avoir une meilleure performance globale que la simple méthode de permettre à la file d'attente pour faire le plein avant de laisser tomber.

Je pense que la meilleur réponse est de cette autre question.

Apache commons collections de 4 a un CircularFifoQueue qui est ce que vous cherchez. Citant la javadoc:

CircularFifoQueue est un premier entré, premier sorti de la file d'attente avec une taille fixe qui remplace le plus ancien élément si complet.