Java dynamische Array-Größen?

Nein, Sie können nicht ändern die Größe eines Arrays wird einmal erstellt. Man muss entweder reservieren Sie größer, als Sie denken, dass Sie benötigen, oder übernehmen Sie den Aufwand für die Umverteilung, die es braucht, um zu wachsen in der Größe. Wenn es funktioniert musst du reservieren Sie eine neue ein und kopieren die Daten von der alten auf die neue:

int oldItems[] = new int[10];
for (int i=0; i<10; i++) {
  oldItems[i] = i+10;
}
int newItems[] = new int[20];
System.arraycopy(oldItems, 0, newItems, 0, 10);
oldItems = newItems;

Wenn Sie sich in dieser situation würde ich empfehlen, mit der Java-Sammlungen statt. Insbesondere ArrayList im wesentlichen umschließt ein array und kümmert sich um die Logik für den Anbau der array wie gewünscht:

List<xClass> mysclass = new ArrayList<xClass>();
myclass.add(new xClass());
myclass.add(new xClass());

In der Regel eine ArrayList ist eine bessere Lösung, um ein array sowieso aus mehreren Gründen. Für eine Sache, die arrays sind mutable. Wenn Sie eine Klasse, die dies tut:

class Myclass {
  private int items[];

  public int[] getItems() { return items; }
}

hast du ein problem geschaffen, als ein Anrufer können Ihre privaten Daten-Mitglied, das führt zu allen Arten von defensiven kopieren. Vergleichen Sie diese mit der Liste version:

class Myclass {
  private List<Integer> items;

  public List<Integer> getItems() { return Collections.unmodifiableList(items); }
}

InformationsquelleAutor der Antwort cletus

Wie schon andere gesagt haben, Sie können nicht ändern der Größe einer vorhandenen Java-array.

ArrayList ist die nächste, die standard-Java hat sich zu einer dynamischen Größe array. Es gibt jedoch einige Dinge, über ArrayList (eigentlich die List-Schnittstelle), die nicht "array-like". Zum Beispiel:

• Sie nicht verwenden [ ... ] index eine Liste. Verwenden Sie die get(int) und set(int, E) Methoden.
• Eine ArrayList erstellt wird, ist mit null-Elementen. Sie können einfach erstellen Sie eine ArrayList mit 20 Elementen und rufen Sie dann set(15, foo).
• Sie nicht direkt ändern, die Größe einer ArrayList. Sie tun es indirekt über die verschiedenen addinsert und remove Methoden.

Wenn Sie etwas mehr array-like, benötigen Sie für die Gestaltung Ihres eigenen API. (Vielleicht könnte jemand Glockenspiel mit einer vorhandenen Drittanbieter-Bibliothek ... ich konnte nicht finden, dass man mit 2 Minuten "Forschung" mit Hilfe von Google 🙂 )

Wenn Sie nur wirklich brauchen, um ein array, das wächst als Sie initialisierendann ist die Lösung so etwas wie dieses.

ArrayList<T> tmp = new ArrayList<T>();
while (...) {
    tmp.add(new T(...));
}
//This creates a new array and copies the element of 'tmp' to it.
T[] array = tmp.toArray(new T[tmp.size()]);

InformationsquelleAutor der Antwort Stephen C

Können Sie verwenden ArrayList:

import java.util.ArrayList;
import java.util.Iterator;

...

ArrayList<String> arr = new ArrayList<String>();
arr.add("neo");
arr.add("morpheus");
arr.add("trinity");
Iterator<String> foreach = arr.iterator();
while (foreach.hasNext()) System.out.println(foreach.next());

InformationsquelleAutor der Antwort Pascal9x

Als andere user sagen, Sie müssen wahrscheinlich eine Implementierung von java.util.Liste.

Wenn, aus irgendeinem Grund, werden Sie schließlich müssen ein array, können Sie zwei Dinge tun:

• Verwenden Sie eine Liste, und konvertieren Sie Sie dann in ein array mit myList.toArray()

• Verwenden Sie ein array einer bestimmten Größe. Wenn Sie brauchen, mehr oder weniger Größe, können Sie es ändern mit java.util.Arrays Methoden.

Beste Lösung hängt von Ihrem problem 😉

InformationsquelleAutor der Antwort sinuhepop

Arrays.copyOf() Methode hat viele Optionen, um das problem zu beheben Array mit der Länge steigen dynamisch.

Java-API

InformationsquelleAutor der Antwort man.2067067

Es ist eine gute Praxis, erhalten Sie den Betrag, den Sie brauchen, um zu speichern, dann erst das array initialisiert.

würden Sie beispielsweise den Benutzer auffordern, wie viele Daten er speichern müssen und dann initialisieren Sie es, oder Abfrage die Komponente oder das argument, wie viele Sie benötigen, zu speichern.
wenn Sie möchten, dass ein dynamisches array, das Sie verwenden könnte ArrayList() und verwenden al.add(); - Funktion halten Sie das hinzufügen, dann übertragen Sie es auf einen festen array.

//Initialize ArrayList and cast string so ArrayList accepts strings (or anything
ArrayList<string> al = new ArrayList(); 
//add a certain amount of data
for(int i=0;i<x;i++)
{
  al.add("data "+i); 
}

//get size of data inside
int size = al.size(); 
//initialize String array with the size you have
String strArray[] = new String[size]; 
//insert data from ArrayList to String array
for(int i=0;i<size;i++)
{
  strArray[i] = al.get(i);
}

dies ist redundant, aber nur um zu zeigen Sie auf die Idee, ArrayList kann Objekte enthalten im Gegensatz zu anderen primitiven Datentypen und sind sehr leicht zu manipulieren, entfernen Sie etwas aus der Mitte ist einfach wie gut, völlig dynamisch.gleiche mit List und Stack

InformationsquelleAutor der Antwort bakz

Ich weiß nicht, ob Sie können die Größe ändern zur Laufzeit, sondern nehmen Sie die Größe zur Laufzeit. Versuchen Sie es mit diesem code:

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

        System.out.print ("Enter the size of the array: ");
        x = s.nextInt();

        myArray = new int[x];
    }
}

diese weist das array-Größe zu sein, die der angegebenen Laufzeit in x.

InformationsquelleAutor der Antwort Maranatha

In Java-Array-Größen sind immer eine Feste Länge, Aber es ist Weg, in dem Sie Dynamisch erhöhen Sie die Größe des Array zur Laufzeit Selbst

Dies ist die am meisten "genutzt" als auch bevorzugte Art und Weise, es zu tun-

    int temp[]=new int[stck.length+1];
    for(int i=0;i<stck.length;i++)temp[i]=stck[i];
    stck=temp;

Im obigen code sind wir initialisieren einen neuen temp [] - array, mit einer for-Schleife, zum initialisieren der Inhalt des temp mit dem Inhalt der original-array, dh. stck[]. Und dann wieder kopieren es zurück zum original, gibt uns ein neues array der neuen GRÖßE.

Kein Zweifel, es erzeugt eine CPU-Overhead durch das erneute initialisieren ein array mit for-Schleife wiederholt. Aber man kann immer noch verwenden, und implementieren es in Ihrem code.
Für die best-practice-verwenden "Verlinkte Liste" anstelle von Arrays, wenn Sie wollen, dass die Daten gespeichert werden dynamisch im Speicher eine variable Länge.

Hier ist eine Echtzeit-Beispiel auf Basis Dynamischer Stacks zu ERHÖHEN, ARRAY-GRÖßE zur Laufzeit

Datei-name: DStack.java

public class DStack {
private int stck[];
int tos;

void Init_Stck(int size) {
    stck=new int[size];
    tos=-1;
}
int Change_Stck(int size){
    return stck[size];
}

public void push(int item){
    if(tos==stck.length-1){
        int temp[]=new int[stck.length+1];
        for(int i=0;i<stck.length;i++)temp[i]=stck[i];
        stck=temp;
        stck[++tos]=item;
    }
    else
        stck[++tos]=item;
}
public int pop(){
    if(tos<0){
        System.out.println("Stack Underflow");
        return 0;
    }
    else return stck[tos--];
}

public void display(){
    for(int x=0;x<stck.length;x++){
        System.out.print(stck[x]+" ");
    }
    System.out.println();
}

}

Datei-name: Exec.java

(mit der main-Klasse)

import java.util.*;
public class Exec {

private static Scanner in;

public static void main(String[] args) {
    in = new Scanner(System.in);
    int option,item,i=1;
    DStack obj=new DStack();
    obj.Init_Stck(1);
    do{
        System.out.println();
        System.out.println("--MENU--");
        System.out.println("1. Push a Value in The Stack");
        System.out.println("2. Pop a Value from the Stack");
        System.out.println("3. Display Stack");
        System.out.println("4. Exit");
        option=in.nextInt();
        switch(option){
        case 1:
            System.out.println("Enter the Value to be Pushed");
            item=in.nextInt();
            obj.push(item);
            break;
        case 2:
            System.out.println("Popped Item: "+obj.pop());
            obj.Change_Stck(obj.tos);
            break;
        case 3:
            System.out.println("Displaying...");
            obj.display();
            break;
        case 4:
            System.out.println("Exiting...");
            i=0;
            break;
        default:
            System.out.println("Enter a Valid Value");

        }
    }while(i==1);

}

}

Hoffe, das löst deine Anfrage.

InformationsquelleAutor der Antwort Jatin Chauhan

Seit ArrayList nimmt zu viel Speicher, wenn ich Sie brauche array von primitiven Typen, die ich lieber mit IntStream.- generator() für die Erzeugung von int-Arrays (Sie können auch LongStream und DoubleStream Bauherren).

Beispiel:

Builder builder = IntStream.builder();
int arraySize = new Random().nextInt();
for(int i = 0; i<arraySize; i++ ) {
    builder.add(i);
}
int[] array = builder.build().toArray();

Anmerkung: seit Java 8.

InformationsquelleAutor der Antwort Bosko Popovic