java - tad - Creando una pila de tamaño fijo

pila java peek

Question

Quiero crear una pila en Java, pero arreglar el tamaño. Por ejemplo, cree una nueva pila, establezca el tamaño en 10, luego, cuando empujo los elementos a la pila, se llena y cuando se llena hasta diez, el último elemento de la pila se retira (se quita). Quiero usar Stack porque usa LIFO y se adapta muy bien a mis necesidades.

Pero el método setSize () que Stack hereda de Vector no parece limitar realmente el tamaño de la Pila. Creo que me estoy perdiendo algo acerca de cómo funcionan las Pilas, o tal vez las Pilas no debían estar restringidas por lo que es imposible. ¡Por favor educame!

Answer 1

Aquí hay un tipo de SizedStack que extiende la Stack :

import java.util.Stack;

public class SizedStack<T> extends Stack<T> {
    private int maxSize;

    public SizedStack(int size) {
        super();
        this.maxSize = size;
    }

    @Override
    public T push(T object) {
        //If the stack is too big, remove elements until it''s the right size.
        while (this.size() >= maxSize) {
            this.remove(0);
        }
        return super.push(object);
    }
}

Úselo así: SizedStack<Float> mySizedStack = new SizedStack<Float>(10); . Aparte del tamaño, funciona como cualquier otra Stack .

Answer 2

Esto no es imposible :) Solo tienes que proporcionar tu propia implementación.

Comenzaría con un RingBuffer como this y lo ajustaría en consecuencia.

Answer 3

Lo que necesitas es una cola de doble final como LinkedList . Sin embargo, esto no eliminaría automáticamente los elementos en la parte frontal, pero al crear una subclase / decoración, podría agregar esa funcionalidad.

Answer 4

Puede crear una subclase de Stack y anular los métodos apropiados para implementar este comportamiento personalizado. Y asegúrese de darle un nombre claro (por ejemplo, FixedStack ).

Answer 5

Puede usar LinkedHashMap y anular su método removeEldestEntry:

public class FixedStack extends LinkedHashMap<Long, String> {

    private final int capacity;

    public FixedStack(int capacity) {
        this.capacity = capacity;
    }

    @Override
    protected boolean removeEldestEntry(final Map.Entry<Long, String> eldest) {
        return super.size() > capacity;
    }
}

Y para probarlo:

    public static void main(String[] args) {

        FixedStack stack = new FixedStack(10);

        long added = 0;
        for (Locale locale : Locale.getAvailableLocales()) {
            if (locale.getDisplayCountry().length() > 0) {
                stack.put(added, locale.getDisplayCountry());
                System.out.println(locale.getDisplayCountry());
                added++;
            }
        }
        System.out.println(String.format(">>>>>>>>> %s added",
                added));
        Iterator<Entry<Long, String>> iterator = stack.entrySet().iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next().getValue());
        }
    }

Solo tienes que decidir qué quieres usar como clave, usé un contador simple en el ejemplo.

Answer 6

Puedes crear una pila muy simple como esta:

public class FixedStack<T>
{
    private T[] stack;
    private int size;
    private int top;

    public FixedStack<T>(int size)
    {
        this.stack = (T[]) new Object[size];
        this.top = -1;
        this.size = size;
    }

    public void push(T obj)
    {
        if (top >= size)
            throw new IndexOutOfBoundsException("Stack size = " + size);
        stack[++top] = obj;
    }

    public T pop()
    {
        if (top < 0) throw new IndexOutOfBoundsException();
        T obj = stack[top--];
        stack[top + 1] = null;
        return obj;
    }

    public int size()
    {
        return size;
    }

    public int elements()
    {
        return top + 1;
    }
}

Answer 7

Un LinkedBlockingDeque es una opción simple. Use el LinkedBlockingQueue(int) donde el parámetro es el límite de su pila.

Como has observado, Stack y Vector modelan secuencias ilimitadas. El método setSize() trunca la pila / vector. No impide que la estructura de datos crezca más allá de ese tamaño.

Answer 8

Una pila pura no limitaría su tamaño, ya que para muchos de los problemas que solucionan las pilas no sabes cuántos elementos necesitarás.

Podría escribir una pila personalizada que implemente las necesidades que describió. Sin embargo, romperás LIFO si lo haces. Si se cumple el tamaño máximo y empuja algo nuevo en la pila, simplemente pierde el elemento agregado previamente. Así que si luego empiezas a sacar objetos de tu pila, te perderás algunos.