Java ArrayList cómo agregar elementos al principio

Necesito agregar elementos a un ArrayList poner en cola lo que sea, pero cuando llamo a la función para agregar un elemento, quiero que agregue el elemento al comienzo de la matriz (para que tenga el índice más bajo) y si la matriz tiene 10 elementos, agregar un nuevo resultado eliminando el más antiguo elemento (el de mayor índice).

¿Alguien tiene alguna sugerencia?

List tiene el metodo add(int, E)por lo que puede utilizar:

list.add(0, yourObject);

Luego puede eliminar el último elemento con:

if(list.size() > 10)
    list.remove(list.size() - 1);

Sin embargo, es posible que desee reconsiderar sus requisitos o utilizar una estructura de datos diferente, como un Queue

EDITAR

Tal vez eche un vistazo a Apache CircularFifoQueue:

CircularFifoQueue es una cola de primero en entrar, primero en salir con un tamaño fijo que reemplaza su elemento más antiguo si está lleno.

Simplemente inicialícelo con su tamaño máximo:

CircularFifoQueue queue = new CircularFifoQueue(10);

Uso de estructuras de datos específicas

Hay varias estructuras de datos que están optimizadas para agregar elementos en el primer índice. Sin embargo, tenga en cuenta que si convierte su colección en una de estas, la conversación probablemente necesitará una complejidad de tiempo y espacio de O(n)

Deque

El JDK incluye el Deque estructura que ofrece métodos como addFirst(e) y offerFirst(e)

Deque<String> deque = new LinkedList<>();
deque.add("two");
deque.add("one");
deque.addFirst("three");
//prints "three", "two", "one"

Análisis

La complejidad espacial y temporal de la inserción es con LinkedList constante (O(1)). Ver el Hoja de trucos de Big-O.

Invertir la lista

Un método muy fácil pero ineficiente es usar el reverso:

 Collections.reverse(list);
 list.add(elementForTop);
 Collections.reverse(list);

Si usa flujos de Java 8, esta respuesta podría interesarle.

Análisis

• Complejidad del tiempo: O(n)
• Complejidad espacial: O(1)

Mirando a la implementación de JDK esto tiene un O(n) Complejidad de tiempo, por lo que solo es adecuado para listas muy pequeñas.

Puedes echar un vistazo a la agregar (índice int, elemento E):

Inserta el elemento especificado en la posición especificada en esta lista. Cambia el elemento actualmente en esa posición (si lo hay) y cualquier elemento subsiguiente a la derecha (agrega uno a sus índices).

Una vez que agregue, puede verificar el tamaño de ArrayList y eliminar los que están al final.

Es posible que desee mirar a Deque. le da acceso directo tanto al primer como al último elemento de la lista.

Lo que estás describiendo, es una situación apropiada para usar Queue.

Ya que quieres add elemento nuevo y remove el viejo. Puede agregar al final y eliminar desde el principio. Eso no hará mucha diferencia.

La cola tiene métodos add(e) y remove() que agrega al final el nuevo elemento y elimina desde el principio el elemento anterior, respectivamente.

Queue<Integer> queue = new LinkedList<Integer>();
queue.add(5);
queue.add(6);
queue.remove();  // Remove 5

Entonces, cada vez que agregas un elemento al queue puedes respaldarlo con un remove llamada de método.

ACTUALIZAR: –

Y si tu quieres para fijar el tamaño de la Queueentonces puedes echar un vistazo a: – ApacheCommons#CircularFifoBuffer

Desde el documentation: –

CircularFifoBuffer es un búfer primero en entrar, primero en salir con un tamaño fijo que reemplaza su elemento más antiguo si está lleno.

Buffer queue = new CircularFifoBuffer(2); // Max size

queue.add(5);
queue.add(6);
queue.add(7);  // Automatically removes the first element `5`

Como puede ver, cuando se alcanza el tamaño máximo, al agregar un nuevo elemento se elimina automáticamente el primer elemento insertado.

Creo que la implementación debería ser fácil, pero teniendo en cuenta la eficiencia, debe usar LinkedList pero no ArrayList como contenedor. Puede consultar el siguiente código:

import java.util.LinkedList;
import java.util.List;

public class DataContainer {

    private List<Integer> list;

    int length = 10;
    public void addDataToArrayList(int data){
        list.add(0, data);
        if(list.size()>10){
            list.remove(length);
        }
    }

    public static void main(String[] args) {
        DataContainer comp = new DataContainer();
        comp.list = new LinkedList<Integer>();

        int cycleCount = 100000000;

        for(int i = 0; i < cycleCount; i ++){
            comp.addDataToArrayList(i);
        }
    }
}

Java LinkedList proporciona los métodos addFirst(E e) y push(E e) que agregan un elemento al principio de la lista.

https://docs.oracle.com/javase/7/docs/api/java/util/LinkedList.html#addFirst(E)