Come aggiungere un elemento alla matrice e spostare gli indici?

Question

Ho bisogno di aggiungere un elemento alla matrice specificando posizione e valore. Ad esempio, ho Array

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

dopo addPos applicano (int 4, int 87) dovrebbe essere

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

Capisco che qui dovrebbe essere uno spostamento di indici di array, ma non vedi come implementarlo nel codice.

Answer 1

Il modo più semplice per farlo è utilizzare ArrayList<Integer> e utilizzare il metodo 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); 

Answer 2

I odore compiti a casa, quindi probabilmente un ArrayList non sarà consentito

Invece di cercare un modo per "indici di turno", forse solo a costruire un nuovo array (?):

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

Poi

1. copia forma indici matrice un contare da zero fino a inserire positio n
2. ...
3. ...

// edit: valori di copia, naturalmente, non indici

Answer 3

è necessario effettuare un nuovo array, utilizzare System.arraycopy per copiare il prefisso e suffisso, e imposta quello slot sul nuovo valore.

Answer 4

Questo dovrebbe fare il trucco:

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

Dove a è la matrice originale, pos è la posizione di inserimento e num è il numero da inserire.

Answer 5

Ecco un quasi-oneliner che lo fa:

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

Answer 6

Dai un'occhiata alla commons. Usa arrayCopy(), ma ha una sintassi migliore. A chi risponde con il codice elemento per elemento: se questo non è compito a casa, è banale e la risposta interessante è quella che promuove il riutilizzo. A coloro che propongono liste: probabilmente anche i lettori lo sanno e devono essere menzionati i problemi di performance.

Answer 7

Prova questa

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

Answer 8

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

Answer 9

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

b matrice sarebbe creato come {1, 2, 3, 4, 87, 5,6};

Answer 10

System.arraycopy è più performante ma difficile da ottenere a causa dei calcoli degli indici. Meglio attenersi alla risposta jrad o ArrayList se non si dispone di requisiti di prestazione.

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

E JUnit4 test per verificare che funzioni come previsto.

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

Answer 11

La soluzione Jrad è buona ma non mi piace che non usi la copia dell'array. Internamente System.arraycopy() esegue una chiamata nativa in modo da ottenere risultati più rapidi.

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

Answer 12

org.apache.commons.lang3.ArrayUtils#add(T[], int, T) è deprecato in ultimo comuni lang3, è possibile utilizzare org.apache.commons.lang3.ArrayUtils#insert(int, T[], T...) invece.

Deprecato questo metodo è stato sostituito da insert (int, T [], T ...) e può essere rimosso in una versione futura. Si prega di notare la manipolazione di array in input nulli differisce nel nuovo metodo: inserimento X in un nulli risultati array nel nulla non X

codice di esempio:

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