Wie kann ich einem Java-Array dynamisch Elemente hinzufügen?

In PHP können Sie Arrays dynamisch Elemente hinzufügen, indem Sie Folgendes tun:

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

Danach $xwäre ein Array wie folgt : {1,2}.

Gibt es eine Möglichkeit, etwas Ähnliches in Java zu tun?

Schauen Sie sich java.util.LinkedList oder java.util.ArrayList an

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

Arrays in Java haben eine feste Größe, so dass Sie nicht "am Ende etwas hinzufügen" können, wie Sie es in PHP tun könnten.

Ein bisschen ähnlich wie das PHP-Verhalten ist dies:

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

Dann können Sie schreiben:

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

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

Dieses Schema ist jedoch für größere Arrays schrecklich ineffizient , da es jedes Mal eine Kopie des gesamten Arrays erstellt. (Und es ist in der Tat nicht ganz gleichbedeutend mit PHP, da Ihre alten Arrays gleich bleiben).

Die PHP-Arrays sind in der Tat ziemlich identisch mit einer Java-HashMap mit einem hinzugefügten "max-Schlüssel", sodass sie wissen, welcher Schlüssel als nächstes verwendet werden soll, und einer seltsamen Iterationsreihenfolge (und einer seltsamen Äquivalenzbeziehung zwischen Integer-Schlüsseln und einigen Strings). Verwenden Sie für einfache indizierte Sammlungen besser eine Liste in Java, wie die anderen vorgeschlagenen Antwortenden.

Wenn Sie die Verwendung Listaufgrund des Overheads beim Umschließen jedes int in eine Ganzzahl vermeiden möchten, sollten Sie die Neuimplementierung von Sammlungen für primitive Typen in Betracht ziehen, die Arrays intern verwenden, jedoch nicht bei jeder Änderung eine Kopie erstellen, nur wenn das interne Array voll ist ( genau wie ArrayList). (Ein schnell gegoogeltes Beispiel ist diese IntList-Klasse .)

Guava enthält Verfahren die Schaffung einer solchen Umhüllungen in Ints.asList, Longs.asListusw.

Apache Commons verfügt über eine ArrayUtils- Implementierung, mit der am Ende des neuen Arrays ein Element hinzugefügt werden kann :

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

Ich habe diese Frage sehr oft im Internet gesehen und meiner Meinung nach haben viele Menschen mit hohem Ansehen diese Fragen nicht richtig beantwortet. Deshalb möchte ich hier meine eigene Antwort ausdrücken.

Zuerst sollten wir bedenken, dass es einen Unterschied zwischen arrayund gibt arraylist.

In der Frage wird gefragt , ob einem Array ein Element hinzugefügt werden soll und nicht ArrayList

Die Antwort ist ganz einfach. Dies kann in 3 Schritten erfolgen.

1. Konvertieren Sie ein Array in eine Arrayliste
2. Element zur ArrayList hinzufügen
3. Konvertieren Sie die neue ArrayList zurück in das Array

Hier ist das einfache Bild davon

Und zum Schluss hier der Code:

Schritt 1:

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

Schritt 2:

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

            list.add(element);
            return list;
    }

Schritt 3:

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

Schritt 4

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

Sie können eine ArrayListund dann die toArray()Methode verwenden. Aber je nachdem, was Sie tun, benötigen Sie möglicherweise überhaupt kein Array. Prüfen Sie, ob Sie Listsmehr wollen.

Siehe: Java List Tutorial

Sie möchten wahrscheinlich eine ArrayList dafür verwenden - für eine Array-ähnliche Struktur mit dynamischer Größe.

Sie können einem Array mithilfe von Collection Frameworks in JAVA dynamisch Elemente hinzufügen. Das Collection Framework funktioniert nicht mit primitiven Datentypen.

Dieses Collection-Framework wird im Paket "java.util. *" Verfügbar sein

Wenn Sie beispielsweise ArrayList verwenden,

Erstellen Sie ein Objekt und fügen Sie dann eine Anzahl von Elementen hinzu (ein beliebiger Typ wie String, Integer ... usw.)

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

Jetzt wurden einem Array 3 Elemente hinzugefügt.

Wenn Sie hinzugefügte Elemente entfernen möchten

a.remove("suman");

erneut, wenn Sie ein Element hinzufügen möchten

a.add("Gurram");

Die Arraygröße nimmt also dynamisch zu / ab.

Verwenden Sie eine ArrayList oder jonglieren Sie mit Arrays, um die Arraygröße automatisch zu erhöhen.

Zählen Sie, wo Sie sich im primitiven Array befinden

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

Dies ist eine einfache Möglichkeit, einem Array in Java etwas hinzuzufügen. Ich habe ein zweites Array verwendet, um mein ursprüngliches Array zu speichern, und dann ein weiteres Element hinzugefügt. Danach habe ich das Array an das ursprüngliche zurückgegeben.

    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 ist die Größe des Arrays fest, aber Sie können einem Array mit fester Größe mithilfe seines Index und der for-Schleife dynamisch Elemente hinzufügen. Das folgende Beispiel finden Sie unten.

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

}