web-dev-qa-db-fra.com

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

J'ai besoin d'ajouter des éléments à une file d'attente ArrayList, peu importe, mais quand j'appelle la fonction pour ajouter un élément, je veux qu'il ajoute l'élément au début du tableau (il a donc le plus bas index) et si le tableau a 10 éléments l'ajout d'un nouveau résultat en supprimant l'élément le plus ancien (celui avec l'indice le plus élevé).

Est-ce que quelqu'un a des suggestions?

javaarraysarrayliststack
132
ZeDonDino

List a la méthode add(int, E) , vous pouvez donc utiliser:

list.add(0, yourObject);

Ensuite, vous pouvez supprimer le dernier élément avec:

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

Cependant, vous voudrez peut-être repenser vos exigences ou utiliser une structure de données différente, telle qu'une structure Queue

MODIFIER

Jetez peut-être un coup d'œil au CircularFifoQueue :

CircularFifoQueue est une file d'attente premier entré, premier sorti avec une taille fixe qui remplace son élément le plus ancien si complet. 

Il suffit de l'initialiser avec votre taille maximale:

CircularFifoQueue queue = new CircularFifoQueue(10);
235
Baz

Utiliser des infrastructures de données spécifiques

Diverses structures de données sont optimisées pour l’ajout d’éléments au premier index. Toutefois, sachez que si vous convertissez votre collection en l'un de ces éléments, la conversation nécessitera probablement une complexité temporelle et spatiale de O(n) 

Deque

Le JDK inclut la structure Deque qui propose des méthodes telles que addFirst(e) et offerFirst(e) .

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

Une analyse

La complexité spatiale et temporelle de l'insertion est avec LinkedList constante (O(1)). Voir la feuille de triche Big-O .

Inverser la liste

Une méthode très simple mais peu efficace consiste à utiliser l'inverse:

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

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

Une analyse

  • Complexité temporelle: O(n)
  • Complexité de l'espace: O(1)

En ce qui concerne l’implémentation JDK , la complexité temporelle est O(n) et ne convient donc que pour de très petites listes.

21
patrickf

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

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

Une fois que vous avez ajouté, vous pouvez vérifier la taille de la liste de tableaux et supprimer celles qui se trouvent à la fin.

8
npinti

Vous voudrez peut-être regarder Deque. il vous donne un accès direct au premier et au dernier élément de la liste.

4
Evvo

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

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

Queue a les méthodes add(e) et remove() qui ajoutent à la fin le nouvel élément et suppriment du début l’ancien élément, respectivement.

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

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

METTRE &AGRAVE; JOUR: -

Et si vous voulez que fixe la taille de Queue, vous pouvez jeter un coup d'œil à: - ApacheCommons#CircularFifoBuffer

De la documentation : -

CircularFifoBuffer est un tampon premier entré premier sorti avec une taille fixe qui 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 constater, lorsque la taille maximale est atteinte, l'ajout d'un nouvel élément supprime automatiquement le premier élément inséré.

3
Rohit Jain

Je pense que l'implémentation devrait être facile, mais compte tenu de l'efficacité, vous devriez utiliser LinkedList mais pas ArrayList en tant que 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);
        }
    }
}
2
feikiss

Java LinkedList fournit à la fois les méthodes addFirst (E e) et 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)

2
Josh Grill

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

J'ai eu un problème similaire en essayant d'ajouter un élément au début d'un tableau existant, de décaler les éléments existants vers la droite et d'éliminer le plus ancien (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

0
FabianCid

Vous pouvez utiliser des méthodes de liste, supprimer et ajouter

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

Vous pouvez utiliser

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

}

Changer 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.

0
a Learner