Skip to main content

So kannst du Java Arrays mit for Schleife füllen und auslesen

Wir haben in einem anderen Beitrag bereits über Java Arrays gesprochen.

So ein Array speichert Zahlen, Texte oder Objekte in eine Art Liste.
Und dann kannst du ganz bequem über den Index das Array füllen und die bereits enthaltenen Werte abrufen.

Ganz bequem?
So, wie ich dich aus dem letzten Beitrag entlassen habe, war das überhaupt nicht bequem. 🙂

Schau dir einfach mal diesen Code dazu an.


public class ArrayForSchleife {
 
public static void main(String[] args) {
int[] arrayEins = new int[8]; // arrayEins mit Länge von 8
arrayEins[0] = 0; // erstes Element i = 0
arrayEins[1] = 21;// zweites Element i = 1
arrayEins[2] = 12;
arrayEins[3] = 83;
arrayEins[4] = 234;
arrayEins[5] = 15;
arrayEins[6] = 62;
arrayEins[7] = 72; //achte Element des Array i = 8
 
System.out.println(arrayEins[0]);
System.out.println(arrayEins[1]);
System.out.println(arrayEins[2]);
System.out.println(arrayEins[3]);
System.out.println(arrayEins[4]);
System.out.println(arrayEins[5]);
System.out.println(arrayEins[6]);
System.out.println(arrayEins[7]);
}
}

Und mit diesem Wissensstand habe ich dich zurückgelassen.
So aufwendig war es ein Array zu füllen und sich die Werte ausgeben zu lassen.

Du siehst das Array hat eine Länge von 8.
Dieses Array kann somit 8 Zahlen vom Datentyp Integer speichern.

Du siehst auch, wie viele Zeilen Code ich benötige, um dieses Array zu füllen.
Und genau die gleiche Anzahl benötige ich um die Zahlen aus dem Array zu lesen.

Das ist sch…. 🙂
Lass uns einen besseren Weg finden.

Du kannst Java Arrays mit einer for Schleife füllen.

Und so geht’s.

Die for Schleife besitzt einen Schleifenkopf.
Und dieser Kopf sieht normalerweise so aus:
for (int i = 0; i < endwert ; i++)

Die Schleife startet bei i=0.
Und wird solange durchlaufen bis i nicht mehr kleiner als ein bestimmter Endwert ist.
Und bei jedem Durchlauf wird dann i um eins erhöht.

Und ein Array?
Ein Java Array hat ebenfalls einen Index i.
Dieser gibt die Position des Elementes an.

Es liegt nahe, dass sich dies kombinieren lässt.
Und so würde der Code aussehen.


public class ArrayForSchleife {
 
public static void main(String[] args) {
int[] arrayEins = new int[8];
 
for (int i = 0; i < 8 ; i++){
arrayEins[i]=1; // Jedes Element im Java Array bekommt den Wert eins zugewiesen
}
 
System.out.println(arrayEins[0]); //Bildschirmausgaben
System.out.println(arrayEins[1]);
System.out.println(arrayEins[2]);
System.out.println(arrayEins[3]);
System.out.println(arrayEins[4]);
System.out.println(arrayEins[5]);
System.out.println(arrayEins[6]);
System.out.println(arrayEins[7]);
}
}

Die for-Schleife startet bei i=0;
Die Schleife wird solange durchlaufen, bis "i" nicht mehr kleiner als 8 ist.

Wieso acht?
Acht ist die Länge des Arrays.

Und bei jedem Durchlauf wird i um eins erhöht.

Im Schleifenrumpf wird dann das Array gefüllt.
Und zwar wird es an der Stelle i gefüllt.

Am besten ist……
Wir spielen die for Schleife einmal gedanklich für die ersten drei Elemente durch.

  • Die for Schleife startet bei i =0.
  • Jetzt wird geprüft, ob i kleiner als 8 ist.
    Jawohl ist es.
  • Dann springt das Programm in den Schleifenrumpf.
    Und hier wird für i=0 oder "arrayEins" beim Index Null der Wert 1 gesetzt.
  • Und dann wird i um eins erhöht.

Java Arrays For Schleife 1 Durchlauf

Und weiter geht’s.

  • I hat den Wert 1.
  • Die Schleife prüft: "Ist i kleiner als 8?"
    Jawohl und ab in den Schleifenrumpf.
  • Da i jetzt den Wert eins hat - bekommt jetzt das Element mit Index 1 den Wert von 1 zugewiesen.
  • Wie gehabt wird am Ende der Schleife, i um eins erhöht.

Java Arrays For Schleife 2 Durchlauf

"I" hat jetzt den Wert zwei und das Spiel beginnt von vorn.
Java Arrays For Schleife 3 Durchlauf

Das Ganze läuft solange bis i den Wert 7 hat.
Dann bricht die Schleife ab.
Somit wurden acht Elemente (0 bis 7) in das Array gesteckt.

Und natürlich kannst du mit der for Schleife auch die Werte aus den Arrays lesen.

Im Prinzip ist es die gleiche Struktur.
Es ändert sich nur eine Kleinigkeit im Schleifenrumpf.

Und zwar machst du jetzt keine Zuweisung mehr.
Du lässt dir den Wert über eine System.out.println()-Anweisung ausgeben.

Java Arrays For Schleife Lesen

Und dies wäre der Code dazu.


public class ArrayForSchleife {
 
public static void main(String[] args) {
int[] arrayEins = new int[8];
 
/*
 * For Schleife zum Füllen eines Java Array
 */
for (int i = 0; i < 8; i++) {
arrayEins[i] = 1; // Jedes Element erhält die Zahl eins.
}
 
/*
 * For Schleife zum Lesen eines Java Array
 */
for (int i = 0; i < 8; i++) {
System.out.println(arrayEins[i]); // Rückgabe der Werte
}
}
}

Sieht doch schon viel attraktiver aus, als zum Anfang des Beitrages, oder?

Eins fehlt noch….

Die Länge des Arrays wird zum Problem.

Stell dir vor.
Du möchtest jetzt nicht 8 Werte in das Array stecken, sondern 100.

Was bedeutet das?
Du musst die Deklarierung des Arrays ändern.
int[] arrayEins = new int[100];

Okay, kein Problem.
Aber was heißt das für die Schleifen?

Ich habe im Code einmal die Länge des Arrays geändert.


public class ArrayForSchleife {
 
public static void main(String[] args) {
int[] arrayEins = new int[100]; // Array mit Länge von 100
 
/*
 * For Schleife zum Füllen eines Java Array
 */
for (int i = 0; i < 8; i++) {
arrayEins[i] = 1; // Jedes Element erhält die Zahl eins.
}
 
/*
 * For Schleife zum Lesen eines Java Array
 */
for (int i = 0; i < 8; i++) {
System.out.println(arrayEins[i]); // Rückgabe der Werte
}
}
}

Probiere es jetzt aus.
Ändere, so wie ich, die Länge des Arrays und klicke auf "Run".

Wie viele Werte kommen zurück?
100 oder 8?

8 - Es sollten aber 100 sein.
Du musst also immer auch den Endwert der for-Schleife ändern.
Denn jetzt läuft die for-Schleife immer noch - nur 8-mal.
(int i = 0; i < 8 ; i++)

Also ändere die for-Schleife ebenfalls ab.
(int i = 0; i < 100 ; i++)

Ähhh- ich habe mich falsch ausgedrückt.
Du musst nicht nur die eine for Schleife abändern.
Du musst beide For Schleifen abändern.
Und das wird jetzt zum Problem.

Wieso?
Das hat nichts mit Faulheit zu tun.
Der Code ist einfach fehleranfällig.

Denn jedes Mal, wenn du die Länge des Array änderst - Musst du auch die for-Schleifen ändern, welche das Array lesen oder füllen.
Und somit musst du das jedes Mal bedenken.

Und noch viel schlimmer.
Du musst wissen, welchen Code du ändern musst.

Vielleicht greifen Java Methoden auf das Array zu.
Vielleicht werden Werte aus dem Array in andere Methoden übergeben.

Du siehst, wenn dein Code etwas komplexer ist, dann wird das wirklich zum Problem.

Also was machst du?

Für jedes Array bietet Java eine bestimmte Variable an.

Und diese Variable speichert die Länge des Arrays.

Wie greifst du auf diese Variable zu?
Per Punktnotation - Wie beim Objekt.

  1. Du schreibst den Namen der Referenzvariablen "arrayEins".
  2. Setzt den Punkt.
  3. Und dann die Variable "length".

Und diese Variable gibt dir immer die Länge des entsprechenden Arrays zurück.

Probier diesen Code einmal aus:


public class ArrayForSchleife {
 
public static void main(String[] args) {
int[] arrayEins = new int[100]; //Array mit Länge 100
int[] arrayZwei = new int [8]; // Array mit Länge 8
 
System.out.println(arrayEins.length); //Ausgabe 100
System.out.println(arrayZwei.length); //Ausgabe 8        
}
}

Und zwar erscheint jetzt die Länge 8 und 100.
Genauso, wie lang diese Arrays nun mal sind.

Und was bringt es, wenn Java das weiß?
Du kannst jetzt diese Variable für die Anzahl der Schleifendurchläufe nutzen.
Und dann kannst du die Länge des Arrays ändern und die Schleifendurchläufe ändern sich automatisch mit.

Ist doch eine tolle Sache, oder?
Lass uns das einbauen.


public class ArrayForSchleife {
 
public static void main(String[] args) {
int[] arrayEins = new int[100]; //Array mit Länge 100
 
for (int i = 0; i< arrayEins.length; i++){
arrayEins[i]=1;
} 
 
for (int i = 0; i<arrayEins.length;i++){
System.out.println(arrayEins[i]);
} 
}
}

Klicke auf "RUN" und jetzt sollte 100-mal eine Eins erscheinen.
Jetzt werden genauso viele Schleifendurchläufe produziert, wie das Array Elemente entgegen nehmen kann.

Probiere es aus.
Und ändere die Länge des Array von 100 auf 8 oder auf 6.

Nicht schlecht, oder?

Das Ganze ist noch nicht sehr spektakulär.
Mit einem Array, welches 100-mal eine 1 speichert, hol ich dich wahrscheinlich nicht von den Socken. 🙂

Und deshalb sind hier noch einige Beispiele wie du Java Arrays mit for Schleife nutzen kannst.

Ganz wichtig, ist die Tatsache, dass alle Werte gespeichert werden.
Und jeder Wert im gespeicherten Array kann in Methoden genutzt und abgerufen werden.

Also hier das erste Beispiel:
Die Zahlen 1 bis 100.


public class ArrayForSchleife {
 
public static void main(String[] args) {
int[] arrayEins = new int[101];
 
for (int i = 0; i < arrayEins.length; i++) {
arrayEins[i] = i; // i wird jedes Mal erhöht und gespeichert
}
 
for (int i = 0; i < arrayEins.length; i++) {
System.out.println(arrayEins[i]);
}
}
}

Noch ein Beispiel.
Die Viererreihe soll im Array gespeichert werden.


public class ArrayForSchleife {
 
public static void main(String[] args) {
int[] arrayEins = new int[101];

int viererZahl=0; // lokale Variable soll gespeichert werden
for (int i = 0; i < arrayEins.length; i++, viererZahl=viererZahl+4) {
arrayEins[i] = viererZahl;
}
 
for (int i = 0; i < arrayEins.length; i++) {
System.out.println(arrayEins[i]);
}
}
}

Und das letzte Beispiel.
Ein Java Array, welches Zufallszahlen zwischen 0 und 100 speichert.


public class ArrayForSchleife {
 
public static void main(String[] args) {
int[] arrayEins = new int[101];
 
 
for (int i = 0; i < arrayEins.length; i++) {
arrayEins[i] = (int)(Math.random()*100);
}
 
for (int i = 0; i < arrayEins.length; i++) {
System.out.println(arrayEins[i]);
}
}
}

Zusammenfassung:

  • Mit einer for-Schleife kannst du deine Java Arrays mit Werten füllen.
  • Und du kannst mit einer anderen For-Schleife dir die Werte wieder zurückgeben lassen.
  • Dabei dient der Schleifenzähler i gleichzeitig als Index des Arrays.
  • Um die Länge des Array dynamisch zu halten, nutzt du die Variable length.

Ähnliche Beiträge

Lexikalik, Syntax und Semantik in Programmiersprachen

Programmiersprachen Semantik Programmiersprachen Syntax Programmiersprachen Lexikalik Java

Java ist eine Programmiersprache. Und wie jede andere Programmiersprache ist auch Java, lediglich eine künstliche Sprache.   Normalerweise bieten künstliche Projekte immer jede Menge Spielraum für Eigenkreationen. Bei der Programmierung ist dies nicht ganz so. Denn Programmiersprachen sind auch immer sehr exakt.   Jede Programmiersprache und auch jede gesprochene Sprache folgt immer einer Abstraktionsreihenfolge, welche […]

Java Übung 31: Speichere deine Würfe im Array

Java Übung Array Würfelspiel

In dieser Java Übung soll ein Würfelspiel simuliert werden. Lege eine Klasse namens, Würfelspiel an. Diese Klasse enthält eine statische Methode, namens würfeln(). Diese Methode erwartet einen Parameter vom Datentyp Integer, namens „anzahlWuerfe“. Diese Variable/Parameter repräsentiert die Anzahl der Würfe. Nachdem der Methode die Anzahl der Würfe übergeben wurde, soll die Methode Zufallszahlen zwischen 1 […]

So lassen sich aus Java Klassen Instanzen erstellen

Java Klassen Instanzen erstellen

Lass uns jetzt aus den Java Klassen heraus Objekte anlegen. Im Einführungsbeispiel hast du bereits gelernt, wie du: Instanzvariablen bzw. Attribute anlegst Wie du aus einer normalen Java Klasse eine Programmstart Klasse machst In diesem Artikel erfährst du: Was Objekte bzw. Instanzen sind. Wie sich Objekte zusammensetzen. Wo und wie du Instanzen aus Java Klassen […]

Verwalte deine Java Klassen in packages

java klassen verwalten

Es macht durchaus Sinn deine Java Klassen in verschiedenen Paketen zu organisieren. Wieso? Es sprechen mehrere Gründe dafür: Du kannst doppelte Klassennamen verwenden Du kannst deinen Code oder deine Klassen inhaltlich trennen Du kannst Hierarchien abbilden. Und genau um diese Dinge geht es in diesem Beitrag

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 […]

Das Java Vererbung Konzept in einem Rollenspiel

Java ist eine objektorientierte Programmiersprache. Und das bedeutet nicht nur, dass du Objekte einer Java Klasse erzeugen kannst. Es bedeutet auch, dass Java Klassen von anderen Klassen erben können. Wieso das Ganze? Stell dir einmal ein Rollenspiel vor. Wie würdest du ein Rollenspiel entwerfen? In einem Rollenspiel gibt es magische Gegenstände. Zauberringe, Zauberstäbe, welche bei […]

So kannst du in Java Und Verknüpfung anlegen und auswerten

Java Und

In Java stehen dir eine Menge Operatoren zur Verfügung. Einer dieser Operatoren ist der Und-Operator. Dies ist ein logischer Operator, da dieser sogenannte Wahrheitswerte mit einander verknüpft. Also…. Was erwartet dich in diesem Beitrag? Zuerst möchte ich dir die Aussagenlogik hinter dem Und-Operator zeigen. Also wann sind Aussagen wahr und wann sind diese falsch. Dann […]

So erstellst du deine ersten Java Klassen mit Eclipse

Java Klassen sind Baupläne für Java Objekte. Und da Java eine objektorientierte Programmiersprache ist, sind Java Klassen somit ein elementarer Bestandteil. In diesem Beitrag möchte ich dir zeigen, wie du eine Java Klasse in Eclipse erstellen kannst. Ich möchte dir außerdem zeigen, was physikalisch in deinem Projekt passiert. Ganz zum Schluss zeige ich dir noch, […]

Nutze das Java Switch Case Statement für komplexe Verzweigungen

Java Switch case

Java switch case statement – was ist das? Wozu brauchst du das? Lass mich anders beginnen… 🙂 In einen meiner früheren Beiträge habe ich schon einmal über bedingte Anweisungen oder Zuweisungen geschrieben. Diese if und else Konstrukte funktionieren eigentlich ganz gut. Aber was ist, wenn du mehrere Parameter abfangen möchtest. Okay ein Beispiel…

Der Java Datentyp boolean im Interview

Java boolean

Nein, ich bin nicht verrückt. Aber… Neulich traf ich zufällig den Java Datentyp boolean. 🙂 Er erklärte sich bereit, mir ein Interview zu geben. In diesem Interview geht es um die Werte, welcher dieser Wertetyp annehmen kann. Und in diesem Zusammenhang geht es auch um Logik. Also lassen wir uns doch die Logik vom direkten […]

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 […]