Ajouter un objet à ArrayList à l'index spécifié

Je pense que c'est une question assez simple, mais je ne sais pas comment faire cela correctement.

J'ai une arraylist vide:

ArrayList<object> list = new ArrayList<object>();

J'ai des objets que je veux ajouter et chaque objet doit être à une certaine position. Il faut cependant qu'ils puissent être ajoutés dans chaque ordre possible. Quand j'essaye ceci, cela ne fonctionne pas et j'obtiens un IndexOutOfBoundsException:

list.add(1, object1)
list.add(3, object3)
list.add(2, object2)

Ce que j'ai essayé, c'est de remplir le ArrayListavec null, puis de faire ce qui précède. Cela fonctionne, mais je pense que c'est une solution horrible. Y a-t-il une autre façon de faire cela?

Vous pouvez le faire comme ceci:

list.add(1, object1)
list.add(2, object3)
list.add(2, object2)

Après avoir ajouté object2 à la position 2, il déplacera object3 vers la position 3.

Si vous voulez que object3 soit à la position3 tout le temps, je vous suggère d'utiliser un HashMap avec la position comme clé et l'objet comme valeur.

Vous pouvez utiliser un tableau d'objets et le convertir en ArrayList-

Object[] array= new Object[10];
array[0]="1";
array[3]= "3";
array[2]="2";
array[7]="7";

List<Object> list= Arrays.asList(array);

ArrayList sera- [1, null, 2, 3, null, null, null, 7, null, null]

Si tel est le cas, pourquoi ne pas envisager d'utiliser un tableau standard, initialiser la capacité et placer les objets à l'index souhaité.

Object[] list = new Object[10];

list[0] = object1;
list[2] = object3;
list[1] = object2;

Vous pouvez également remplacer ArrayList pour insérer des valeurs nulles entre votre taille et l'élément que vous souhaitez ajouter.

import java.util.ArrayList;


public class ArrayListAnySize<E> extends ArrayList<E>{
    @Override
    public void add(int index, E element){
        if(index >= 0 && index <= size()){
            super.add(index, element);
            return;
        }
        int insertNulls = index - size();
        for(int i = 0; i < insertNulls; i++){
            super.add(null);
        }
        super.add(element);
    }
}

Ensuite, vous pouvez ajouter à tout moment dans ArrayList. Par exemple, cette méthode principale:

public static void main(String[] args){
    ArrayListAnySize<String> a = new ArrayListAnySize<>();
    a.add("zero");
    a.add("one");
    a.add("two");
    a.add(5,"five");
    for(int i = 0; i < a.size(); i++){
        System.out.println(i+": "+a.get(i));
    }
}   

renvoie ce résultat de la console:

0: zéro

1 un

2: deux

3: nul

4: nul

5: cinq

J'attire votre attention sur la ArrayList.adddocumentation , qui dit qu'elle jette IndexOutOfBoundsException- si l'index est hors de portée (index < 0 || index > size() )

Vérifiez le size()de votre liste avant d'appelerlist.add(1, object1)

Vous devez remplir les index vides avec des valeurs nulles.

while (arraylist.size() < position)
{
     arraylist.add(null);
}

arraylist.add(position, object);

@Maethortje 

The problem here is java creates an empty list when you called new ArrayList and 

en essayant d'ajouter un élément à la position spécifiée, vous avez obtenu IndexOutOfBound, de sorte que la liste doit avoir des éléments à leur position.

Veuillez essayer de suivre

/*
  Add an element to specified index of Java ArrayList Example
  This Java Example shows how to add an element at specified index of java
  ArrayList object using add method.
*/

import java.util.ArrayList;

public class AddElementToSpecifiedIndexArrayListExample {

  public static void main(String[] args) {
    //create an ArrayList object
    ArrayList arrayList = new ArrayList();

    //Add elements to Arraylist
    arrayList.add("1");
    arrayList.add("2");
    arrayList.add("3");

    /*
      To add an element at the specified index of ArrayList use
      void add(int index, Object obj) method.
      This method inserts the specified element at the specified index in the
      ArrayList.  
    */
    arrayList.add(1,"INSERTED ELEMENT");

    /*
      Please note that add method DOES NOT overwrites the element previously
      at the specified index in the list. It shifts the elements to right side
      and increasing the list size by 1.
    */

    System.out.println("ArrayList contains...");
    //display elements of ArrayList
    for(int index=0; index < arrayList.size(); index++)
      System.out.println(arrayList.get(index));

  }
}

/*
Output would be
ArrayList contains...
1
INSERTED ELEMENT
2
3

*/

Que diriez-vous de cette petite whileboucle comme solution?

private ArrayList<Object> list = new ArrayList<Object>();

private void addObject(int i, Object object) {
    while(list.size() < i) {
        list.add(list.size(), null);
    }
    list.add(i, object);
}
....

addObject(1, object1)
addObject(3, object3)
addObject(2, object2)

Voici une solution possible:

list.add(list.size(), new Object());

Je pense que la solution de medopal est ce que vous recherchez.

Mais une autre solution alternative consiste à utiliser un HashMap et à utiliser la clé (Integer) pour stocker les positions.

De cette façon, vous n'aurez pas besoin de le remplir initialement avec des valeurs nulles, etc., collez simplement la position et l'objet dans la carte au fur et à mesure. Vous pouvez écrire quelques lignes à la fin pour le convertir en liste si vous en avez besoin de cette façon.

Supposons que vous souhaitiez ajouter un élément à une position, alors la taille de la liste doit être supérieure à la position.

add(2, item): cette syntaxe signifie, déplacer l'ancien élément à la position 2 vers l'index suivant et ajouter l'élément à la 2ème position.

S'il n'y a pas d'élément en 2ème position, cela ne fonctionnera pas, cela lancera une exception.

Cela signifie que si vous souhaitez ajouter quelque chose dansposition 2,

la taille de votre liste doit être au moins (2 + 1) =3,pour que les articles soient disponibles à0,1,2 Position.

de cette manière, il est garanti que la position 2 est accessible en toute sécurité et il n'y aurait pas d'exception.

Si vous utilisez la saveur Android de Java, puis-je suggérer d'utiliser un SparseArray . C'est un mappage plus efficace en mémoire des entiers aux objets et plus facile à parcourir qu'une mappe

Un peu tard mais j'espère qu'il peut encore être utile à quelqu'un.

2 étapes pour ajouter des éléments à une position spécifique dans un ArrayList

1. add éléments nuls à un index spécifique dans un ArrayList

2. Puis setles positions au fur et à mesure des besoins.

       list = new ArrayList();//Initialise the ArrayList
   for (Integer i = 0; i < mItems.size(); i++) {
       list.add(i, null); //"Add" all positions to null
   }
      // "Set" Items
       list.set(position, SomeObject);

De cette façon, vous n'avez pas d'éléments redondants dans le ArrayListie si vous deviez ajouter des éléments tels que,

list = new ArrayList(mItems.size());    
list.add(position, SomeObject);

Cela n'écraserait pas simplement les éléments existants dans la position, en déplaçant les éléments existants vers la droite par un - vous avez donc une ArrayList avec deux fois plus d'indices.

Vous devez définir au lieu d'ajouter pour remplacer la valeur existante à l'index.

list.add(1, object1)
list.add(2, object3)
list.set(2, object2)

La liste contiendra [objet1, objet2]