it-swarm.com.de

Java-Arrays zum Hinzufügen von Elementen am Anfang

Ich muss Elemente zu einer ArrayList-Warteschlange hinzufügen, aber wenn ich die Funktion zum Hinzufügen eines Elements aufrufe, möchte ich, dass das Element am Anfang des Arrays hinzugefügt wird (es hat also den niedrigsten Index) und das Array 10 Elemente hat Durch Hinzufügen neuer Ergebnisse wird das älteste Element (das Element mit dem höchsten Index) gelöscht.

Hat jemand irgendwelche Vorschläge?

132
ZeDonDino

List hat die Methode add(int, E) , so dass Sie Folgendes verwenden können:

list.add(0, yourObject);

Anschließend können Sie das letzte Element löschen mit:

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

Möglicherweise möchten Sie jedoch Ihre Anforderungen überdenken oder eine andere Datenstruktur verwenden, z. B. eine Queue .

EDIT

Werfen Sie einen Blick auf Apaches CircularFifoQueue :

CircularFifoQueue ist eine First-In-First-Out-Warteschlange mit fester Größe, die das älteste Element ersetzt, wenn es voll ist. 

Initialisieren Sie es einfach mit Ihrer maximalen Größe:

CircularFifoQueue queue = new CircularFifoQueue(10);
235
Baz

Bestimmte Datenstrukturen verwenden

Es gibt verschiedene Datenstrukturen, die für das Hinzufügen von Elementen am ersten Index optimiert sind. Beachten Sie jedoch, dass die Konversation wahrscheinlich eine zeitliche und räumliche Komplexität von O(n) erfordert, wenn Sie Ihre Sammlung in eine davon konvertieren. 

Deque

Das JDK enthält die Deque Struktur, die Methoden wie addFirst(e) und offerFirst(e) anbietet.

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

Analyse

Die räumliche und zeitliche Komplexität des Einfügens ist mit LinkedList konstant (O(1)). Siehe das Big-O Cheatsheet .

Umkehren der Liste

Eine sehr einfache, aber ineffiziente Methode ist die umgekehrte Verwendung:

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

Wenn Sie Java 8-Streams verwenden, könnte diese Antwort Sie interessieren.

Analyse

  • Zeitkomplexität: O(n)
  • Raumkomplexität: O(1)

Betrachtet man die JDK-Implementierung , hat dies eine O(n)-Zeitkomplexität, die nur für sehr kleine Listen geeignet ist.

21
patrickf

Sie können einen Blick auf das add (int index, E-Element) werfen:

Fügt das angegebene Element an der angegebenen Position in diese Liste ein. Verschiebt das Element, das sich an dieser Position befindet (sofern vorhanden) und ein beliebiges nachfolgende Elemente auf der rechten Seite (fügt eines ihrer Indizes hinzu).

Nach dem Hinzufügen können Sie die Größe der ArrayList überprüfen und am Ende die entfernen.

8
npinti

Vielleicht möchten Sie sich Deque ansehen. Sie haben direkten Zugriff auf den ersten und den letzten Eintrag in der Liste.

4
Evvo

Was Sie beschreiben, ist eine geeignete Situation, um Queue zu verwenden.

Da möchten Sie add neues Element und remove das alte Element. Sie können am Ende hinzufügen und vom Anfang entfernen. Das wird keinen großen Unterschied machen.

Die Warteschlange hat die Methoden add(e) und remove(), die am Ende das neue Element hinzufügt bzw. das alte Element von Anfang an entfernt.

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

Jedes Mal, wenn Sie der queue ein Element hinzufügen, können Sie es mit einem remove-Methodenaufruf sichern.


UPDATE: -

Und wenn Sie möchten, dass die Größe der Queue festlegt, können Sie einen Blick darauf werfen: - ApacheCommons#CircularFifoBuffer

Aus der documentation : -

CircularFifoBuffer ist ein FIFO-Puffer mit fester Größe das ersetzt sein ältestes Element, wenn es voll ist.

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

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

Wenn Sie die maximale Größe erreicht haben, wird beim Hinzufügen eines neuen Elements automatisch das erste eingefügte Element entfernt.

3
Rohit Jain

Ich denke, die Implementierung sollte einfach sein, aber in Anbetracht der Effizienz sollten Sie LinkedList verwenden, nicht ArrayList als Container. Sie können auf den folgenden Code verweisen:

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);
        }
    }
}
2
feikiss

Java LinkedList stellt sowohl die addFirst (E e) - als auch die Push (E e) -Methode bereit, die ein Element am Anfang der Liste hinzufügen.

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

2
Josh Grill

sie können diesen Code verwenden

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);
    }
}
1
MaVRoSCy
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);
 }
}
0

Ich hatte ein ähnliches Problem beim Versuch, ein Element am Anfang eines vorhandenen Arrays hinzuzufügen, die vorhandenen Elemente nach rechts zu verschieben und das älteste (array [length-1]) zu verwerfen aber es funktioniert für meine Zwecke.

 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

Viel Glück

0
FabianCid

Sie können Listenmethoden verwenden, entfernen und hinzufügen

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

Sie können verwenden

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

}

Ändern Sie E mit Ihrem Datentyp

Wenn das älteste Element gelöscht werden muss, können Sie Folgendes hinzufügen:

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

vor Rückgabeanweisung. Ansonsten fügt die Liste Ihr Objekt am Anfang hinzu und behält auch das älteste Element bei.

Dadurch wird das letzte Element in der Liste gelöscht.

0
a Learner