Java dynamische Array-Größen?

Question

Ich habe eine Klasse - XClass, die ich in ein Array von XClasses laden möchte:

XClass myClass[] = new XClass[10];
myclass[0] = new XClass();
myclass[9] = new XClass();

Ich weiß jedoch nicht, ob ich 10, 8 oder 12 Klassen oder irgendeine andere Anzahl benötigen werde.
Ich werde es erst zur Laufzeit wissen.

Kann ich die Anzahl der Elemente in einem Array während der Laufzeit ändern?
Wenn ja, wie?

Answer 1

Java-Array-Größen sind festgelegt, Sie können keine dynamischen Arrays erstellen wie in C++.

Please note that HTML tags do not change in translation.

Answer 2

Ja, wir können es auf diese Weise machen.

import java.util.Scanner;

public class Collection_Basic {

    private static Scanner sc;

    public static void main(String[] args) {

        Object[] obj = new Object[4];
        sc = new Scanner(System.in);

        //Element speichern
        System.out.println("Geben Sie Ihr Element ein");
        for(int i = 0; i < 4; i++){
            obj[i] = sc.nextInt();
        }

        /*
         * Hier erreicht die Größe ihre maximale Kapazität, sodass nicht mehr Elemente gespeichert werden können,
         * 
         * Um mehr Elemente zu speichern, müssen wir ein neues Array-Objekt mit der erforderlichen Größe erstellen
         */

        Object[] tempObj = new Object[10];

        //Altes Array in neues Array kopieren

        int alteArrayGröße = obj.length;
        int i = 0;
        for(; i < alteArrayGröße; i++){

            tempObj[i] = obj[i];
        }

        /*
         * Das neue Element am Ende des neuen Array-Objekts speichern
         */
        tempObj[i] = 90;

        //Neue Array-Objektreferenz dem alten zuweisen

        obj = tempObj;

        for(int j = 0; j < obj.length; j++){
            System.out.println("obj["+j+"] -"+obj[j]);
        }
    }

}

Answer 3

Da ArrayList zu viel Speicher benötigt, wenn ich ein Array von primitiven Typen benötige, ziehe ich es vor, IntStream.builder() für die Erstellung eines int-Arrays zu verwenden (Sie können auch LongStream- und DoubleStream-Builder verwenden).

Beispiel:

Builder builder = IntStream.builder();
int arraySize = new Random().nextInt();
for(int i = 0; i

`

Hinweis: verfügbar seit Java 8.

`

Answer 4

Es ist eine gute Praxis, zuerst die Menge zu erhalten, die Sie speichern müssen, und dann das Array zu initialisieren.

Zum Beispiel würden Sie den Benutzer fragen, wie viele Daten er speichern muss, und sie dann initialisieren, oder die Komponente oder das Argument abfragen, wie viele Sie speichern müssen. Wenn Sie ein dynamisches Array möchten, könnten Sie ArrayList() verwenden und die Funktion al.add(); verwenden, um fortlaufend hinzuzufügen, danach können Sie es in ein festes Array überführen.

// ArrayList initialisieren und String casten, damit ArrayList Strings akzeptiert (oder alles andere)
ArrayList al = new ArrayList(); 
// eine bestimmte Menge an Daten hinzufügen
for(int i=0;i

``

Das ist zwar redundant, aber um Ihnen die Idee zu zeigen, ArrayList kann Objekte speichern im Gegensatz zu anderen primitiven Datentypen und sind sehr einfach zu manipulieren, das Entfernen aus der Mitte ist ebenfalls einfach, vollständig dynamisch. Dasselbe gilt für List und Stack

``

Answer 5

Ich weiß nicht, ob Sie die Größe zur Laufzeit ändern können, aber Sie können die Größe zur Laufzeit zuweisen. Versuchen Sie es mit diesem Code:

class MyClass {
    void myFunction () {
        Scanner s = new Scanner (System.in);
        int myArray [];
        int x;

        System.out.print ("Geben Sie die Größe des Arrays ein: ");
        x = s.nextInt();

        myArray = new int[x];
    }
}

dies weist die Größe Ihres Arrays auf die zur Laufzeit in x eingegebene Größe zu.