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

Java lernen durch ständiges Testen – Nutze die Testumgebung von Eclipse

Java Programmierung lernen

Probieren geht über studieren Wenn du wirklich Java Programmierung lernen möchtest, dann solltest du Java nicht aus einem Buch lernen. Du solltest auch nicht strikt von dieser oder anderen Webseiten lernen. Etwas wirklich zu lernen, setzt die Bereitschaft voraus, etwas zu probieren. Denn nur durch eigenes Probieren gelangst du zum Wesentlichen. Durch Probieren wirst du […]

Java Übung: Alles beginnt mit Hello World

Java Übung Hello World

Alles beginnt mit „Hello World“. Sämtliche Java Bücher beginnen mit diesem ersten Beispiel. Auch die Java Übungen sollen mit diesem ersten Programm starten. Definiere eine Klasse „Hello World“. Implementiere die Main Methode. Die Main Methode soll bei Programmaufruf die Bildschirmanzeige „Hallo Welt“ zurückgeben. Die Lösung zur Java Übung „Hallo Welt“ public class HelloWorld{ public static […]

Nutze die Fernbedienung für deine Java Objekte

Auf Java Objekte greifst du mit einer Art Fernsteuerung zu. Diese bezeichnet man als Referenz oder als Verweis. Und diese Referenzvariablen möchte ich dir jetzt einmal vorstellen. Doch bevor wir loslegen, lass mich noch ein paar Dinge loswerden. 🙂 Ich habe es ja schon einmal in einem früheren Beitrag erwähnt. Java unterscheidet zwischen primitiven und […]

Java Übung 11 – Java Objekte in Java Methoden übergeben

Java Übung Java Methoden Objekte

In dieser Java Übung möchte ich dir zeigen, dass du auch in Klassenmethoden auf Objekte und deren Instanzvariablen zugreifen kannst. Schau dir dazu einmal diesen Java Code an. public class Umwandlung { private int x; public int getX() { // getter Methode return x; } public void setX(int x) { // setter Methode this.x = […]

So organisierst und verwaltest du ganz bequem deine Java Projekte

Du kennst das auch. Denn du bist ja fleißig. Und weil du so fleißig bist, hast du mitunter auch mehrere Java Projekte gleichzeitig laufen. Und dann kommt es vor, dass du enorm viele Java Projekte am Laufen hast. Und dein Package-Explorer wird extrem unübersichtlich. In diesem Beitrag möchte ich dir zwei Varianten vorstellen, wie du […]

So legst du Utility Klassen in Java an

Java Utility Klassen

Utility Java Klassen – was ist das? Man nennt diese auch Hilfsklassen von Java. Diese Utility Klassen sind Java Klassen, welche lediglich Methoden und Konstanten anbieten. Am Beispiel: Die Klasse Math ist so eine klassische Utility Klasse. Wozu braucht man solche Klassen? Diese Klassen sind so etwas wie ein Werkzeugkoffer für jedes Java Programm. Hier […]

So kannst du dein Java Programm mit der main Methode ausführen

Auf zum ersten Java Programm. Vielleicht fragst du dich jetzt gerade: Na, was haben wir denn bisher gemacht? War das etwa kein Java Programm? Wir haben bisher nur eine Klasse „Human“ für ein zuküntfiges Mensch-Objekt erstellt. Diesem Objekt haben wir eine Instanzvariable, namens size (Größe) zugeordnet. Und wir haben eine Instanzmethode, namens grow (wachsen) geschrieben. […]

Die drei Bestandteile aller Java Klassen

Java Klassen Bestandteile

Java ist eine objektorientierte Programmiersprache. Was heißt das? Ja… Anscheinend hat es etwas mit Objekten zu tun. Also was ist ein Objekt? Ein Objekt ist ein bestimmtes Konstrukt im Programm. Bauen wir ein Spiel. Ein Grafik-Adventure. Du kennst das. Ein Held wird in eine bestimmte Spielwelt hinein gesteckt. Der Held muss mit bestimmten Personen sprechen. […]