Tableaux Java comment ajouter des éléments au début

Utilisation De Structures De Données Spécifiques

Il existe différentes structures de données qui sont optimisées pour ajouter des éléments au premier index. Rappelez-vous cependant que si vous convertissez votre collection à l'une d'entre elles, la conversation aura probablement besoin d'une complexité temporelle et spatiale de O(n)

Deque

Le JDK comprend l'Deque structure qui propose des méthodes comme addFirst(e) et offerFirst(e)

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

Analyse

Espace et temps la complexité de l'insertion est avec LinkedList constante (O(1)). Voir la Big-O triche.

Inverser la liste

Une méthode très facile mais inefficace consiste à utiliser reverse:

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

Si vous utilisez les flux Java 8, cette réponse pourrait vous intéresser.

Analyse

• Complexité Temporelle: O(n)
• Complexité De L'Espace: O(1)

En regardant l'implémentation JDK cela a une complexité temporelle O(n) donc seulement convient pour de très petites listes.

Vous pouvez jeter un oeil à l'élément add (int index, E):

Insère l'élément spécifié à la position spécifiée dans cette liste. Déplace l'élément actuellement à cette position (le cas échéant) éléments suivants à droite (ajoute un à leurs indices).

Une fois que vous ajoutez, vous pouvez ensuite vérifier la taille de L'ArrayList et supprimer celles à la fin.

Vous pouvez regarder Deque. il vous donne un accès direct aux premier et dernier éléments de la liste.

Ce que vous décrivez, est une situation appropriée à utiliser Queue.

Puisque vous voulez add élément nouveau, et remove l'ancien. Vous pouvez ajouter à la fin, et supprimer du début. Cela ne fera pas beaucoup de différence.

La file d'attente a des méthodes add(e) et remove() qui ajoutent à la fin le nouvel élément, et supprime au début l'ancien élément, respectivement.

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

Donc, chaque fois que vous ajoutez un élément à l' queue, vous pouvez le sauvegarder avec un remove appel de méthode.

Mise à jour: -

Et si vous voulez pour fixer la taille de la Queue, ensuite, vous pouvez prendre un coup d'oeil à: - ApacheCommons#CircularFifoBuffer

À Partir de la documentation: -

CircularFifoBuffer est un tampon first in first out de taille fixe cela remplace son élément le plus ancien s'il est plein.

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

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

Comme vous pouvez le voir, lorsque la taille maximale est atteinte, l'ajout d'un nouvel élément supprime automatiquement la première élément inséré.

Je pense que l'implémentation devrait être facile, mais compte tenu de l'efficacité, vous devriez utiliser LinkedList mais pas ArrayList comme conteneur. Vous pouvez vous référer au code suivant:

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 fournit à la fois la méthode addFirst(E e) et la méthode push(E e) qui ajoutent un élément au début de la liste.

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

Vous pouvez utiliser ce code

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

Vous pouvez utiliser

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

}

Changez E avec votre type de données

Si la suppression de l'élément le plus ancien est nécessaire, vous pouvez ajouter:

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

Avant la déclaration de retour. Sinon list ajoutera votre objet au début et conservera également l'élément le plus ancien.

Cela supprimera le dernier élément de la liste.

Vous pouvez utiliser les méthodes list, supprimer et ajouter

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

, j'ai eu un problème similaire, en essayant d'ajouter un élément au début d'un tableau existant, déplacer les éléments vers la droite et jetez la plus ancienne (tableau[longueur-1]). Ma solution pourrait ne pas être très performante mais cela fonctionne pour mes besoins.

 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

Bonne chance

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