Java ArrayList come aggiungere elementi all'inizio

Devo aggiungere elementi a una ArrayListcoda qualunque, ma quando chiamo la funzione per aggiungere un elemento, voglio che aggiunga l'elemento all'inizio dell'array (quindi ha l'indice più basso) e se l'array ha 10 elementi aggiungendo un nuovo comporta l'eliminazione dell'elemento più vecchio (quello con l'indice più alto).

Qualcuno ha qualche suggerimento?

Listha il metodo add(int, E), quindi puoi usare:

list.add(0, yourObject);

Successivamente puoi eliminare l'ultimo elemento con:

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

Tuttavia, potresti voler ripensare i tuoi requisiti o utilizzare una diversa struttura di dati, come un Queue

MODIFICARE

Forse dai un'occhiata ad Apache CircularFifoQueue:

CircularFifoQueue è una coda first-in first-out con una dimensione fissa che sostituisce il suo elemento più vecchio se pieno.

Basta inizializzarlo con te dimensione massima:

CircularFifoQueue queue = new CircularFifoQueue(10);

Utilizzo di specifiche strutture dati

Esistono varie strutture dati ottimizzate per l'aggiunta di elementi al primo indice. Ricorda, tuttavia, che se converti la tua raccolta in una di queste, la conversazione avrà probabilmente bisogno di una complessità temporale e spazialeO(n)

deque

Il JDK include la Dequestruttura che offre metodi come addFirst(e)eofferFirst(e)

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

Analisi

La complessità di spazio e tempo dell'inserimento è con LinkedListcostante ( O(1)). Vedi il cheatsheet di Big-O .

Invertire l'elenco

Un metodo molto semplice ma inefficiente è usare il contrario:

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

Se usi stream Java 8, questa risposta potrebbe interessarti.

Analisi

• Complessità temporale: O(n)
• Complessità spaziale: O(1)

Guardando l' implementazione di JDK questo ha una O(n)complessità temporale quindi adatta solo per elenchi molto piccoli.

Puoi dare un'occhiata all'aggiunta (indice int, elemento E) :

Inserisce l'elemento specificato nella posizione specificata in questo elenco. Sposta l'elemento attualmente in quella posizione (se presente) e tutti gli elementi successivi a destra (aggiunge uno ai loro indici).

Una volta aggiunto, è possibile quindi controllare le dimensioni dell'ArrayList e rimuovere quelle alla fine.

Potresti voler guardare Deque. ti dà accesso diretto sia al primo che all'ultimo elemento dell'elenco.

Quello che stai descrivendo è una situazione appropriata da usare Queue.

Dal momento che vuoi addnuovo elemento, e removequello vecchio. È possibile aggiungere alla fine e rimuovere dall'inizio. Ciò non farà molta differenza.

La coda ha metodi add(e)e remove()che aggiunge alla fine il nuovo elemento e rimuove dall'inizio il vecchio elemento, rispettivamente.

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

Quindi, ogni volta che aggiungi un elemento a queuepuoi eseguirne il backup con una removechiamata di metodo.

AGGIORNAMENTO : -

E se vuoi correggere la dimensione delQueue , allora puoi dare un'occhiata a: -ApacheCommons#CircularFifoBuffer

Dal documentation: -

CircularFifoBuffer è un buffer first in first out con una dimensione fissa che sostituisce il suo elemento più vecchio se pieno.

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

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

Come puoi vedere, quando viene raggiunta la dimensione massima, l'aggiunta di un nuovo elemento rimuove automaticamente il primo elemento inserito.

Penso che l'attrezzo dovrebbe essere facile, ma considerando l'efficienza, dovresti usare LinkedList ma non ArrayList come contenitore. È possibile fare riferimento al seguente codice:

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 fornisce sia il metodo addFirst (E e) che il metodo push (E e) che aggiungono un elemento all'inizio dell'elenco.

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

puoi usare questo codice

private List myList = new ArrayList();
private void addItemToList(Object obj){
    if(myList.size()<10){
      myList.add(0,obj);
    }else{
      myList.add(0,obj);
      myList.remove(10);
    }
}

È possibile utilizzare i metodi di elenco, rimuovere e aggiungere

list.add(lowestIndex, element);
list.remove(highestIndex, element);

Prendi questo esempio: -

List<String> element1 = new ArrayList<>();
element1.add("two");
element1.add("three");
List<String> element2 = new ArrayList<>();
element2.add("one");
element2.addAll(element1);

Puoi usare

public List<E> addToListStart(List<E> list, E obj){
list.add(0,obj);
return (List<E>)list;

}

Cambia E con il tuo tipo di dati

Se è necessario eliminare l'elemento meno recente, è possibile aggiungere:

list.remove(list.size()-1); 

prima della dichiarazione di ritorno. Altrimenti l'elenco aggiungerà il tuo oggetto all'inizio e manterrà anche l'elemento più vecchio.

Ciò eliminerà l'ultimo elemento nell'elenco.

import java.util.*:
public class Logic {
  List<String> list = new ArrayList<String>();
  public static void main(String...args) {
  Scanner input = new Scanner(System.in);
    Logic obj = new Logic();
      for (int i=0;i<=20;i++) {
        String string = input.nextLine();
        obj.myLogic(string);
        obj.printList();
      }
 }
 public void myLogic(String strObj) {
   if (this.list.size()>=10) {
      this.list.remove(this.list.size()-1);
   } else {
     list.add(strObj); 
   }
 }
 public void printList() {
 System.out.print(this.list);
 }
}

Ho avuto un problema simile, cercando di aggiungere un elemento all'inizio di un array esistente, spostare gli elementi esistenti a destra e scartare quello più vecchio (array [lunghezza-1]). La mia soluzione potrebbe non essere molto performante ma funziona per i miei scopi.

 Method:

   updateArray (Element to insert)

     - for all the elements of the Array
       - start from the end and replace with the one on the left; 
     - Array [0] <- Element

In bocca al lupo