web-dev-qa-db-fra.com

ajouter un élément au tableau int [] dans java

Voulez-vous ajouter ou ajouter des éléments à un tableau existant

int[] series = {4,2};

maintenant, je veux mettre à jour la série de manière dynamique avec les nouvelles valeurs que j'envoie.

comme si j'envoyais 3 séries de mises à jour en tant que int[] series = {4,2,3};

à nouveau si j'envoie 4 séries de mises à jour en tant que int[] series = {4,2,3,4};

encore une fois si j’envoie 1 série de mises à jour comme int[] series = {4,2,3,4,1}; ainsi de suite

Comment faire????

Je génère un entier toutes les 5 minutes dans une autre fonction et souhaite envoyer pour mettre à jour le tableau int[] series.

javaarrays
45
Kiran

La longueur d'un tableau est immuable en Java. Cela signifie que vous ne pouvez pas changer la taille d'un tableau une fois que vous l'avez créé. Si vous l'avez initialisé avec 2 éléments, sa longueur est de 2. Vous pouvez toutefois utiliser une collection différente.

List<Integer> myList = new ArrayList<Integer>();
myList.add(5);
myList.add(7);

Et avec une méthode d'emballage

public void addMember(Integer x) {
    myList.add(x);
};
72
flavian

essaye ça

public static void main(String[] args) {
    int[] series = {4,2};
    series = addElement(series, 3);
    series = addElement(series, 1);
}

static int[] addElement(int[] a, int e) {
    a  = Arrays.copyOf(a, a.length + 1);
    a[a.length - 1] = e;
    return a;
}
51
Evgeniy Dorofeev

Si vous générez un entier toutes les 5 minutes, utilisez plutôt la collecte. Vous pouvez toujours en obtenir un tableau, si cela est requis dans votre code.

Sinon, définissez un tableau assez grand pour gérer toutes vos valeurs au moment de l'exécution (pas préférable cependant).

12
Sudhanshu Umalkar

Comme d'autres l'ont suggéré, il vaut mieux utiliser la collection. Si pour une raison quelconque vous devez cependant vous en tenir à un tableau, Apache Commons ArrayUtils peut vous aider:

int[] series = {4,2};
series = ArrayUtils.add(series, 3); // series is now {4,2,3}
series = ArrayUtils.add(series, 4); // series is now {4,2,3,4};

Notez que la méthode add crée un nouveau tableau, copie le tableau donné et ajoute le nouvel élément à la fin, ce qui peut avoir une incidence sur les performances.

7
Bunarro

Vous devrez créer un nouveau tableau si vous souhaitez ajouter un index.

Essaye ça:

public static void main(String[] args) {
    int[] series = new int[0];
    int x = 5;


    series = addInt(series, x);

    //print out the array with commas as delimiters
    System.out.print("New series: ");
    for (int i = 0; i < series.length; i++){
        if (i == series.length - 1){
            System.out.println(series[i]);
        }
        else{
            System.out.print(series[i] + ", ");
        }
    }
}

// ici, crée une méthode

public static int[] addInt(int [] series, int newInt){
    //create a new array with extra index
    int[] newSeries = new int[series.length + 1];

    //copy the integers from series to newSeries    
    for (int i = 0; i < series.length; i++){
        newSeries[i] = series[i];
    }
//add the new integer to the last index     
    newSeries[newSeries.length - 1] = newInt;



    return newSeries;

     }
7
Didi Bui

Vous pouvez aussi essayer ceci.

public static int[] addOneIntToArray(int[] initialArray , int newValue) {

    int[] newArray = new int[initialArray.length + 1];
    for (int index = 0; index < initialArray.length; index++) {
        newArray[index] = initialArray[index];
    }

    newArray[newArray.length - 1] = newValue;
    return newArray;
}
5
Jason Ivey

La taille d'un tableau ne peut pas être modifiée. Si vous voulez un plus grand tableau, vous devez créer un nouveau tableau.

Cependant, une meilleure solution consisterait à utiliser une liste (matricielle) pouvant s’épanouir au fur et à mesure de vos besoins. La méthode ArrayList.toArray (T [] a) renvoie un tableau si vous devez utiliser un tableau dans votre application.

4
Erik Pragt

Le ... ne peut être utilisé que dans JDK version 1.5 ou ultérieure. Si vous utilisez JDK 4 ou une version inférieure, utilisez ce code: '

public static int[] addElement(int[] original, int newelement) {
    int[] nEw = new int[original.length + 1];
    System.arraycopy(original, 0, nEw, 0, original.length);
    nEw[original.length] = newelement;
}

sinon (JDK 5 ou supérieur):

public static int[] addElement(int[] original, int... elements) { // This can add multiple elements at once; addElement(int[], int) will still work though.
    int[] nEw = new int[original.length + elements.length];
    System.arraycopy(original, 0, nEw, 0, original.length);
    System.arraycopy(elements, 0, nEw, original.length, elements.length);
    return nEw;
}

Bien sûr, comme beaucoup l'ont mentionné ci-dessus, vous pouvez utiliser un Collection ou un ArrayList, ce qui vous permet d'utiliser la méthode .add().

2
HyperNeutrino
class AddElement {
     public static void main(String s[]) {
        int arr[] ={2,3};
        int add[] = new int[arr.length+1];
        for(int i=0;i<add.length;i++){
        if(i==add.length-1){
            add[i]=4;
        }else{
            add[i]=arr[i];
        }
        System.out.println(add[i]);
        }
    } 
}
2
Ankit Giri
import Java.util.Arrays;

public class NumberArray {     

    public static void main(String []args){
        int[] series = {4,2};
        int[] newSeries = putNumberInSeries(1,series);
        System.out.println(series==newSeries);//return false. you won't get the same int[] object. But functionality achieved.
    }
    private static int[] putNumberInSeries(int i, int[] series) {
        int[] localSeries = Arrays.copyOf(series, series.length+1);
        localSeries[series.length] = i;
        System.out.println(localSeries);
        return localSeries;
    }
}
2
AmitG
public int[] return_Array() {

int[] a =new int[10];   
int b = 25;
for(int i=0; i<10; i++) {               
    a[i] = b * i;
    }
return a;

}
2
Lakshmi Prasanna

Cela fonctionne pour moi:

int[] list = new int[maximum];
for (int i = 0; i < maximum; i++{
    list[i] = put_input_here;
}

De cette façon, c'est simple, mais efficace.

2
Herpy_Derp

similaire à Evgeniy:

int[] series = {4,2};

  add_element(3);
  add_element(4);
  add_element(1);


public void add_element(int element){
  series = Arrays.copyOf(series, series.length +1);
  series[series.length - 1] = element;
}
1
tom

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

    //new value
    int newValue = 10;

    //define the new array
    int[] newArray = new int[oldArray.length + 1];

    //copy values into new array
    for(int i=0;i < oldArray.length;i++)
        newArray[i] = oldArray[i];
    //another solution is to use 
    //System.arraycopy(oldArray, 0, newArray, 0, oldArray.length);

    //add new value to the new array
    newArray[newArray.length-1] = newValue;

    //copy the address to the old reference 
    //the old array values will be deleted by the Garbage Collector
    oldArray = newArray;
0
Chandu D