web-dev-qa-db-fra.com

Comment ajouter un élément à Array et décaler les index?

J'ai besoin d'ajouter un élément à Array en spécifiant la position et la valeur .Par exemple, j'ai Array

int []a = {1, 2, 3, 4, 5, 6};

après application addPos(int 4, int 87) il devrait être

int []a = {1, 2, 3, 4, 87, 5};

Je comprends qu’il devrait y avoir un décalage des index de Array, mais je ne vois pas comment le mettre en œuvre dans le code.

javaarrays
14
devger

Cela devrait faire l'affaire:

public static int[] addPos(int[] a, int pos, int num) {
    int[] result = new int[a.length];
    for(int i = 0; i < pos; i++)
        result[i] = a[i];
    result[pos] = num;
    for(int i = pos + 1; i < a.length; i++)
        result[i] = a[i - 1];
    return result;
}

Où a est le tableau d'origine, pos est la position d'insertion et num est le nombre à insérer.

14
jrad

Le moyen le plus simple consiste à utiliser un ArrayList<Integer> et à utiliser la méthode add(int, T).

List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);

// Now, we will insert the number
list.add(4, 87);
8
Martijn Courteaux

Vous devez créer un nouveau tableau, utiliser System.arraycopy pour copier le préfixe et le suffixe, puis définir cet emplacement sur la nouvelle valeur.

7
Marko Topolnik

La solution de Jrad est bonne mais je n'aime pas le fait qu'il n'utilise pas la copie de tableau. En interne, System.arraycopy () effectue un appel natif pour vous permettre d’obtenir des résultats plus rapidement. 

public static int[] addPos(int[] a, int index, int num) {
    int[] result = new int[a.length];
    System.arraycopy(a, 0, result, 0, index);
    System.arraycopy(a, index, result, index + 1, a.length - index - 1);
    result[index] = num;
    return result;
}
5
user1121883

Je sens les devoirs, donc probablement pas un ArrayList (?) 

Au lieu de chercher un moyen de "décaler les index", peut-être juste construire un nouveau tableau:

int[] b = new int[a.length +1];

Ensuite

  1. copier les index sous forme de tableau a en comptant de zéro à insérer
  2. ...
  3. ...

// edit: copie les valeurs bien sûr, pas les index

4
pafau k.

Jetez un coup d'œil à commons . Il utilise arrayCopy (), mais a une syntaxe plus agréable. Pour ceux qui répondent avec le code élément par élément: s'il ne s'agit pas d'un devoir, c'est trivial et la réponse intéressante est celle qui favorise la réutilisation. Pour ceux qui proposent des listes: les lecteurs le savent probablement aussi et les problèmes de performance doivent être mentionnés.

2
zakmck

À moins que quelque chose ne me manque, la question ne concerne pas l'augmentation de la taille du tableau. Dans l'exemple, la taille du tableau reste la même. (Comme un peu de décalage.) Dans ce cas, il n'y a vraiment aucune raison de créer un nouveau tableau ou de le copier. Cela devrait faire l'affaire:

static void addPos(int[] array, int pos, int value) {
    // initially set to value parameter so the first iteration, the value is replaced by it
    int prevValue = value;

    // Shift all elements to the right, starting at pos
    for (int i = pos; i < array.length; i++) {
        int tmp = prevValue;
        prevValue = array[i];
        array[i] = tmp;
    }
}

int []a = {1, 2, 3, 4, 5, 6};
addPos(a, 4, 87);
// output: {1, 2, 3, 4, 87, 5}
2
Ivar

Voici un quasi-oneliner qui le fait:

String[] prependedArray = new ArrayList<String>() {
  {
    add("newElement");
    addAll(Arrays.asList(originalArray));
  }
}.toArray(new String[0]);
2
Tomasz

Si vous préférez utiliser Apache Commons plutôt que de réinventer la roue, l'approche actuelle est la suivante:

a = ArrayUtils.insert(4, a, 87);

C'était autrefois ArrayUtils.add (...), mais c'était obsolète depuis un moment. Plus d'infos ici: 1

1
Fran Marzoa

org.Apache.commons.lang3.ArrayUtils#add(T[], int, T) est obsolète dans lang3, le plus récent commun, vous pouvez utiliser org.Apache.commons.lang3.ArrayUtils#insert(int, T[], T...) à la place.

Obsolète, cette méthode a été remplacée par insert (int, T [], T ...) et pourrait être supprimée dans une version ultérieure. Veuillez noter que la gestion des tableaux d'entrées NULL diffère selon la nouvelle méthode: insérer X dans un tableau NULL entraîne null et X

Exemple de code:

    Assert.assertArrayEquals
            (org.Apache.commons.lang3.ArrayUtils.insert
            (4, new int[]{1, 2, 3, 4, 5, 6}, 87), new int[]{1, 2, 3, 4, 87, 5, 6});
1
aristotll

System.arraycopy est plus performant mais difficile à obtenir grâce aux calculs d'index. Mieux vaut vous en tenir à jrad answer ou à ArrayList si vous n'avez pas d'exigences de performance.

public static int[] insert(
    int[] array, int elementToInsert, int index) {
  int[] result = new int[array.length + 1];
  // copies first part of the array from the start up until the index
  System.arraycopy(
      array /* src */,
      0 /* srcPos */,
      result /* dest */,
      0 /* destPos */,
      index /* length */);
  // copies second part from the index up until the end shifting by 1 to the right
  System.arraycopy(
      array /* src */,
      index /* srcPos */,
      result /* dest */,
      index + 1 /* destPos */,
      array.length - index /* length */);
  result[index] = elementToInsert;
  return result;
}

Et JUnit4 test pour vérifier qu'il fonctionne comme prévu.

@Test
public void shouldInsertCorrectly() {
  Assert.assertArrayEquals(
      new int[]{1, 2, 3}, insert(new int[]{1, 3}, 2, 1));
  Assert.assertArrayEquals(
      new int[]{1}, insert(new int[]{}, 1, 0));
  Assert.assertArrayEquals(
      new int[]{1, 2, 3}, insert(new int[]{2, 3}, 1, 0));
  Assert.assertArrayEquals(
      new int[]{1, 2, 3}, insert(new int[]{1, 2}, 3, 2));
}
0
TohaSt
public class HelloWorld{

     public static void main(String[] args){
        int[] LA = {1,2,4,5};
        int k = 2;
        int item = 3;
        int j = LA.length;
        int[] LA_NEW = new int[LA.length+1];


       while(j >k){
            LA_NEW[j] = LA[j-1];
            j = j-1;
        }
        LA_NEW[k] = item;
        for(int i = 0;i<k;i++){
            LA_NEW[i] = LA[i];
        }
        for(int i : LA_NEW){
            System.out.println(i);
        }
     }
}
0
Chiya

Le code suivant insérera l'élément à la position spécifiée et décalera les éléments existants pour passer au nouvel élément.

public class InsertNumInArray {

public static void main(String[] args) {
    int[] inputArray = new int[] { 10, 20, 30, 40 };
    int inputArraylength = inputArray.length;
    int tempArrayLength = inputArraylength + 1;
    int num = 50, position = 2;
    int[] tempArray = new int[tempArrayLength];

    for (int i = 0; i < tempArrayLength; i++) {
        if (i != position && i < position)
            tempArray[i] = inputArray[i];
        else if (i == position)
            tempArray[i] = num;
        else
            tempArray[i] = inputArray[i-1];
    }

      inputArray = tempArray;

    for (int number : inputArray) {
        System.out.println("Number is: " + number);
    }
}
}
0
PAQuality101

Essaye ça 

public static int [] insertArry (int inputArray[], int index, int value){
    for(int i=0; i< inputArray.length-1; i++) {

        if (i == index){

            for (int j = inputArray.length-1; j >= index; j-- ){
                inputArray[j]= inputArray[j-1];
            }

            inputArray[index]=value;
        }

    }
    return inputArray;
}
0
Akash 
int[] b = new int[a.length +1];
System.arraycopy(a,0,b,0,4); 
//System.arraycopy(srcArray, srcPosition, destnArray, destnPosition, length)
b[4]=87;
System.arraycopy(a,4,b,5,2);

le tableau b serait créé sous la forme {1, 2, 3, 4, 87, 5,6};

0
Praveen