Skip to main content

So kannst du in drei einfachen Schritten Java Arrays dynamisch vergrößern

Es ist der 31.März 1727. Es ist ein Montag.
Die Welt nimmt Abschied von einem sehr bedeutenden Weltveränderer.

Seine Sichtweisen beeinflussen, heute noch, die Forschung und Entwicklung im Bereichen der Physik und Chemie.
Ja selbst unser aller Leben – unsere Sicht auf die alltäglichen Dinge – wurden durch seine Denkstöße revolutioniert.

Dieser große Vorreiter starb im Alter von 84 Jahren.
Er hinterließ eine Enkelin, namens Catherine Barton.

Als Catherine das Zimmer ihres verschiedenen Großvaters betrat, fiel ihr Blick auf sein Vermächtnis.
Der Mann, welcher sein ganzes Leben der Weiterentwicklung von Wissenschaft und Weltanschauung widmete, überlies ihr sein ganzes Erbe.

Was für eine Ehre, oder?
Dieser großen Würde folgte eine große Ernüchterung.

Denn das Erbe dieses bedeutenden Menschen war nichts als ein Koffer.
Es war der Koffer von Isaac Newton.

Und in diesem Koffer befanden sich unzählige Notizen und Erkenntnisse – zu Physik, Chemie, Theologie und Alchemie.

Dieser Koffer war genau der Aufhänger zum Buch „Newtons Koffer – Geniale Außenseiter, die die Wissenschaft blamierten – und sie weiterbrachten.“

Aber wieso ein Koffer?
In dem Buch von Frederico Di Trocchio geht es um die großen bedeutenden Wissenschaftler vergangener Tage.
Es geht auch darum, wie bizarr und zum Teil weltfremd diese Leute waren.
Und wie einfach und bescheiden sie lebten.

Mal ehrlich – Ein Koffer für das komplette Lebenswerk?
Ich denke der Koffer des Isaac Newtons hätte gar nicht groß genug sein können.
Schließlich sollte dieser den Platz für sein riesiges Lebenswerk bieten.

Ich denke auch, dass Newton ziemlich oft seinen Koffer neu sortieren musste.
Stets und ständig Altes aussortieren und wegschmeißen – einfach weil der Platz nicht ausreichte.

Wie schön wäre doch ein Koffer, welcher stets nach Bedarf an Stauraum zunimmt.

Wäre doch echt cool, oder?
Du brauchst mehr Platz in deinem Koffer oder deinem Schrank und schwuppsdiwupp ist ein neues Fach oder eine Schublade da.

Nein in diesem Beitrag geht es weder um Koffer noch um Schränke.
Es geht darum Java Arrays vergrößern zu können.
Und zwar dynamisch.

Immer dann, wenn dein Array voll ist – soll sich die Größe des Arrays automatisch um ein Fach erweitern.
Ich habe die ganze Prozedur in drei einfachen Schritten für Dich zusammengefasst.

Außerdem schauen wir uns die praktische Umsetzung einmal genauer an.

Schritt 1: Lege ein Java Array zum Vergrößern an.

Lege irgendein Array an.
In diesem Beispiel habe ich ein Integer Array mit einer Länge von 1 angelegt.

public class JavaArraysVergroessern {
	
	public static void main(String[] args) {
		int [] zahlen = new int [1];//Array mit Länge 1
	}
}

Und jetzt sollen in dieses Array die Zahlen von 0 bis 100 gespeichert werden.
Du solltest deshalb eine Startvariable für das erste Fach anlegen – zahl = 0.

public class JavaArraysVergroessern {
	
	public static void main(String[] args) {
		int [] zahlen = new int [1];//Array mit Länge 1
		int zahl = 0; //Startzahl für erste Fach
	}
}

Gefüllt wird jetzt das Array mit einer while-Schleife.
Da 100 Zahlen in das Array sollen, lautet die Schleifenbedingung: zahl <= 100.

public class JavaArraysVergroessern {
	
	public static void main(String[] args) {
		int [] zahlen = new int [1];//Array mit Länge 1
		int zahl = 0; //Startzahl für erste Fach
		
		//Ins Array sollen die Zahlen 1 bis 100
		while (zahl <= 100){ //Beginn der while-Schleife
		   
		} //Ende while Schleife
	}
}

Im Schleifenrumpf wird die Variable Zahl aufaddiert und die neue Zahl (zahl+1) in das jeweilige Fach gepackt.
Das bedeutet – der Index für das Fach und die Zahl, welche ins Fach kommen sind identisch.

public class JavaArraysVergroessern {
	
	public static void main(String[] args) {
		int [] zahlen = new int [1];//Array mit Länge 1
		int zahl = 0; //Startzahl für erste Fach
		
		//Ins Array sollen die Zahlen 1 bis 100
		while (zahl <= 100){ //Beginn der while-Schleife
		   zahlen[zahl]=zahl;//Belegung des Faches des Arrays - Index=zahl
		   zahl++;//zahl wird um eins erhöht
		} //Ende while Schleife
	}
}

Jetzt noch eine for-Schleife, welche die Zahlen aus dem Array herausliest und dir als Bildschirmausgabe präsentiert.

public class JavaArraysVergroessern {
	
	public static void main(String[] args) {
		int [] zahlen = new int [1];//Array mit Länge 1
		int zahl = 0; //Startzahl für erste Fach
		
		//Ins Array sollen die Zahlen 1 bis 100
		while (zahl <= 100){ //Beginn der while-Schleife
		   zahlen[zahl]=zahl;//Belegung des Faches des Arrays - Index=zahl
		   zahl++;//zahl wird um eins erhöht
		} //Ende while Schleife
		
		
		//Auslesen der Daten im Array
		for (int i = 0; i< zahlen.length; i++){
			System.out.println(zahlen[i]);
		}
	}
}

Klicke auf Run und die Show geht los. 🙂

Java Arrays vergrößern Exception

Miese Show. 🙂
Denn ganz logisch, das Array hat Platz für eine Zahl und nicht für 100 Zahlen.
Du bekommst somit eine „IndexOutOfBoundException“.

Schritt 2: Lege ein temporäres Array innerhalb der Schleife an.

Immer dann, wenn der Wert der Variable Zahl größer als die Fächeranzahl im Array ist – soll sich das Array stets und ständig um ein Fach vergrößern.
Du benötigst also eine zusätzliche if-Verzweigung in der while Schleife.
Dieser Block checkt, ob das Array vergrößert werden soll.

public class JavaArraysVergroessern {
	
	public static void main(String[] args) {
		int [] zahlen = new int [1];//Array mit Länge 1
		int zahl = 0; //Startzahl für erste Fach
		
		//Ins Array sollen die Zahlen 1 bis 100
		while (zahl <= 100){ //Beginn der while-Schleife
                        if (zahl>=zahlen.length){ //Beginn if -Block
			
			} //Ende if Block
			zahlen[zahl]=zahl;
			zahl++;
		} //Ende while Schleife
		
		
		//Auslesen der Daten im Array
		for (int i = 0; i< zahlen.length; i++){
			System.out.println(zahlen[i]);
		}
	}
}

Jetzt kommt’s…..
Da du nicht einfach so Java Arrays vergrößern kannst – benötigst du ein temporäres Hilfs-Array.
Dieses Hilfsarray soll:

  1. Immer ein Fach größer als das Ursprungsarray sein.
  2. Deine bisherigen Daten zwischenspeichern.
  3. Die Daten dann wieder ins alte Array zurück kopieren.
  4. Und zum Schluss zerstört werden.
public class JavaArraysVergroessern {
	
	public static void main(String[] args) {
		int [] zahlen = new int [1];//Array mit Länge 1
		int zahl = 0; //Startzahl für erste Fach
		
		//Ins Array sollen die Zahlen 1 bis 100
		while (zahl <= 100){ 
                        if (zahl>=zahlen.length){
			int [] tmp = new int [zahlen.length+1];//Anlegen des Hilfsarrays 
			zahlen = tmp;//Umswitchen = tmp ist Futter für Grabage Collector
			}
			zahlen[zahl]=zahl;
			zahl++;
		}
		
		
		//Auslesen der Daten im Array
		for (int i = 0; i< zahlen.length; i++){
			System.out.println(zahlen[i]);
		}
	}
}

Schauen wir uns die Anforderungen an das Hilfsarray nochmal an.

Java Arrays Hilfsarray zum Erweitern

Die Punkte 1,3 und 4 sind erledigt.
Das Zwischenspeichern fehlt noch.

Schritt 3: Kopiere die Daten vom Hilfsarray ins richtige Array zurück.

Und zwar machst du dies mit einer vorgefertigten Methode.
Die Kopiermethode für Java Arrays haben wir schon ausführlich behandelt.

Hier ein Bild und Erklärung zur System.arrayCopy-Methode.

Java Arrays kopieren Methode zum Vergrößern

Also dann die Methode rein in den if-Block und das Teil ist fertig.

public class JavaArraysVergroessern {
	
	public static void main(String[] args) {
		int [] zahlen = new int [1];//Array mit Länge 1
		int zahl = 0; //Startzahl für erste Fach
		
		//Ins Array sollen die Zahlen 1 bis 100
		while (zahl <= 100){ 
                        if (zahl>=zahlen.length){
			int [] tmp = new int [zahlen.length+1];//Anlegen des Hilfsarrays 
			System.arraycopy(zahlen, 0, tmp, 0, zahlen.length);//Kopieren der Daten
			zahlen = tmp;//Umswitchen = tmp ist Futter für Grabage Collector
			}
			zahlen[zahl]=zahl;
			zahl++;
		}
		
		
		//Auslesen der Daten im Array
		for (int i = 0; i< zahlen.length; i++){
			System.out.println(zahlen[i]);
		}
	}
}

Klicke auf „RUN“ und jetzt läuft die Show. 🙂
Eigentlich ist das Teil so fertig.

Aber…..

Falls du ständig Java Arrays vergrößern oder erweitern musst, solltest du diese Logik in einer separaten Methode anbieten.

Meine Idee:

  • Eine Methode nimmt Vornamen oder andere Namen entgegen und speichert diese, per Konsoleneingabe, in ein Array.
  • Wenn das Array dann voll ist, ruft diese Methode eine andere Methode auf und lässt sich ein größeres Array geben.
  • Und dann macht die Methode einfach so weiter, wie bisher.

Aufgrund dessen, dass eine separate Methode immer wieder ein größeres Array bereitstellt – kannst du diese „Vergrößern-Methode“ für sämtliche anderen Methoden auch nutzen.

Cool, oder?
Also machen wir das.

Zuerst legst du eine Methode an, welche die Vornamen speichern soll.

Da die Vornamen in ein Array gespeichert werden sollen, muss die Methode ein String-Array erstellen.
Eine Länge von 1 reicht erstmal, denn du willst das Array ja sowieso vergrößern.

public class JavaArraysVergroessern {
	
	static void vorNamenEingeben(){
		String [] vorNamen = new String [1];//Array mit Länge 1
         
	}
	public static void main(String[] args) {
		vorNamenEingeben();//Methodenaufruf
	}
}

Und dieses String Array wird per for-Schleife gefüllt.

public class JavaArraysVergroessern {
	
	static void vorNamenEingeben(){
		String [] vorNamen = new String [1];
                
		for (int i=0; i<vorNamen.length;i++){
                      //For-Schleife speichert Vornamen
		}
	}
	public static void main(String[] args) {
		vorNamenEingeben();//Methodenaufruf
	}
}

Wenn du dann alle deine Vornamen im Array hast, soll eine Ausgabe erfolgen.
Diese Bildschirmausgabe machst du wiederum mit der for-Schleife.

(PS: Die Ausgabe kannst du später ebenfalls in einer separaten Methode anbieten.)
Aber hier erstmal der Code.

public class JavaArraysVergroessern {
	
	static void vorNamenEingeben(){
		String [] vorNamen = new String [1];
                
		for (int i=0; i<vorNamen.length;i++){
                      //For-Schleife speichert Vornamen
		}
                //For-Schleife liest Array und gibt Vornamen zurück
		for (int i=0;i<vorNamen.length;i++){
			System.out.println(vorNamen[i]);
		}
	}
	public static void main(String[] args) {
		vorNamenEingeben();//Methodenaufruf
	}
}

Da du die Vornamen zur Laufzeit eingeben willst, brauchst du eine Konsoleneingabe.

Und so eine Konsoleneingabe machst du über den Scanner.
Also legst du ein Scannerobjekt mit Referenzvariable an.
In meinem Beispiel nenne ich diese: „scanNamen“.

import java.util.Scanner;

public class JavaArraysVergroessern {
	
	static void vorNamenEingeben(){
		String [] vorNamen = new String [1];
		
		Scanner scanNamen = new Scanner(System.in);//Speichern der Namen
                
		for (int i=0; i<vorNamen.length;i++){
                      //For-Schleife speichert Vornamen
		}
                //For-Schleife liest Array und gibt Vornamen zurück
		for (int i=0;i<vorNamen.length;i++){
			System.out.println(vorNamen[i]);
		}
	}
	public static void main(String[] args) {
		vorNamenEingeben();//Methodenaufruf
	}
}

Im Schleifenrumpf erfolgt dann die Zuweisung über die Konsoleneingabe.
Somit wird nach und nach – jedes Fach mit deiner Eingabe gefüllt.

import java.util.Scanner;

public class JavaArraysVergroessern {
	
	static void vorNamenEingeben(){
		String [] vorNamen = new String [1];
		
		Scanner scanNamen = new Scanner(System.in);//Speichern der Namen
                
		for (int i=0; i<vorNamen.length;i++){
                        System.out.println("Gib Vornamen ein!");//Aufforderung zur Texteingabe
                        vorNamen[i]=scanNamen.next();//Hinzufügen der neuen Zeichenkette
		}
                //For-Schleife liest Array und gibt Vornamen zurück
		for (int i=0;i<vorNamen.length;i++){
			System.out.println(vorNamen[i]);
		}
	}
	public static void main(String[] args) {
		vorNamenEingeben();//Methodenaufruf
	}
}

Bis hierhin kannst du das ganze einmal ausprobieren.
Klicke auf „Run“.
Je nach Länge des Arrays kannst du verschiedene Vornamen eingeben.
Aber irgendwann ist Schluss.

In unserem Beispiel – bei einer Länge von 1 – ist nach dem ersten Namen schon Schluss.

Durch eine weitere Konsoleneingabe kannst du selbst bestimmen, wann das Programm abrechen soll.

Deshalb benötigst du ein weiteren Scanner und eine weitere Referenzvariable – z.B. „scanWeiter“.

import java.util.Scanner;

public class JavaArraysVergroessern {
	
	static void vorNamenEingeben(){
		String [] vorNamen = new String [1];
		
		Scanner scanNamen = new Scanner(System.in);//Speichern der Namen
		Scanner scanWeiter = new Scanner(System.in);//Speichern der Abbruchvariablen - Bei 0 ist Abruch
		int abruch =0;//Abruchvariable startet bei Null

                
		for (int i=0; i<vorNamen.length;i++){
                        System.out.println("Gib Vornamen ein!");//Aufforderung zur Texteingabe
                        vorNamen[i]=scanNamen.next();//Hinzufügen der neuen Zeichenkette
		}
                //For-Schleife liest Array und gibt Vornamen zurück
		for (int i=0;i<vorNamen.length;i++){
			System.out.println(vorNamen[i]);
		}
	}
	public static void main(String[] args) {
		vorNamenEingeben();//Methodenaufruf
	}
}

Diese zweite Scanvariable soll eine Abruchbedingung für die for-Schleife speichern.
Und diese Abbruchbedingung könnte eine Zahl sein und diese kannst du in der Variablen, namens „abruch“ speichern.

import java.util.Scanner;

public class JavaArraysVergroessern {
	
	static void vorNamenEingeben(){
		String [] vorNamen = new String [1];
		
		Scanner scanNamen = new Scanner(System.in);//Speichern der Namen
		Scanner scanWeiter = new Scanner(System.in);//Speichern der Abbruchvariablen - Bei 0 ist Abruch
		int abruch =0;//Abruchvariable startet bei Null

                
		for (int i=0; i<vorNamen.length;i++){
			System.out.println("0=Abruch, 1=Weiter");//Abfrage der Abbruchbedingung
			abruch = scanWeiter.nextInt();//Speichern der neuen Abbruchvariablen
                        System.out.println("Gib Vornamen ein!");//Aufforderung zur Texteingabe
                        vorNamen[i]=scanNamen.next();//Hinzufügen der neuen Zeichenkette
		}
                //For-Schleife liest Array und gibt Vornamen zurück
		for (int i=0;i<vorNamen.length;i++){
			System.out.println(vorNamen[i]);
		}
	}
	public static void main(String[] args) {
		vorNamenEingeben();//Methodenaufruf
	}
}
  • Immer wenn du dann die Zahl 0 eingibst, wird das Programm beendet.
  • Und immer dann, wenn die Zahl nicht Null ist – hast du die Möglichkeit einen weiteren Vornamen einzugeben.

Du brauchst also innerhalb der for-Schleife einen if-Block, falls „abruch“ ungleich Null ist.
Also dann. So sieht der Java Code bisher aus:

import java.util.Scanner;

public class JavaArraysVergroessern {
	
	static void vorNamenEingeben(){
		String [] vorNamen = new String [1];
		
		Scanner scanNamen = new Scanner(System.in);//Speichern der Namen
		Scanner scanWeiter = new Scanner(System.in);//Speichern der Abbruchvariablen - Bei 0 ist Abruch
		int abruch =0;//Abruchvariable startet bei Null

                
		for (int i=0; i<vorNamen.length;i++){
			System.out.println("0=Abruch, 1=Weiter");//Abfrage der Abbruchbedingung
			abruch = scanWeiter.nextInt();//Speichern der neuen Abbruchvariablen
			
                        //If Block wird ausgeführt, wenn Eingabe nicht Null ist
			if (abruch!=0) {
				System.out.println("Gib Vornamen ein!");//Aufforderung zur Texteingabe
				vorNamen[i]=scanNamen.next();//Hinzufügen der neuen Zeichenkette
			}
		}
                //For-Schleife liest Array und gibt Vornamen zurück
		for (int i=0;i<vorNamen.length;i++){
			System.out.println(vorNamen[i]);
		}
	}
	public static void main(String[] args) {
		vorNamenEingeben();//Methodenaufruf
	}
}

Probiere auch diesen Code einmal aus und schau was passiert.

Und – was passiert?
Jetzt kannst du zwar selbst bestimmen, ob du weitere Vornamen speichern möchtest.
Allerdings ist auch hier irgendwann Schluss.
Spätestens wenn das Array voll ist, bricht das Programm automatisch ab und gibt dir alle Vornamen zurück.

Um jetzt weitere Vornamen speichern zu können, musst du die Schleifenbedingung ändern.

Und zwar musst du die Anzahl der Schleifendurchläufe für die „Füllschleife“ ändern.
Ich demonstriere das mal und mach mal die Schleifenbedingung fett.

import java.util.Scanner;

public class JavaArraysVergroessern {
	
	static void vorNamenEingeben(){
		String [] vorNamen = new String [1];
		
		Scanner scanNamen = new Scanner(System.in);//Speichern der Namen
		Scanner scanWeiter = new Scanner(System.in);//Speichern der Abbruchvariablen - Bei 0 ist Abruch
		int abruch =0;//Abruchvariable startet bei Null

                //For-Schleife läuft jetzt bis zum letzten Fach + 1
		for (int i=0; i<vorNamen.length+1;i++){
			System.out.println("0=Abruch, 1=Weiter");//Abfrage der Abbruchbedingung
			abruch = scanWeiter.nextInt();//Speichern der neuen Abbruchvariablen
			
			if (abruch!=0) {
				System.out.println("Gib Vornamen ein!");//Aufforderung zur Texteingabe
				vorNamen[i]=scanNamen.next();//Hinzufügen der neuen Zeichenkette
			}
		}
                //For-Schleife liest Array und gibt Vornamen zurück
		for (int i=0;i<vorNamen.length;i++){
			System.out.println(vorNamen[i]);
		}
	}
	public static void main(String[] args) {
		vorNamenEingeben();//Methodenaufruf
	}
}

Jetzt geht die For-Schleife, obwohl das Array bereits voll ist – nochmal in den Schleifenrumpf.
Denn jetzt provoziert die Schleifenbedingung – immer einen Durchlauf mehr, als die Länge des Arrays ist.

Außerdem solltest du die if-Bedingung abändern.

  • Immer dann, wenn die Länge des Arrays kleiner als der aktuelle Schleifendurchlaufindex (i) ist und die Abruchbedingung weiterhin ungleich Null ist, geht es in den if-Block.
  • Und wenn nur die Abruchariable ungleich Null ist, geht es in den if-else-Block.
  • Wenn Abruch = 0 wird die Schleife beendet.
import java.util.Scanner;

public class JavaArraysVergroessern {
	
	static void vorNamenEingeben(){
		String [] vorNamen = new String [1];
		
		Scanner scanNamen = new Scanner(System.in);//Speichern der Namen
		Scanner scanWeiter = new Scanner(System.in);//Speichern der Abbruchvariablen - Bei 0 ist Abruch
		int abruch =0;//Abruchvariable startet bei Null


		for (int i=0; i<vorNamen.length+1;i++){
			System.out.println("0=Abruch, 1=Weiter");//Abfrage der Abbruchbedingung
			abruch = scanWeiter.nextInt();//Speichern der neuen Abbruchvariablen
			
                        //Falls Abruchvariable=0 und letztes Fach erreicht
			if (vorNamen.length<=i && abruch!=0) {
				System.out.println("Gib Vornamen ein!");//Aufforderung zur Texteingabe
				vorNamen[i]=scanNamen.next();//Hinzufügen der neuen Zeichenkette
			}
			else if (abruch!=0){
				System.out.println("Gib Vornamen ein!");//Aufforderung zur Texteingabe
				vorNamen[i]=scanNamen.next();//Hinzufügen der neuen Zeichenkette
			}
		}
                //For-Schleife liest Array und gibt Vornamen zurück
		for (int i=0;i<vorNamen.length;i++){
			System.out.println(vorNamen[i]);
		}
	}
	public static void main(String[] args) {
		vorNamenEingeben();//Methodenaufruf
	}
}

Wenn du dieses Programm – bis hierher – ausprobierst, bekommst du wiedermal eine Exception.
Na klar das Array muss noch vergrößert werden.

Jetzt lass uns die Methode schreiben, welche das Java Array vergrößern soll.

BÄÄM.
Hier ist der komplette Code:

static String[] vergrStringArray(String[] strArray) {
			String[] tmp = new String[strArray.length + 1];
			System.arraycopy(strArray, 0, tmp, 0, strArray.length);
			strArray = tmp;
		return strArray;
	}
  • Die Methode vergrStringArray()- nimmt ein String-Array entgegen und vergrößert dieses.
    Deshalb muss diese Methode einen StringArray-Parameter erwarten.
  • Außerdem vergrößert die Methode ein Array und gibt dann ein String-Array zurück.
    Diesen Rückgabewert musst du ebenfalls in der Signatur vereinbaren.
  • Na klar sollte die Methode auch statisch sein und ohne ein Objekt funktionieren.

Den Methodenrumpf haben wir oben im Beitrag schon komplett erarbeitet.

  • Zuerst wird ein Hilfsarray angelegt.
    Die Länge des Hilfsarrays ist ein Fach größer als das Array aus der Parameterliste.
  • Dann werden die Daten aus dem Parameterlisten-Array ins Hilfsarray kopiert.
  • Und zum Schluss wird die Referenz umgeswicht und das Hilfsarray wird zerstört.
  • Da die Methode ein Array zurückgibt, muss die letzte Anweisung die return-Anweisung sein.

Jetzt musst du die Vergrößern-Methode noch in die Programmlogik der „vorNamen-Methode“ einbinden.

Und zwar in den if-Block.
Denn erinnere Dich:
Wir brauchen natürlich nur ein größeres Array, wenn das aktuelle voll ist.
Die Bedingung dafür, steht im if-Block.
Den Rückgabewert bzw. die Arrayrückgabe der „vergrStringArray()-Methode“ speicherst du in der Variablen des Ursprungsarray.

import java.util.Scanner;

public class JavaArraysVergroessern {
	
	static String[] vergrStringArray(String[] strArray) {
			String[] tmp = new String[strArray.length + 1];
			System.arraycopy(strArray, 0, tmp, 0, strArray.length);
			strArray = tmp;
		return strArray;
	}
	
	static void vorNamenEingeben(){
		String [] vorNamen = new String [1];
		
		Scanner scanNamen = new Scanner(System.in);//Speichern der Namen
		Scanner scanWeiter = new Scanner(System.in);//Speichern der Abbruchvariablen - Bei 0 ist Abruch
		int abruch =0;//Abruchvariable startet bei Null


		for (int i=0; i<vorNamen.length+1;i++){
			System.out.println("0=Abruch, 1=Weiter");//Abfrage der Abbruchbedingung
			abruch = scanWeiter.nextInt();//Speichern der neuen Abbruchvariablen
			
			if (vorNamen.length<=i && abruch!=0) {
				vorNamen=vergrStringArray(vorNamen);//Aufruf der Methode und speichern des Rückgabewertes
				System.out.println("Gib Vornamen ein!");//Aufforderung zur Texteingabe
				vorNamen[i]=scanNamen.next();//Hinzufügen der neuen Zeichenkette
			}
			else if (abruch!=0){
				System.out.println("Gib Vornamen ein!");//Aufforderung zur Texteingabe
				vorNamen[i]=scanNamen.next();//Hinzufügen der neuen Zeichenkette
			}
		}
                //For-Schleife liest Array und gibt Vornamen zurück
		for (int i=0;i<vorNamen.length;i++){
			System.out.println(vorNamen[i]);
		}
	}
	public static void main(String[] args) {
		vorNamenEingeben();//Methodenaufruf
	}
}

Und fertig.
Klicke auf „Run“ und das Teil sollte laufen. 🙂

Zusammenfassung:

  • Wenn du Java Arrays vergrößern oder erweitern willst, ist dies zur Laufzeit etwas schwierig.
  • Stattdessen musst du die Daten vom Ursprungsarray in eine neues Hilfsarray kopieren.
  • Dabei musst du darauf achten, dass dieses neue Hilfsarray immer mindestens ein Fach mehr hat, als das Ursprungsarray.
  • Zum Schluss zerstörst du das Hilfsarray wieder, indem du die Referenz umswitcht.

Ähnliche Beiträge

So unterstützen dich Java Vererbungstabellen beim Entwurf

Java Vererbungstabellen

Bei der Java Vererbung gibt es zwei Klassenarten bzw. -stufen. Die Superklassen, welche einen allgemeinen Typen darstellen Und die spezielleren Unterklassen, welche die Superklasse um bestimmte Funktionen erweitern. Jetzt ist dieses ganze „Der-erbt-von-dem-Konzept“ mitunter sehr schwierig darzustellen. Zum Beispiel in einem Werkzeugkoffer. In einem Werkzeugkoffer befinden sich sämtliche Werkzeuge, von Säge bis Bohrmaschine. Wie machst […]

So lassen sich Java Strings in char zerlegen

Java Strings zerlegen char

Java Strings sind Zeichenketten. Und diese Zeichenketten lassen sich aufsplitten und in ihre Einzelteile zerlegen. Ich möchte dir in diesem Beitrag Möglichkeiten vorstellen, wie du Strings in Character-Datentypen zerlegen, extrahieren und die Einzelteile in Arrays speichern kannst.

Der Aufbau von Java Klassen

Java Klassen Aufbau

Jedes Java Programm besteht aus Java Klassen. Doch wie sind diese aufgebaut? Wie setzt sich die Struktur zusammen? Wo befinden sich Klassen hierarchisch? Was kommt in die Klassen rein und wie wird es integriert? Das sind die Fragen, welche ich in diesem Artikel beantworten werde. Doch bevor wir bei den Klassen ansetzen, müssen wir eine […]

10 ganz nützlichen Feature der Klasse Java Math

In diesem Beitrag geht es um eine spezielle Java Klasse. Die Klasse nennt sich Java Math. Diese ist in der Standardbibliothek von Java enthalten. Warum solltest du diese Klasse kennen? Die Math Klasse bietet dir einen Menge Methoden an, welche zur Berechnung von mathematischen Gleichungen ganz hilfreich sind. Aber auch für Nichtmathematiker ist etwas dabei. […]

So nutzt du das Java Keyword public

Java Keyword public

Java Programme bestehen aus Java Klassen. Und der Zugriff auf eine Java Klasse sollte nach außen immer gewährleistet sein. Was bedeutet das? Du solltest in jeder Klasse die Möglichkeit haben, ein Objekt einer anderen Klasse anzulegen. Gerade durch diese Möglichkeit macht doch das ganze Klassenkonstrukt erst Sinn.

Zwei smarte Möglichkeiten eine Java Zufallszahl zu erzeugen

Java Zufallszahl

Java Zufallszahl – Wieso? In der Java Programmierung benötigst du immer wieder einmal Zufallszahlen. Du möchtest deine Software mit Daten testen und dir keine Zahlen ausdenken. Du benötigst Stichproben, welche ein reales Verhalten simulieren. Du hast ein Spiel entworfen und die Akteure sollen mit zufälligen aber unterschiedlichen Größen, Rüstungsleveln usw. auftreten. Die Einsatzmöglichkeiten für Zufallszahlen […]

Hier sind ein paar richtig nette Features, die dich beim Java lernen unterstützen

Java lernen Eclipse

Was ist das Wichtigste beim Einstieg in ein neues Wissensgebiet? Nein, kein gutes Sachbuch oder ein besonders guter Lehrer. Es ist Spaß. Beim Java Lernen brauchst du Spaß. Es gibt Lehrer, welche ihren Stoff so vermitteln, dass Lernen Spaß bereitet. Aber die Grundvoraussetzung ist und bleibt der Spaß. Und nichts ist so spaßhemmend wie Langeweile […]

So verwendest du die Java Codeblöcke zur Automatisierung

Java Codeblöcke

In diesem Beitrag geht es um den Einsatz von Java Codeblöcken oder Initialisierungsblöcken. Viele Wege führen nach Rom. Oder Alle Wege führen nach Rom. Heißt es in einem alten Sprichwort. Und so ähnlich ist es bei der Java Programmierung. In diesem Beitrag möchte ich dir einen weiteren Weg vorstellen, wie du Variablen eines Java Objektes […]