Java Array-Länge ändern?

[t2im]

Hi, ich habe eine Frage und zwar wie kann man beim Erzeugen eines Arrays im Konstruktor die Array-Länge ändern? Also nicht array = new Array [3] sondern, dass man die 3 beim Erzeugen des Arrays ändern kann?

LG

 

[CyborgIstDoof]

geht nicht, denn Arrays haben eine feste Länge

 

[JensXF]

Wenn du durch eine Benutzereingabe meinst dann z.B. so

Scanner scanner = new Scanner(System.in);
int eingabe = scanner.nextInt();
int[] array = new int[eingabe];
scanner.close();

 

[M.L.]

Weiterhin unterstützt Java auch "dynamische Arrays" in Form von Vector, ArrayList, LinkedList und CopyOnWriteArrayList.

 

[temi]

int size = 10;
int[] arr = new int[size];

Allgemein kannst du eine Variable für die Erzeugung des Arrays verwenden. Wo der Wert darin herkommt ist egal, das kann eine stinknormale Variable sein, der du einen Wert zuweist oder der Parameter einer Methode oder auch der Rückgabewert einer anderen Methode.

int[] arr = new int[getSize()]; // wir unterstellen mal die Existenz der Methode getSize()...

 

[Kirby.exe]

Naja ist zwar nicht das effizienteste aber du könntest eine Methode erstellen, welche ein neues Array deiner gewollten Größe erstellt und alle Elemente aus dem alten Array in das neue copieren

 

[berndoa]

Hi, ich habe eine Frage und zwar wie kann man beim Erzeugen eines Arrays im Konstruktor die Array-Länge ändern? Also nicht array = new Array [3] sondern, dass man die 3 beim Erzeugen des Arrays ändern kann?

LG

ich hätte gesagt, indem du als attribut in der klasse int[] array; ganz oben stehen hast.
vorausgesetzt deine klasse kriegt ein int n übergeben als parameter bei der objekterzeugung (aka int n ist der parameter vom konstruktor)
dann würde ich in den konstruktor einfahc ne zeile
array=new int[n]; packen.

bewirkt dass wenn du ein objekt der klasse erzeugst, dieses dann ein attribut array hat was ein int array der länge n ist.

Ansonsten eine shcon vorgegebene länge wieder verändern geht nicht.

müsstest du die variable einem neuen, größeren array zuweisen und ggbfls die wette aus dem lten kleinen array da reinkopieren

 

[Neumi5694]

Naja ist zwar nicht das effizienteste aber du könntest eine Methode erstellen, welche ein neues Array deiner gewollten Größe erstellt und alle Elemente aus dem alten Array in das neue copieren

Tatsächlich ist das die einzige Möglichkeit.
Arraylist#add macht das intern auch so ähnlich.
Ist das Array zu kurz, wird ein neues - größeres - erstellt, die alten Werte werden reinkopiert, dann der neue.

@ OP
Falls du wirklich auf Teufel Komm raus mit Arrays arbeiten willst (warum keine Listen, die sind doch so viel angenehmer?), dann schau dir diese Methode an:

System.arraycopy(sourceArray, 0, newBiggerArray, 0, sourceArray.length);

 

[Kirby.exe]

Tatsächlich ist das die einzige Möglichkeit.
Arraylist#add macht das intern auch so ähnlich.

Naja aber die erweitert meist um mehr als nur eine Stelle und diese Operation nicht zu oft durchzuführen, dass sie sehr Laufzeitintensiv ist bei großen ArrayLists

 

[Neumi5694]

Naja aber die erweitert meist um mehr als nur eine Stelle und diese Operation nicht zu oft durchzuführen, dass sie sehr Laufzeitintensiv ist bei großen ArrayLists

Sei dir dessen mal nicht so sicher.

  //Aus ArrayList.java
  private Object[] grow() {
        return grow(size + 1);
    }

Step mal in den dritten Aufruf rein.

    ArrayList<String> s = new ArrayList<>(2);
    s.add("A");
    s.add("B");
    s.add("C");

Am Ende wird elementData eine Größe von 3 haben.
Initialisiert man ArrayList ohne Parameter, hat Elementdata eine Größe von 10 und wird bei Bedarf um 1 erweitert (bei addAll(...) wird natürlich sofort um die notwendige Anzahl erweitert).

Deshalb: ArrayLists nach Möglichkeit immer mit der geschätzten Maximalgröße initialisieren oder per ensureCapacity nachträglich auf die gewünschte Größe setzen.

 

[kneitzel]

Da evtl. noch der Hinweis: Das Verhalten hängt natürlich auch von der Version ab. OpenJDK 11 hat das beschriebene Verhalten:

openjdk-jdk11/src/java.base/share/classes/java/util/ArrayList.java at master · AdoptOpenJDK/openjdk-jdk11

Mirror of the jdk/jdk11 Mercurial forest at OpenJDK - AdoptOpenJDK/openjdk-jdk11

github.com

Aber wenn jemand noch Java 8 / OpenJDK 8 verwendet, dann ist das Verhalten anders (wie man es teilweise in älteren Beiträgen findet):

jdk8/jdk8/jdk: 687fd7c7986d src/share/classes/java/util/ArrayList.java

hg.openjdk.java.net

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

==> Es wird immer mindestens um 50% erweitert ) oldCapacity >> 1 ist oldCapacity / 2

 

[mihe7]

Das ist auch bei AdoptOpenJDK nicht anders.

 

[kneitzel]

Das ist auch bei AdoptOpenJDK nicht anders.

Ja, ich würde da auch kein wirkliches Kosten/Nutzen Verhalten sehen, hier Abweichungen vom OpenJDK einzuführen. Zumal da in den Kommentaren der Klasse ganz deutlich steht:

* Each {@code ArrayList} instance has a capacity. The capacity is
* the size of the array used to store the elements in the list. It is always
* at least as large as the list size. As elements are added to an ArrayList,
* its capacity grows automatically. The details of the growth policy are not
* specified beyond the fact that adding an element has constant amortized
* time cost.

(Das kommt jetzt aus den Sourcen, aber als JavaDoc findet sich das natürlich auch direkt in der Dokumentation der Klasse!)

Man sollte sich also auch nie auf irgend eine spezifische Implementation verlassen.

 

[mrBrown]

Sei dir dessen mal nicht so sicher.

  //Aus ArrayList.java
  private Object[] grow() {
        return grow(size + 1);
    }

Das ist nur der Fall, wenn man add mit Index nutzt und am Ende der Liste hinzufügt.

Ansonsten wird ganz normal die Liste um 50% vergrößert, ist auch in deinem Beispiel mit 3 Elementen der Fall.

 

[kneitzel]

Das ist nur der Fall, wenn man add mit Index nutzt und am Ende der Liste hinzufügt.

Ich glaube, da täuscht Du Dich.

Ich habe @Neumi5694 so verstanden, dass er an den Code über den Debugger gekommen ist, d.h. er hat wirklich seine add Aufrufe verfolgt.

Das habe ich auch einmal nachgespielt (Wer weiss, was ich da sonst an Code finde in irgendwelchen Repositories ) und ich kann das auch bestätigen. Er läuft in das grow() rein was dann eben genau dieses grow(size + 1) aufruft.

Der Code mit den +50% ist auch gar nicht mehr enthalten was ich so gesehen habe.

 

[temi]

Der Wert size + 1 legt ja nur die minCapacity fest, nicht die tatsächliche neue Kapazität.

    private Object[] grow(int minCapacity) {
        return this.elementData = Arrays.copyOf(this.elementData, this.newCapacity(minCapacity));
    }

    private Object[] grow() {
        return this.grow(this.size + 1);
    }

    private int newCapacity(int minCapacity) {
        int oldCapacity = this.elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity <= 0) {
            if (this.elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
                return Math.max(10, minCapacity);
            } else if (minCapacity < 0) {
                throw new OutOfMemoryError();
            } else {
                return minCapacity;
            }
        } else {
            return newCapacity - 2147483639 <= 0 ? newCapacity : hugeCapacity(minCapacity);
        }
    }

 

[mrBrown]

Sorry, hab mich völlig verguckt

Das grow(size + 1) vergrößert das Array auf mindestens size + 1, normalerweise aber um die genannten 50%.

In dem Fall mit drei Elementen ist das eben genau 1, wenn man noch mehr hinzufügen würde, würde man auch größere Vergrößerungen sehen.

jdk/src/java.base/share/classes/java/util/ArrayList.java at dd34a4c28da73c798e021c7473ac57ead56c9903 · openjdk/jdk

JDK main-line development https://openjdk.org/projects/jdk - openjdk/jdk

github.com

 

[kneitzel]

Der Wert size + 1 legt ja nur die minCapacity fest, nicht die tatsächliche neue Kapazität.

Oh, irgendwie hatte ich das komplett übersehen beim überfliegen der Klasse. Meine Aussage:

Der Code mit den +50% ist auch gar nicht mehr enthalten was ich so gesehen habe.

ist damit natürlich kompletter Quatsch. Der Code ist natürlich so enthalten wie Du ihn auch korrekt kopiert hast und ich war schlicht blind. (Will jemand frische Tomaten? Ganz frisch von meinen Augen gepflückt - bezüglich Sprichwort: Tomaten auf den Augen haben )

 

[temi]

Will jemand frische Tomaten?

Da würde ich nicht nein sagen. Ich liebe ein Tomatenbrot mit Zwiebelchen.

 

[Neumi5694]

Sorry, hab mich völlig verguckt

Das grow(size + 1) vergrößert das Array auf mindestens size + 1, normalerweise aber um die genannten 50%.

Ja, das hab ich eben auch übersehen.

 

[berndoa]

Da evtl. noch der Hinweis: Das Verhalten hängt natürlich auch von der Version ab. OpenJDK 11 hat das beschriebene Verhalten:

openjdk-jdk11/src/java.base/share/classes/java/util/ArrayList.java at master · AdoptOpenJDK/openjdk-jdk11

Mirror of the jdk/jdk11 Mercurial forest at OpenJDK - AdoptOpenJDK/openjdk-jdk11

github.com

Aber wenn jemand noch Java 8 / OpenJDK 8 verwendet, dann ist das Verhalten anders (wie man es teilweise in älteren Beiträgen findet):

jdk8/jdk8/jdk: 687fd7c7986d src/share/classes/java/util/ArrayList.java

hg.openjdk.java.net

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

==> Es wird immer mindestens um 50% erweitert ) oldCapacity >> 1 ist oldCapacity / 2

Wann wurde das denn geändert?
Wie war die ganze Zeit felsenfest der Überzeugung, das mit den +50% Kapazität wäre das aktuelle.
und nicht das lächerliche Erweitern um eine(!) Stelle! :O

 

[mrBrown]

Wann wurde das denn geändert?
Wie war die ganze Zeit felsenfest der Überzeugung, das mit den +50% Kapazität wäre das aktuelle.
und nicht das lächerliche Erweitern um eine(!) Stelle! :O

Wie in den nachfolgenden Beiträgen erklärt ist ja auch das erweitern um 50% die aktuelle Implementierung

 

[berndoa]

Wie in den nachfolgenden Beiträgen erklärt ist ja auch das erweitern um 50% die aktuelle Implementierung

Lesen will halt gelernt sein ;-)