Comment puis-je ajouter dynamiquement des éléments à un tableau Java?

En PHP, vous pouvez ajouter dynamiquement des éléments aux tableaux de la manière suivante:

$x = new Array();
$x[] = 1;
$x[] = 2;

Après cela, $xserait un tableau comme celui - ci: {1,2}.

Existe-t-il un moyen de faire quelque chose de similaire en Java?

Regardez java.util.LinkedList ou java.util.ArrayList

List<Integer> x = new ArrayList<Integer>();
x.add(1);
x.add(2);

Les tableaux en Java ont une taille fixe, vous ne pouvez donc pas "ajouter quelque chose à la fin" comme vous pourriez le faire en PHP.

Un peu similaire au comportement PHP est le suivant:

int[] addElement(int[] org, int added) {
    int[] result = Arrays.copyOf(org, org.length +1);
    result[org.length] = added;
    return result;
}

Ensuite, vous pouvez écrire:

x = new int[0];
x = addElement(x, 1);
x = addElement(x, 2);

System.out.println(Arrays.toString(x));

Mais ce schéma est horriblement inefficace pour les plus grands tableaux , car il fait une copie de l'ensemble du tableau à chaque fois. (Et ce n'est en fait pas complètement équivalent à PHP, puisque vos anciens tableaux restent les mêmes).

Les tableaux PHP sont en fait assez identiques à un HashMap Java avec une "clé max" ajoutée, donc il saurait quelle clé utiliser ensuite, et un ordre d'itération étrange (et une étrange relation d'équivalence entre les clés Integer et certaines chaînes). Mais pour les collections indexées simples, mieux vaut utiliser une List en Java, comme les autres répondeurs proposés.

Si vous voulez éviter d'utiliser en Listraison de la surcharge de l'encapsulation de chaque int dans un entier, envisagez d'utiliser des réimplémentations de collections pour les types primitifs, qui utilisent des tableaux en interne, mais ne feront pas de copie à chaque modification, uniquement lorsque le tableau interne est plein ( comme ArrayList). (Un exemple rapidement googlé est cette classe IntList .)

Goyave contient des méthodes créant de tels emballages en Ints.asList, Longs.asListetc.

Apache Commons a une implémentation ArrayUtils pour ajouter un élément à la fin du nouveau tableau:

/** Copies the given array and adds the given element at the end of the new array. */
public static <T> T[] add(T[] array, T element)

J'ai vu cette question très souvent sur le Web et à mon avis, de nombreuses personnes de grande réputation n'ont pas répondu correctement à ces questions. Je voudrais donc exprimer ma propre réponse ici.

Tout d'abord, nous devons considérer qu'il existe une différence entre arrayet arraylist.

La question demande l'ajout d'un élément à un tableau , et non à ArrayList

La réponse est assez simple. Cela peut être fait en 3 étapes.

1. Convertir un tableau en arraylist
2. Ajouter un élément à la arrayList
3. Reconvertissez le nouveau arrayList en tableau

Voici la simple image de celui-ci

Et enfin voici le code:

Étape 1:

public List<String> convertArrayToList(String[] array){
        List<String> stringList = new ArrayList<String>(Arrays.asList(array));
        return stringList;
    }

Étape 2:

public  List<String> addToList(String element,List<String> list){

            list.add(element);
            return list;
    }

Étape 3:

public String[] convertListToArray(List<String> list){
           String[] ins = (String[])list.toArray(new String[list.size()]);
           return ins;
    } 

Étape 4

public String[] addNewItemToArray(String element,String [] array){
        List<String> list = convertArrayToList(array);
        list= addToList(element,list);
        return  convertListToArray(list);
}

Vous pouvez utiliser un ArrayList, puis utiliser la toArray()méthode. Mais selon ce que vous faites, vous n'aurez peut-être même pas besoin d'un tableau du tout. Regardez pour voir siLists vous voulez plus.

Voir: Tutoriel de liste Java

Vous voudrez probablement utiliser une ArrayList pour cela - pour un tableau de taille dynamique comme une structure.

Vous pouvez ajouter dynamiquement des éléments à un tableau en utilisant Collection Frameworks dans JAVA. collection Framework ne fonctionne pas sur les types de données primitifs.

Ce framework Collection sera disponible dans le package "java.util. *"

Par exemple, si vous utilisez ArrayList,

Créez un objet dessus, puis ajoutez un certain nombre d'éléments (tout type comme String, Integer ... etc)

ArrayList a = new ArrayList();
a.add("suman");
a.add(new Integer(3));
a.add("gurram");

Vous avez maintenant ajouté 3 éléments à un tableau.

si vous souhaitez supprimer l'un des éléments ajoutés

a.remove("suman");

encore une fois si vous souhaitez ajouter un élément

a.add("Gurram");

Ainsi, la taille du tableau augmente / diminue dynamiquement.

Utilisez une ArrayList ou jonglez avec les tableaux pour incrémenter automatiquement la taille du tableau.

garder un compte de l'endroit où vous vous trouvez dans le tableau primitif

class recordStuff extends Thread
{
    double[] aListOfDoubles;
    int i = 0;

    void run()
    {
        double newData;
        newData = getNewData(); // gets data from somewhere

        aListofDoubles[i] = newData; // adds it to the primitive array of doubles
        i++ // increments the counter for the next pass

        System.out.println("mode: " + doStuff());
    }

    void doStuff()
    {
        // Calculate the mode of the double[] array

        for (int i = 0; i < aListOfDoubles.length; i++) 
        {
            int count = 0;
            for (int j = 0; j < aListOfDoubles.length; j++)
            {
                if (a[j] == a[i]) count++;
            }
            if (count > maxCount) 
            {
                maxCount = count;
                maxValue = aListOfDoubles[i];
            }
        }
        return maxValue;
    }
}

C'est un moyen simple d'ajouter à un tableau en java. J'ai utilisé un deuxième tableau pour stocker mon tableau d'origine, puis j'y ai ajouté un élément supplémentaire. Après cela, j'ai passé ce tableau à l'original.

    int [] test = {12,22,33};
    int [] test2= new int[test.length+1];
    int m=5;int mz=0;
    for ( int test3: test)        
    {          
    test2[mz]=test3; mz++;        
    } 
    test2[mz++]=m;
    test=test2;

    for ( int test3: test)

    {
      System.out.println(test3);
    }

En Java, la taille du tableau est fixe, mais vous pouvez ajouter des éléments dynamiquement à un tableau de taille fixe en utilisant son index et sa boucle for. Veuillez trouver un exemple ci-dessous.

package simplejava;

import java.util.Arrays;

/**
 *
 * @author sashant
 */
public class SimpleJava {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here

        try{
            String[] transactions;
            transactions = new String[10];

            for(int i = 0; i < transactions.length; i++){
                transactions[i] = "transaction - "+Integer.toString(i);            
            }

            System.out.println(Arrays.toString(transactions));

        }catch(Exception exc){
            System.out.println(exc.getMessage());
            System.out.println(Arrays.toString(exc.getStackTrace()));
        }
    }

}