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

84

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?

kamikaze_pilot
quelle
4
Für alle folgenden Antworten wird ArrayList verwendet, OP fragt jedoch speziell nach Array. Ich würde es auch gerne wissen.
KJYe.Name 葉家仁
4
Die Antwort lautet "Nein". Sie müssen die Größe des Arrays (oder alle Elemente) zum Zeitpunkt der Deklaration / Erstellung in Java angeben. Bitte sehen Sie java.sun.com/docs/books/jls/second_edition/html/arrays.doc.html
Ritesh
Ich habe festgestellt, dass verschiedene Java-Funktionen Arrays zurückgeben, also habe ich mir die Implementierung von list (filter) in File.java angesehen. Es verwendet eine Liste intern und konvertiert sie am Ende in ein Array. List <String> v = new ArrayList <> (); ... return v.toArray (neuer String [v.size ()]);
xtempore

Antworten:

111

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

List<Integer> x = new ArrayList<Integer>();
x.add(1);
x.add(2);
corsiKa
quelle
21
Dies ist eine perfekte Antwort, bis auf ein Stück. Normalerweise verwenden wir in Java nur Listen anstelle von primitiven Arrays, aber in Fällen, in denen Sie tatsächlich ein primitives Array (wie int[]) benötigen, verwenden Sie einfach die toArray()Methode in List. Verwenden Sie den obigen Code, aber verwenden Sie x.toArray(), um ein primitives Array zu erhalten.
Rharter
1
In 99% der Fälle (eher 99,99999% der Fälle) machen Sie etwas falsch, wenn Sie tatsächlich ein primitives Array benötigen, und es sollte mit OO-Prinzipien behandelt werden. Wenn Sie nicht mit nativem Code oder so etwas wie Oracle- ARRAYObjekten oder so etwas Dummem verbunden sind, ist es viel besser, primitive Arrays zu vermeiden.
CorsiKa
11
Oh, all diese Kommentare darüber, wie man primitive Arrays nicht verwenden sollte, wenn es nur so einfach wäre :(
Thecoshman
1
@trusktr Das ist ein Grund dafür. In diesem Beispiel geht es eher um ... ListWenn wir eine Referenz verwenden, können wir ArrayListjederzeit an den Straßenrand treten . Wenn jemand eine bessere Liste veröffentlicht SuperDuperAwesomeList, haben wir möglicherweise viel zu tun, wenn wir unsere Referenz an ArrayList. ArrayList hat Dinge, die List nicht hat. Wenn wir uns auf diese Dinge in unserem Code verlassen, wird es viel schwieriger, sie auszutauschen.
CorsiKa
1
@corsiKa, schreibe einige Komprimierungs- / Codierungsalgorithmen ohne Grundelemente, und diese Fälle sind weitaus häufiger als 99. (9). Маtrix impliziert auch schreiende Primitive. Wenn Sie mit nativem Code interagieren, verwenden Sie DirectBuffers, keine primitiven Arrays. Am Ende muss jemand das Metall, wenn Sie mit Datenbanken und Präsentation stecken, ist es in Ordnung, aber die Aussage von 99% ist einfach albern.
Bests
64

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.

Paŭlo Ebermann
quelle
Es ist viel schlauer als die akzeptierte Lösung. Keine verschwendeten Gegenstände.
Nebel
2
@Mihail: Eigentlich empfehle ich dies normalerweise nicht, da für jedes Hinzufügen eines Elements ein neues Array erstellt und der gesamte Inhalt kopiert wird. (Es hängt jedoch von Ihrem Anwendungsfall ab - wenn Sie selten etwas hinzufügen / entfernen und häufig iterieren / suchen, ist dies möglicherweise in Ordnung.)
Paŭlo Ebermann
ArrayUtils in den neueren Versionen verfügt über eine Methode, die dies tut. Ich bin ziemlich faul, die Implementierung zu überprüfen, aber ich bin mir ziemlich sicher, dass sie sie gut geschrieben haben.
Nebel
1
@MihailStoynov Eigentlich ist dies im Wesentlichen das, was ArrayListfunktioniert - außer dass sich die Größe nicht bei jedem Hinzufügen ändert, wenn der Platz knapp wird, verdoppelt sich die Größe, sodass die Größe nicht so oft geändert werden muss.
CorsiKa
1
@Mav Nein, da orgist einer kürzer als result.
Paŭlo Ebermann
19

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)
Nebel
quelle
2
In den neueren ArrayUtils ist es: ArrayUtils.appendElement (String.class, origArray, "neues Element")
marmor
12

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 Geben Sie hier die Bildbeschreibung ein

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);
}
Jimmy
quelle
1
Upvoted, weil endlich jemand den Unterschied zwischen einem tatsächlichen Array und ArrayList
herausrief
Vollständigste und aussagekräftigste Antwort.
Obaid
11

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

Ian Dallas
quelle
5

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

Luftkissenfahrzeug voller Aale
quelle
4

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.

SSSM
quelle
1

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

Ibrahim AshShohail
quelle
0

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

quelle
Dies hat eigentlich nichts mit der ursprünglichen Frage zu tun, ob es möglich ist, neue Elemente dynamisch an ein primitives Java-Array anzuhängen.
Joe Day
0

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);
    }
Nenad Bojović
quelle
0

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

}
Sashant Pardeshi
quelle