Erhöhen einer Array-Größe in Java

  1. Erhöhen einer Array-Größe durch Erstellen eines weiteren neuen Arrays in Java
  2. Erhöhen Sie die Array-Größe mit der Methode Arrays.copyOf() in Java
  3. Erhöhen Sie die Array-Größe mit dem Array ArrayList in Java
  4. Array-Größe in Java erhöhen
Erhöhen einer Array-Größe in Java

In diesem Tutorial wird erläutert, wie Sie eine Array-Größe in Java erhöhen. Sie haben auch einige Beispielcodes, die Ihnen helfen, das Thema zu verstehen.

Ein Array in Java ist eine endliche Sammlung von Daten desselben Typs. Arrays haben eine feste Größe und ihre Länge kann nach ihrer Erstellung nicht geändert werden. Dies liegt daran, dass Arrays als zusammenhängende Datenblöcke im Speicher gespeichert werden.

Der Benutzer muss ihre Größe vordefinieren, um sicherzustellen, dass die erforderliche Speichermenge zusammenhängend zur Verfügung steht. In diesem Handbuch kennen Sie die verschiedenen Möglichkeiten, das Problem der festen Länge von Arrays anzugehen.

Sehen wir uns zunächst an, was passiert, wenn wir versuchen, einem Array Elemente ohne zusätzlichen Platz hinzuzufügen. Normalerweise fügen wir einem Array Elemente hinzu, indem wir auf seinen Index zugreifen. Wenn wir versuchen, mit dem nächsten Index ein Element zu einem bereits vollen Array hinzuzufügen, gibt Java eine ArrayIndexOutOfBoundsException zurück.

Der folgende Code ist ein Beispiel für ein solches Szenario.

public class Main
{  
    public static void main(String[] args)
    {
        int[] arr = new int[3];
        arr[0] = 5;
        arr[1] = 10;
        arr[2] = 15;
        arr[3] = 20;//Index 3 is out of bounds
    }
}

Ausgabe:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
    at abc.Demo.main(Demo.java:13)

Versuchen wir nun zu verstehen, wie Sie dieses Problem lösen können.

Erhöhen einer Array-Größe durch Erstellen eines weiteren neuen Arrays in Java

Eine einfache Lösung für die feste Größe des Arrays besteht darin, ein weiteres Array mit einer größeren Größe zu erstellen.

Wir können eine Zählervariable verwenden, um die Anzahl der in das Array eingefügten Elemente zu verfolgen. Immer wenn diese Zahl der Länge des Arrays entspricht (was anzeigt, dass das Array voll ist), können wir ein neues Array erstellen, das eine Größe größer als das ursprüngliche Array ist.

Als nächstes übertragen wir alle Elemente aus dem ursprünglichen Array in das neue Array und haben immer noch einen zusätzlichen Platz für ein neues Element. Wir können diesen Vorgang wiederholen, wenn wir ein neues Element erhalten und nicht genügend Platz dafür haben.

Betrachten Sie den folgenden Code, in dem wir ein Array der Länge 5 erstellen und versuchen, darin 7-Elemente einzufügen. Immer wenn das Array voll wird, vergrößern wir seine Größe mit unserer Methode increaseSize().

public class Main
{
    public static int[] increaseSize(int[] arr)
    {
        int[] newArr = new int[arr.length + 1];//Creating a new array with space for an extra element
        for(int i = 0; i < arr.length; i++)
        {
            newArr[i] = arr[i];//Copying the elements to the new array
        }
        return newArr;
    }
    public static void main(String[] args)
    {
        int[] arr = new int[5];
        int counter = 0;
        for(int i = 0; i <= 6; i++)
        {
            if(counter == arr.length)
            {
                arr = increaseSize(arr);
            }
            arr[i] = i*2;
            counter += 1;
        }
        for(int i=0; i<arr.length; i++)
        {
            System.out.print(arr[i]+" ");
        }
    }
}

Ausgabe:

0 2 4 6 8 10 12

Erhöhen Sie die Array-Größe mit der Methode Arrays.copyOf() in Java

Java hat eine eingebaute Methode copyOf(), die ein neues Array mit einer größeren Größe erstellen und unsere alten Array-Elemente in das neue kopieren kann.

Die Funktion copyOf() gehört zur Klasse Arrays. Die Syntax dieser Methode wird unten gezeigt. Es gibt ein Array der angegebenen Länge zurück, das alle Elemente des ursprünglichen Arrays enthält.

copyOf(originalArray, newLength)

Der folgende Code ähnelt dem oben genannten. Der einzige Unterschied besteht darin, dass wir die Methode copyOf anstelle der Methode increaseSize() verwenden.

import java.util.Arrays;
public class Main
{  
    public static void main(String[] args)
    {    
        int[] arr = new int[5];
        int counter = 0;
        for(int i = 0; i <= 6; i++)
        {
            if(counter == arr.length)
            {
                int[] newArr = Arrays.copyOf(arr, arr.length + 1);
                arr = newArr;
            }
            arr[i] = i*2;
            counter += 1;
        }
        for(int i=0; i<arr.length; i++)
        {
            System.out.print(arr[i]+" ");
        }
    }
}

Ausgabe:

0 2 4 6 8 10 12

Erhöhen Sie die Array-Größe mit dem Array ArrayList in Java

Eine ArrayList ist ein dynamisches Array, das sich im Paket java.util befindet und die Schnittstelle List implementiert. Im Gegensatz zu einem normalen Array hat eine ArrayList eine variable Länge.

Java verarbeitet automatisch die Größe dieses dynamischen Arrays, und wir müssen uns keine Sorgen machen, dass der Speicherplatz im Array knapp wird. Seine Standardgröße beträgt 10 Elemente, aber es wird größer, wenn weitere Elemente hinzugefügt werden.

Die folgende Tabelle unten erklärt einige der wichtigsten Unterschiede zwischen einem Array und einer ArrayList.

Array Anordnungsliste
Arrays können nicht in der Größe geändert werden und haben nach der Erstellung immer eine feste Länge. ArrayList ist ein Array mit variabler Größe, dessen Größe dynamisch erhöht wird, wenn zusätzlicher Platz benötigt wird.
Arrays können sowohl primitive Datentypen als auch Objekte enthalten. ArrayList kann nur Objekte speichern und keine primitiven Datentypen. Primitive Datentypen werden in die entsprechenden Objekte konvertiert, bevor sie der Liste hinzugefügt werden. (int zu Integer, double zu Double)
Die Performance von Arrays ist besser als ArrayList, da die Elemente in konstanter Zeit über Indizes hinzugefügt, entfernt oder abgerufen werden können. ArrayLists sind etwas langsamer als Arrays, da ihre Größe angepasst werden muss, wenn wir zusätzlichen Platz benötigen.
Auf ein Element kann über seinen Index zugegriffen werden. Es gibt dedizierte Methoden wie get(), set() oder add(), um auf Elemente in der ArrayList zuzugreifen und diese zu modifizieren. Wir können Indizes in eckigen Klammern nicht direkt verwenden, um auf Elemente zuzugreifen.

Der folgende Code erklärt, wie man ArrayLists verwendet und grundlegende Operationen wie das Hinzufügen eines Elements, das Ändern eines Elements und das Drucken der Listenwerte durchführt.

import java.util.ArrayList;
public class Main
{  
    public static void main(String[] args)
    {  	//Creating a new ArrayList to hold Integer values
        ArrayList<Integer> arrList = new ArrayList<Integer>();
        //Adding elements 5, 10, 15 and 20 to the ArrayList
        arrList.add(5);
        arrList.add(10);
        arrList.add(15);
        arrList.add(20);
        //Printing the ArrayList
        System.out.println(arrList);
        //Adding an element 7 at index 2. This will shift the rest of the elements one place to the right
        arrList.add(2, 7);
        System.out.println(arrList);
        //Fetching the element at index 3
        System.out.println(arrList.get(3));
        //Changing the element present at index 1 to 17
        arrList.set(1, 17);
        System.out.println(arrList);
    }
}

Ausgabe:

[5, 10, 15, 20]
[5, 10, 7, 15, 20]
15
[5, 17, 7, 15, 20]

Das Szenario, in dem wir versucht haben, 7 Elemente zu einem Array der Länge 5 hinzuzufügen, lässt sich leicht mit ArrayLists lösen. Denken Sie daran, dass wir in ArrayLists keine primitiven Datentypen wie int verwenden können, daher verwenden wir die Wrapper-Klasse Integer.

import java.util.ArrayList;
public class Main
{
  public static void main(String[] args)
  {
      ArrayList<Integer> arrList = new ArrayList<Integer>();
      for(int i = 0; i <= 6; i++)
      {
          arrList.add(i*2);
      }
      for(int i=0; i<arrList.size(); i++)
      {
          System.out.print(arrList.get(i) + " ");
      }  
  }
}

Ausgabe:

0 2 4 6 8 10 12

Array-Größe in Java erhöhen

Ein Array ist eine grundlegende, aber äußerst wichtige und nützliche Datenstruktur. Eine Einschränkung von Arrays besteht darin, dass sie eine feste Größe haben und ihre Größe nicht dynamisch erhöht werden kann.

In diesem Tutorial haben wir gelernt, wie man die Größe eines Arrays erhöht. Wir können ein neues Array mit einer größeren Größe erstellen und den Inhalt des alten Arrays in das neue kopieren. Die beste und einfachste Lösung ist die Verwendung von ArrayLists, da diese ihre Größe dynamisch erhöhen können.

Wir hoffen, dass dieser Leitfaden sehr hilfreich war und Sie etwas Neues in Java gelernt haben.

Verwandter Artikel - Java Variable

  • Unterschied zwischen statischen und finalen Variablen in Java
  • Setzen der JAVA_HOME-Variable in Java
  • Zähler in Java
  • Zugriff auf eine Variable aus einer anderen Klasse in Java
  • Erstellen Sie eine globale Variable in Java
  • Verwandter Artikel - Java Array

  • So konvertieren Sie Byte-Array in Hex-String in Java
  • Wie man zwei Arrays in Java verkettet
  • Entfernen Sie Duplikate aus dem Array in Java
  • Assoziatives Array in Java
  • Vergleichen Arrays in Java
  • Slicen ein Array in Java