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 kannst du mit dem StringTokenizer Java Strings zerlegen oder splitten

Java StringTokenizer Java Strings teilen zerlegen splitten

Java StringTokenizer – was ist das? Bevor ich diese Frage kläre, schiebe ich eine zweite Frage hinterher. Denn im Wort Tokenizer steckt das Wort Token. Also was ist ein Token? Hier die Definition zum Token: Ein Token ist eine bestimmte Aneinanderreihung von Zeichen. Man kann auch sagen, eine lexikalische Einheit. Das kann zum Beispiel eine […]

Overriding und Vererbung – So lassen sich Java Methoden überschreiben

Java Methoden überschreiben

In Deutschland entstehen jeden Tag tolle Geschichten. So wie diese hier…. Die größte Turmuhr der Welt, die Makkah Clock, steht in Saudi – Arabien. Und zwar direkt in Mekka. Hier ein paar Eckdaten zur Uhr: Höhe des Turmes 601 m. Das Ziffernblatt der Turmuhr hat einen Durchmesser von 43 Meter Die Länge des Minutenzeigers beträgt […]

So kannst du ein Java Programm starten und Argumente übergeben

Um ein Java Programm starten zu können, benötigst du immer die main-Methode. Das Programm startet immer genau an dieser Stelle. Alle lokalen Variablen, welche du in der Main Methode anlegst, kannst du dann im Programm nutzen. Auch alle Methoden, welche du innerhalb des Methodenrumpfes der main-Methode aufrust, werden ausgeführt. Was ist aber vor der main-Methode. […]

3 Möglichkeiten um Vererbung von Java Klassen zu verhindern, zu verbieten oder ausschließen

Java Vererbung verhindern

Die ganze Java Vererbung für bestimmte Klassen ausschließen bzw. verhindern oder verbieten. Was soll das? Für bestimmte Java Klassen soll die Vererbung ausgeschlossen werden. Es soll also verhindert werden, dass Elternklassen – Kindklassen bekommen können. Klingt ein bisschen wie Verhütung, oder? Denn wie auch im echten Leben, können Kinder zu kleinen Tyrannen werden. Sie bedienen […]

Java lernen von Kopf bis Fuß

Wenn du Java lernen möchtest, kannst du an meinem kostenlosen Java Kurs teilnehmen. Aber manch Einer hätte gern eine zweite Meinung. Und da bieten sich natürlich Java Bücher an. Eines dieser Java Bücher möchte ich dir jetzt vorstellen. Dieses Buch nennt sich „Java von Kopf bis Fuß“. Was kannst du von diesem Buch erwarten? Also […]

So kannst du Eclipse installieren

Eclipse installieren

Das Schöne an Eclipse ist, es läuft auf sämtlichen Betriebssystemen. Eclipse wird einfach auf der Webseite des Herstellers herunter geladen und kann dann installiert werden. Dabei stehen dir verschiedene Versionen zur Verfügung.

Die vier verschiedenen Zahlensysteme in der Java Programmierung

Java Zahlensysteme

Java Zahlensysteme – Was soll das? In sämtlichen Programmiersprachen werden Zahlen in Variablen abgespeichert. Wenn du dir die einzelnen primitiven Datentypen in Java einmal anschaust – wirst du feststellen – dass die Masse der Datentypen Zahlen annehmen und speichern können. Zahlen und die Mathematik dahinter spielen in der Programmierung eine sehr große Rolle. Ganz am […]

So verwendest du den Java Oder Operator

Java Oder Operator

Kennst du das auch aus deiner Schulzeit? Du schreibst eine Klassenarbeit in irgendeinem Fach. Nehmen wir einfach mal an – Mathe. Jetzt bist gerade fertig mit deiner Arbeit. Und zu Hause wirst du gefragt: „Und wie lief es?“ Du antwortet:“ Ganz gut. Es wird bestimmt eine Eins oder eine Zwei.“ Drei oder vier Tage später […]

Java Polymorphie – besserer Code und mehr Möglichkeiten

Java Polymorphie Vorteile

Polymorphie ist das Herzstück jeder objektorientierten Sprache. Nicht nur in Java – auch in Python, Javascript und in anderen Sprachen. Aber was bedeutet Polymorphie eigentlich? Polymorphie oder auch Polymorphismus genannt, kommt aus dem Griechischen. Es bedeutet Vielgestaltigkeit. Etwas freier übersetzt, kannst du es auch als Facettenreichtum bezeichnen. Im Grunde genommen zielt die ganze Java Vererbung […]

3 Möglichkeiten – Java Strings verketten und zusammenfügen

Java Strings verketten

Kennst du dieses Relikt längst vergangener Tage? Ein Brief. Ja früher einmal war es üblich, Briefe zu schreiben. Lange bevor es Smartphones oder Email gab. Man stelle sich einmal vor…. Die Leute mussten sich hinsetzen mit einem Blatt und einem Stift – und richtig schreiben. Nein nicht tippen – schreiben. 🙂 Grausame Welt, oder? Aber […]