Come posso aggiungere dinamicamente elementi a un array Java?

In PHP, puoi aggiungere dinamicamente elementi agli array nel modo seguente:

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

Dopo questo, $xsarebbe un array come questo: {1,2}.

C'è un modo per fare qualcosa di simile in Java?

Guarda java.util.LinkedList o java.util.ArrayList

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

Gli array in Java hanno una dimensione fissa, quindi non puoi "aggiungere qualcosa alla fine" come potresti fare in PHP.

Un po 'simile al comportamento di PHP è questo:

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

Quindi puoi scrivere:

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

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

Ma questo schema è orribilmente inefficiente per array più grandi , poiché ogni volta esegue una copia dell'intero array. (E in effetti non è completamente equivalente a PHP, poiché i tuoi vecchi array rimangono gli stessi).

Gli array PHP sono infatti più o meno gli stessi di una Java HashMap con una "chiave massima" aggiunta, quindi saprebbe quale chiave usare dopo, e uno strano ordine di iterazione (e una strana relazione di equivalenza tra le chiavi Integer e alcune stringhe). Ma per semplici raccolte indicizzate, è meglio utilizzare un elenco in Java, come gli altri risponditori proposti.

Se si desidera evitare di utilizzare a Listcausa del sovraccarico di avvolgere ogni int in un numero intero, prendere in considerazione l'utilizzo di reimplementazioni di raccolte per i tipi primitivi, che utilizzano gli array internamente, ma non eseguiranno una copia a ogni modifica, solo quando l'array interno è pieno ( proprio come ArrayList). (Un esempio rapidamente cercato su Google è questa classe IntList .)

Guava contiene metodi creando tali involucri in Ints.asList, Longs.asListecc

Apache Commons ha un'implementazione ArrayUtils per aggiungere un elemento alla fine del nuovo array:

/** 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)

Ho visto questa domanda molto spesso nel web e, a mio parere, molte persone con un'alta reputazione non hanno risposto correttamente a queste domande. Quindi vorrei esprimere la mia risposta qui.

Innanzitutto dobbiamo considerare che esiste una differenza tra arraye arraylist.

La domanda chiede di aggiungere un elemento a un array e non ArrayList

La risposta è abbastanza semplice. Può essere fatto in 3 passaggi.

1. Converti array in un elenco di array
2. Aggiungi elemento a arrayList
3. Riconvertire il nuovo arrayList nell'array

Ecco la semplice immagine di esso

E finalmente ecco il codice:

Passo 1:

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

Passo 2:

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

            list.add(element);
            return list;
    }

Passaggio 3:

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

Passaggio 4

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

È possibile utilizzare un ArrayListe quindi utilizzare il toArray()metodo. Ma a seconda di cosa stai facendo, potresti non aver nemmeno bisogno di un array. Cerca di vedere se Listssei più quello che vuoi.

Vedere: Tutorial sull'elenco Java

Probabilmente vorrai usare un ArrayList per questo - per una struttura simile a un array di dimensioni dinamiche.

È possibile aggiungere dinamicamente elementi a un array utilizzando Collection Frameworks in JAVA. collection Framework non funziona sui tipi di dati primitivi.

Questo framework Collection sarà disponibile nel pacchetto "java.util. *"

Ad esempio, se utilizzi ArrayList,

Crea un oggetto ad esso e poi aggiungi il numero di elementi (qualsiasi tipo come String, Integer ... ecc.)

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

Ora sei stato aggiunto 3 elementi a un array.

se vuoi rimuovere uno qualsiasi degli elementi aggiunti

a.remove("suman");

di nuovo se vuoi aggiungere qualsiasi elemento

a.add("Gurram");

Quindi la dimensione dell'array aumenta / diminuisce dinamicamente.

Utilizzare un ArrayList o destreggiarsi tra gli array per incrementare automaticamente la dimensione dell'array.

tieni un conteggio di dove ti trovi nella matrice primitiva

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

Questo è un modo semplice per aggiungere a un array in java. Ho usato un secondo array per memorizzare il mio array originale, quindi ho aggiunto un altro elemento ad esso. Dopodiché ho passato quell'array a quello originale.

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

In Java la dimensione dell'array è fissa, ma puoi aggiungere elementi dinamicamente a un array di dimensioni fisse usando il suo indice e il ciclo for. Si prega di trovare un esempio di seguito.

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

}