So kannst du in drei Schritten Java Arrays dynamisch vergrößern, erweitern
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.
Inhalt
- 1 Schritt 1: Lege ein Java Array zum Vergrößern an.
- 2 Schritt 2: Lege ein temporäres Array innerhalb der Schleife an.
- 3 Schritt 3: Kopiere die Daten vom Hilfsarray ins richtige Array zurück.
- 4 Falls du ständig Java Arrays vergrößern oder erweitern musst, solltest du diese Logik in einer separaten Methode anbieten.
- 4.1 Zuerst legst du eine Methode an, welche die Vornamen speichern soll.
- 4.2 Da du die Vornamen zur Laufzeit eingeben willst, brauchst du eine Konsoleneingabe.
- 4.3 Durch eine weitere Konsoleneingabe kannst du selbst bestimmen, wann das Programm abrechen soll.
- 4.4 Um jetzt weitere Vornamen speichern zu können, musst du die Schleifenbedingung ändern.
- 4.5 Jetzt lass uns die Methode schreiben, welche das Java Array vergrößern soll.
- 4.6 Jetzt musst du die Vergrößern-Methode noch in die Programmlogik der „vorNamen-Methode“ einbinden.
- 5 Zusammenfassung:
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.
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:
- Immer ein Fach größer als das Ursprungsarray sein.
- Deine bisherigen Daten zwischenspeichern.
- Die Daten dann wieder ins alte Array zurück kopieren.
- 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.
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.
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.
Über den Autor
