Comment puis-je ajouter dynamiquement des éléments à un tableau Java?
En PHP, vous pouvez ajouter dynamiquement des éléments à des tableaux en procédant comme suit:
$x = new Array();
$x[] = 1;
$x[] = 2;
Après cela, $x serait 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.
Voici un peu le comportement de PHP:
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 terriblement inefficace pour les grands tableaux, car il copie à chaque fois le tableau entier. (Et ce n’est en fait pas tout à fait équivalent à PHP, puisque vos anciens tableaux restent les mêmes).
Les tableaux PHP sont en fait assez similaires à un tableau de hachage Java avec une "clé max" ajoutée, ainsi, il saura quelle clé utiliser, et un ordre d'itération étrange (et une relation d'équivalence étrange entre les clés Integer et quelques cordes). Mais pour les collections indexées simples, utilisez mieux une liste en Java, comme les autres répondeurs proposés.
Si vous voulez éviter d'utiliser List en raison de la surcharge d'encapsuler chaque entier dans un entier, envisagez d'utiliser des réimplémentations de collections pour les types primitifs, qui utilisent des tableaux en interne, mais ne font pas de copie à chaque changement, uniquement lorsque le tableau interne est plein. (tout comme ArrayList). (Un exemple rapidement googlé est cette classe IntList .)
Guava contient des méthodes créant de tels wrappers in Ints.asList, Longs.asList, etc.
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 souvent vu cette question sur le Web et, à mon avis, de nombreuses personnes très réputées ne répondaient pas correctement à ces questions. Je voudrais donc exprimer ma propre réponse ici.
Nous devrions d’abord considérer qu’il existe une différence entre array et arraylist.
La question demande d'ajouter un élément à un tableau et not ArrayList
La réponse est assez simple. Cela peut être fait en 3 étapes.
- Convertir un tableau en un artiste
- Ajouter un élément à la liste de tableaux
- Convertir la nouvelle liste de tableaux en tableau
En voici une image simple 
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 une ArrayList, puis utiliser la méthode toArray(). Mais selon ce que vous faites, vous n’avez peut-être même pas besoin d’un tableau. Cherchez à savoir si Lists est plus ce que vous voulez.
Voir: Tutoriel Java List
Vous voudrez probablement utiliser une liste de tableaux pour cela - pour un tableau de taille dynamique comme une structure.
Vous pouvez ajouter dynamiquement des éléments à un tableau à l'aide de Collection Frameworks in Java. collection Framework ne fonctionne pas sur les types de données primitifs.
Cette structure de collection sera disponible dans le package "Java.util. *"
Par exemple, si vous utilisez ArrayList,
Créez-lui un objet puis ajoutez un nombre d'éléments (n'importe quel type comme String, Integer ... etc)
ArrayList a = new ArrayList();
a.add("suman");
a.add(new Integer(3));
a.add("gurram");
Maintenant, vous avez 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 voulez ajouter un élément
a.add("Gurram");
Donc, la taille du tableau augmente/diminue dynamiquement.
Utilisez une liste de tableaux ou jonglez avec les tableaux pour incrémenter automatiquement la taille du tableau.
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 lui ai ajouté un élément supplémentaire. Après cela, j'ai renvoyé ce tableau à celui d'origine.
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 de manière dynamique à un tableau de taille fixe en utilisant son index et sa boucle. 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()));
}
}
}
comptez 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;
}
}