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


85

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?


4
Pour toutes les réponses ci-dessous, utilise ArrayList mais OP demande spécifiquement Array. je voudrais aussi savoir.
KJYe.Name 葉家仁

4
la réponse est «non». Vous devez spécifier la taille du tableau (ou remplir tous les éléments) au moment de la déclaration / création en Java. Veuillez consulter java.sun.com/docs/books/jls/second_edition/html/arrays.doc.html
Ritesh

J'ai remarqué que diverses fonctions Java renvoyaient des tableaux, alors j'ai examiné l'implémentation de list (filter) dans File.java. Il utilise une liste en interne, puis la convertit en tableau à la fin. List <String> v = new ArrayList <> (); ... return v.toArray (new String [v.size ()]);
xtempore

Réponses:


112

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

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

21
C'est une réponse parfaite sauf pour une pièce. Normalement, en Java, nous utilisons simplement List au lieu de tableaux primitifs, mais pour les instances où vous avez réellement besoin d'un tableau primitif (comme int[]), utilisez simplement la toArray()méthode sur List. Utilisez le code ci-dessus mais utilisez x.toArray()pour obtenir un tableau primitif.
rharter

1
Dans 99% des cas (plus comme 99,99999% des cas), si vous avez réellement besoin d'un tableau primitif, vous faites quelque chose de mal et cela devrait être géré avec les principes OO. À moins que vous n'interagissiez avec du code natif, ou quelque chose comme des ARRAYobjets Oracle ou une sottise de ce genre, il vaut mieux éviter les tableaux primitifs.
corsiKa

11
oh, tous ces commentaires sur la façon dont vous ne devriez pas utiliser les tableaux primitifs, si seulement c'était aussi simple que cela :(
thecoshman

1
@trusktr C'est une des raisons de le faire. Dans cet exemple, cela ressemble plus à ... l'utilisation d'une Listréférence nous permet de ArrayListpasser au trottoir quand nous le voulons. Si quelqu'un publie une meilleure liste, comme SuperDuperAwesomeList, nous pourrions avoir beaucoup de travail à faire si nous avons fait notre référence un ArrayList. ArrayList a des choses que List n'a pas. Si nous nous appuyons sur ces éléments dans notre code, il devient beaucoup plus difficile d'échanger.
corsiKa

1
@corsiKa, écrivez des algorithmes de compression / codage sans primitives et ces cas sont beaucoup plus courants que 99. (9). Маtrix implique également des primitifs de cri. Sur une note flip si vous interagissez avec le code natif, vous utilisez des DirectBuffers et non des tableaux primitifs. En fin de compte, quelqu'un doit faire du métal, si vous êtes coincé avec les bases de données et la présentation, c'est ok mais la déclaration de 99% est tout simplement stupide.
bestsss

64

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.


c'est beaucoup plus intelligent que la solution acceptée. pas d'objets gaspillés.
brouillard du

2
@Mihail: En fait, je ne recommande normalement pas de faire cela, car pour chaque ajout d'un élément, un nouveau tableau est créé et tout le contenu copié. (Cela dépend de votre cas d'utilisation, cependant - si vous ajoutez / supprimez rarement quoi que ce soit, et que vous itérez / recherchez souvent, cela pourrait être bien.)
Paŭlo Ebermann

ArrayUtils dans les versions plus récentes a une méthode qui fait cela. Je suis assez paresseux pour vérifier l'implémentation, mais je suis presque sûr qu'ils l'ont bien écrite.
brouillard

1
@MihailStoynov En fait, c'est essentiellement ce que ArrayListfait - sauf qu'au lieu de redimensionner à chaque ajout, quand il manque de place, il double de taille pour ne pas avoir à redimensionner aussi souvent.
corsiKa

1
@Mav Non, car orgc'est un plus court que result.
Paŭlo Ebermann

19

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)

2
Dans le nouveau ArrayUtils c'est: ArrayUtils.appendElement (String.class, origArray, "new element")
marmor

12

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 entrez la description de l'image ici

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

1
A voté pour parce que finalement quelqu'un a appelé la différence entre un tableau réel et ArrayList ...
JoeG

Réponse la plus complète et la plus descriptive.
Obaid le

11

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



4

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.


1

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


0

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

Cela n'a vraiment rien à voir avec la question initiale de savoir s'il est possible ou non d'ajouter dynamiquement de nouveaux éléments à un tableau primitif Java.
Joe Day

0

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

0

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

}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.