Skip to main content

So kannst du Werte aus zwei oder mehreren Java Arrays verrechnen.

Wie kann man Werte aus zwei oder mehreren Java Arrays miteinander verrechnen?

Zum Beispiel:

  • Du möchtest alle Werte des ersten Arrays mit allen Werten des zweiten Arrays addieren
  • Oder du möchtest die Summe aus beiden Arrays wissen und erst dann diese miteinander addieren.

Was erwartet dich in diesem Beitrag?

  • Zuerst werde ich dir zeigen, wie du zwei Arrays in der main-Methode anlegst.
  • Dann zeige ich dir, wie du in diesen Arrays Werte speicherst.
  • Und dann implementiere ich eine for-Schleife, welche die Daten aus dem Array liest und diese miteinander addiert.
    Die Summe beider Arrays erscheint dann als Konsolenausgabe.

Also legen wir los. 🙂

Ich habe für diesen Artikel bereits eine Klasse vorbereitet.
In dieser befindet sich, zu diesem Zeitpunkt, lediglich die main-Methode um das Programm auszuführen.


public class ArraysVerrechnen {

	public static void main(String[] args) {
		
	}
}

So erstellst du zwei Java Arrays.

Und zwar befinden sich diese in der main Methode.

Um es übersichtlich zu machen, halte ich die Arrays klein.
Diese sollen lediglich eine Länge von drei haben.


public class ArraysVerrechnen {

	public static void main(String[] args) {
		double[] erstesArray = new double[3];//erstes Array mit Länge 3
		double[] zweitesArray = new double[3];// zweites Array mit Länge drei
	}
}

Arrays legst du nach folgenden Ablauf an:

  • Datentyp: Ich wähle double, um Kommazahlen speichern zu können.
  • Zwei eckige Klammern: Dies ist die Kennzeichnung für ein Array.
  • Der Name der Referenzvariablen: Ich wähle die Namen „erstesArray“ und „zweitesArray“.
  • Dann folgt die Zuweisung.
    Und eine Zuweisung in Java erfolgt immer durch ein Gleichheitszeichen.
  • Dann schreibst du das Keyword new:
    Dies ist die Anweisung, dass ein neues Array angelegt wird.
  • Und dann nochmal den Datentyp: Double für Gleitkommazahlen.
  • In die letzten eckigen Klammern, schreibst du die Länge des Arrays.
    In diesem Beispiel bedeutet das:
    Beide Arrays haben eine Länge von drei.
    Sie sind somit in der Lage drei Double-Werte zu speichern.

Und so füllst du beide Arrays mit Daten.

Um in den Arrays Daten zu speichern, musst du einen Wert in jedes Fach packen.

Und wie?
Die beiden Java Arrays in unserem Beispiel haben jeweils drei Fächer.

Um auf jedes einzelne Fach zuzugreifen schreibst du:

  • Den Namen der Referenzvariablen „erstesArray“ bzw. „zweitesArray“.
  • Setzt dann ein eckiges Klammerpaar.
  • Innerhalb dieser Klammern schreibst du dann den Index für das Fach.
    Bedenke das erste Fach eines jeden Java Arrays hat immer den Index 0.
  • Dann erfolgt das Gleichheitszeichen. Denn Zuweisungen erfolgen in Java immer durch das Gleichheitszeichen.
    Und dann schreibst du den Wert, welcher im Fach gespeichert werden soll.

Und so würde der Code zu beiden Arrays aussehen:


public class ArraysVerrechnen {

	public static void main(String[] args) {
		double[] erstesArray = new double[3];
		double[] zweitesArray = new double[3];	
		
		//Füllen des ersten Arrays
		erstesArray[0]= 2.2;//Fach 1 mit Wert 2,2
		erstesArray[1]= 4.0;//Fach 2 mit Wert 4
		erstesArray[2]= 333;//Fach 3 mit Wert 333
				
		//Füllen des zweiten Arrays
		zweitesArray[0]=7.6; //Fach 1 mit Wert 7,6
		zweitesArray[1]=10; //Fach 2 mit Wert 10
		zweitesArray[2]=14.7; //Fach 3 mit Wert 14,7
	}
}

Du siehst in einem Double-Array kannst du auch ganze Zahlen übergeben.
Die ganzen Zahlen werden implizit gecastet (in Kommazahlen umgewandelt).

Und jetzt lass uns die Daten einmal auslesen.

So lässt du ein Array durchlaufen.

Beide Arrays haben eine Länge von drei.

Mit einer for-Schleife kannst du jetzt das komplette Array einmal durchlaufen.

Was meine ich damit?
Eine Schleife ist immer eine sich wiederholende Anweisung.

Man kann jetzt für diese beiden Arrays diese wiederholende Anweisung ganz formal so ausdrücken:

„Liebes Javaprogramm, durchlaufe bitte beide Arrays und gib mir die Werte, welche in den Fächern stecken zurück.
Beginne bitte beim ersten Fach.
Und mach das Ganze bitte solange, bis du am Ende des Arrays, im letzten Fach, angekommen bist.“

Also wie kannst du nun seine Schleife implementieren?
Lass uns die Java-Bitte einmal in echten Java Code übersetzen.

Eine for-Schleife hat immer einen Schleifenkopf.
Und dieser Schleifenkopf besteht aus 3 Teilen:

  1. Einen Schleifenzähler:

    „Beginne bitte beim ersten Fach“

    Dieser Schleifenzähler beginnt bei einem bestimmten Startwert.
    Da du mit dem ersten Fach des Arrays (erstesArray[0]) beginnen möchtest, vereinbarst du den Startwert 0.
    Du musst diesen Startwert in einer Variablen speichern:
    int i =0;

  2. Eine Schleifenbedingung:

    „Und mach das Ganze bitte solange, bis zum Ende des Arrays“.

    Das bedeutet: Die Schleifenbedingung ist i<3. Solange der Startwert kleiner als die Länge des Arrays (3) ist, wird die Schleife durchlaufen.

  3. Inkrementierung: i++
    Und diese Inkrementierung bedeutet, dass der Startwert (i=0) bei jedem Schleifendurchlauf um eins erhöht wird.

Der Schleifenkopf zum Lesen der Werte aus dem ersten Array würde somit so aussehen:
( int i = 0; i<3; i++ )

So eine Schleife hat aber nicht nur einen Kopf.
Sie hat auch einen Rumpf.

Und im Rumpf werden die wiederholenden Anweisungen platziert.
Hier kannst du dann eine Konsolenausgabe anlegen.
Und diese Konsolenausgabe gibt den Wert der entsprechenden Fächer zurück.

Und so würde der bisherige Java Code aussehen:


public class ArraysVerrechnen {

	public static void main(String[] args) {
		double[] erstesArray = new double[3]; //
		double[] zweitesArray = new double[3];	
		
		//Füllen des ersten Arrays
		erstesArray[0]= 2.2; //Fach 1 mit Wert 2,2
		erstesArray[1]= 4.0; //Fach 2 mit Wert 4
		erstesArray[2]= 333; //Fach 3 mit Wert 333
				
		//Füllen des zweiten Array
		zweitesArray[0]=7.6; //Fach 1 mit Wert 7,6
		zweitesArray[1]=10; //Fach 2 mit Wert 10
		zweitesArray[2]=14.7; //Fach 3 mit Wert 14,7
		
		//Werte aus ersten Array lesen
		for( int i = 0; i<3; i++ ){
			System.out.println(erstesArray[i]);
		}
	}
}

Kopiere doch einmal den Code in deine Eclispe Oberfläche.
Lege aber vorher die Klasse einmal an.
Klicke auf "Run" und schau dir die Bildschirmausgabe an.

Cool, oder? 🙂

Lass uns den Schleifenablauf einmal gedanklich durchspielen.
Der Startwert ist null. (i=0)
Die Schleifenbedingung (i<3) ist wahr. Also ab in den Schleifenrumpf.

Java-Arrays-for-Schleife-Werte

Und im Schleifenrumpf wird die Anweisung ausgeführt.
Im Code siehst du, dass das Fach an der Stelle "i" ausgelesen und der entsprechende Wert zurückgegeben wird.
Und i ist 0.
Also wird der Wert des ersten Faches (erstesArray[0]) zurückgegeben.
Dann wird i um eins erhöht.

So - Der Schleifenzähler i hat jetzt den Wert 1.
Es wird erneut geprüft:
Ist der Schleifenzähler i immer noch kleiner als drei? Jawohl- ab in den Schleifenrumpf.

Java Arrays for Schleife Werte 2 Durchlauf

Und jetzt wird das Fach zwei des Arrays ausgelesen (erstesArray[1]) und auf der Konsole zurückgegeben.
Dann wird i wieder um eins erhöht.

I hat jetzt den Wert 2.
Ist i immer noch kleiner als 3?
Jawohl - Also nochmal in den Schleifenrumpf.

Java-Arrays-for-Schleife-Werte-3-Durchlauf

Jetzt wird das dritte Fach des Java Arrays ausgelesen (erstesArray[2]).
Zum Schluss wird i wieder um eins erhöht.

Und jetzt hat i den Wert drei.
Es wird geprüft:
Ist i immer noch kleiner als drei (Länge des Arrays).
Nein.

Java Arrays for Schleife Werte Abbruch

Die Schleife bricht also ab.
Programm Ende.

Und genau den gleichen Ablauf, implementierst du für das zweite Array.
Und so würden beide for-Schleifen aussehen:


public class ArraysVerrechnen {

	public static void main(String[] args) {
		double[] erstesArray = new double[3];
		double[] zweitesArray = new double[3];	
		
		//Füllen des ersten Arrays
		erstesArray[0]= 2.2; //Fach 1 mit Wert 2,2
		erstesArray[1]= 4.0; //Fach 2 mit Wert 4
		erstesArray[2]= 333; //Fach 3 mit Wert 333
				
		//Füllen des zweiten Array
		zweitesArray[0]=7.6; //Fach 1 mit Wert 7,6
		zweitesArray[1]=10; //Fach 2 mit Wert 10
		zweitesArray[2]=14.7; //Fach 3 mit Wert 14,7
		
		//Werte aus ersten Array lesen
		for( int i = 0; i<3; i++ ){
			System.out.println(erstesArray[i]);
		} 
		
		//Werte aus zweiten Array lesen
		for( int i = 0; i<3; i++ ){
			System.out.println(zweitesArray[i]);
		}
	}
}

Übernimm den Code und klicke einmal auf Run und schau, was passiert.

Und alles gut, oder? 🙂

Wir haben das eigentliche Problem nicht gelöst.
Wir wollten eine Summe aus dem jeweiligen Array ziehen.
Und wir wollten eine Gesamtsumme aus beiden Arrays haben.

Bisher bekommen wir lediglich die Werte angezeigt, welche im Array stecken.
Lass uns das jetzt ändern.

So kannst du beide Arrays mit einander verrechnen.

Bis hierhin war es nur Vorbereitung.
Jetzt geht's richtig los.

Jetzt brauchst du eine Variable, welche die Summe speichern kann.

Da die Zahlen alles Gleitkommazahlen - also double Datentypen sind - sollte die Summe ebenfalls ein Double Datentyp sein.
Und innerhalb der Schleife wird der Summenwert zugewiesen.

Und so geht’s.


public class ArraysVerrechnen {

	public static void main(String[] args) {
		double[] erstesArray = new double[3]; //Array mit Länge 3
		double[] zweitesArray = new double[3];//Array mit Länge 3	
		
		double summeArrayEins=0; //lokale Variable benötigt eine Wertzuweisung
		
		//Füllen des ersten Arrays
		erstesArray[0]= 2.2; //Fach 1 mit Wert 2,2
		erstesArray[1]= 4.0; //Fach 2 mit Wert 4
		erstesArray[2]= 333; //Fach 3 mit Wert 333
				
		//Füllen des zweiten Array
		zweitesArray[0]=7.6; //Fach 1 mit Wert 7,6
		zweitesArray[1]=10; //Fach 2 mit Wert 10
		zweitesArray[2]=14.7; //Fach 3 mit Wert 14,7
		
		//Summe aus ersten Array lesen
		for( int i = 0; i<3; i++ ){
			summeArrayEins=erstesArray[i]+summeArrayEins;
		}
		System.out.println(summeArrayEins);
	}
}

Wie du siehst, habe ich für die Summe eine neue Variable "summeArrayEins" angelegt.
Diese speichert die Summe aller Werte für das erste Array.

In der for-Schleife wird die Summe jetzt berechnet.
Lass uns doch die for-Schleife noch einmal durchgehen.

Summe hat den Wert 0.
Der Schleifenzähler i hat ebenfalls den Wert null.
I ist kleiner 3 - Also ab in den Schleifenrumpf.

Java Arrays Summe erster Durchlauf

Im Schleifenrumpf wird die Anweisung oder die Summengleichung summeArrayEins=erstesArray[i]+summeArrayEins; ausgeführt.
Das bedeutet:
Der Wert des Arrays an der Stelle (i=0) ist 2,2.
Setze die Werte in Summengleichung ein!: 2,2 + 0 =2,2.
Nach dem ersten Durchlauf hat die Variable "summeArrayEins" den Wert 2,2.
I wird dann um eins erhöht.

Nächster Durchlauf.
Der Schleifenzähler hat den Wert 1.
Die Variable "summeArrayEins" hat den Wert 2,2.
I ist immer noch kleiner als drei.
Also ab in den Schleifenrumpf.

Java Arrays Summe 2 Durchlauf

Jetzt wird der Wert an der Stelle i=1 (4,0) auf die bisherige Summe aufaddiert.
Die Summe hat demnach jetzt den Wert 6,2 (4,0+2,2).
I wird wie immer um eins erhöht.

Dritter Durchlauf.
Die bisherige Summe hat den Wert 6,2 und der Schleifenzähler i den Wert 2.
Der Schleifenzähler ist immer noch kleiner als drei. Also wieder in den Schleifenrumpf.

Java Arrays Summe 3 Durchlauf

An der Stelle erstesArray[i]=2 steht der Wert 333. Dieser wird der Variablen "summeArrayEins" hinzuaddiert.
Und heraus kommt der Wert (6,2+333) 339,2.
I wird um eins erhöht und hat jetzt den Wert 3.

Nächste Prüfung.
Der Schleifenzähler i hat den Wert drei. Und i ist jetzt nicht mehr kleiner als 3.
Somit bricht die Schleife an dieser Stelle ab.

Java Arrays Summe Abbruch

Das Programm springt dann hinter die Schleife (Schleifenende) und führt den Code dazu aus.


public class ArraysVerrechnen {

	public static void main(String[] args) {
		double[] erstesArray = new double[3]; 
		double[] zweitesArray = new double[3];	
		
		double summeArrayEins=0; //lokale Variable benötigt eine Wertzuweisung
		
		//Füllen des ersten Arrays
		erstesArray[0]= 2.2; //Fach 1 mit Wert 2,2
		erstesArray[1]= 4.0; //Fach 2 mit Wert 4
		erstesArray[2]= 333; //Fach 3 mit Wert 333
				
		//Füllen des zweiten Array
		zweitesArray[0]=7.6; //Fach 1 mit Wert 7,6
		zweitesArray[1]=10; //Fach 2 mit Wert 10
		zweitesArray[2]=14.7; //Fach 3 mit Wert 14,7
		
		//Summe aus ersten Array lesen
		for( int i = 0; i<3; i++ ){
			summeArrayEins=erstesArray[i]+summeArrayEins;
		} //Schleifenende hier geht es dann weiter
		System.out.println(summeArrayEins);
	}
}

Ich habe für dich im Code das Schleifenende nur noch einmal fett markiert.
Und hinter diesem Schleifenende gibt die System.out.println()-Anweisung den Gesamtwert der Variablen "summeArrayEins" aus.

Und analog dazu kannst du dies für das zweite Array auch machen.
Lege eine zweite lokale Variable an. (zB. "summeArrayZwei")
Und lass diese im Schleifenkopf um den jeweiligen Array-Wert erhöhen.

Hier der komplette Code für beide Arrays.


public class ArraysVerrechnen {

	public static void main(String[] args) {
		double[] erstesArray = new double[3]; //
		double[] zweitesArray = new double[3];	
		
		double summeArrayEins=0; //lokale Variable benötigt eine Wertzuweisung
		double summeArrayZwei=0; //lokale Variable speichert die Summe des zweiten Arrays
		
		//Füllen des ersten Arrays
		erstesArray[0]= 2.2; //Fach 1 mit Wert 2,2
		erstesArray[1]= 4.0; //Fach 2 mit Wert 4
		erstesArray[2]= 333; //Fach 3 mit Wert 333
				
		//Füllen des zweiten Array
		zweitesArray[0]=7.6; //Fach 1 mit Wert 7,6
		zweitesArray[1]=10; //Fach 2 mit Wert 10
		zweitesArray[2]=14.7; //Fach 3 mit Wert 14,7
		
		//Werte aus ersten Array lesen
		for( int i = 0; i<3; i++ ){
			summeArrayEins=erstesArray[i]+summeArrayEins;
		} //Schleifenende
		System.out.println(summeArrayEins);
		
		//Summe aus zweiten Array lesen
		for( int i = 0; i<3; i++ ){
			summeArrayZwei=zweitesArray[i]+summeArrayZwei;
		}
		System.out.println(summeArrayZwei);
	}
}

Du hast jetzt aus jedem Array die entsprechende Summe aller Werte, welche sich im Array befinden.

Was ist mit einer Gesamtsumme aus beiden Arrays?
Wenn du die Gesamtsumme speichern möchtest, legst du entweder eine dritte Variable "gesamtSumme" an.
Und lässt dir eine zusätzliche Bildschirmausgabe zurückgeben.
Oder du speicherst dieses Ergebnis nicht zwischen und implementierst die Addition direkt in ein System.out.println()-Anweisung.

Hier im Code nochmal die fett markierten Neuerungen mit einer Gesamtsumme.


public class ArraysVerrechnen {

	public static void main(String[] args) {
		double[] erstesArray = new double[3];
		double[] zweitesArray = new double[3];	
		
		double summeArrayEins=0; //lokale Variable benötigt eine Wertzuweisung
		double summeArrayZwei=0; //lokale Variable speichert die Summe des zweiten Arrays
		
		erstesArray[0]= 2.2;
		erstesArray[1]= 4.0;
		erstesArray[2]= 333;
				
		zweitesArray[0]=7.6;
		zweitesArray[1]=10;
		zweitesArray[2]=14.7;
		
		
		for( int i = 0; i<3; i++ ){
			summeArrayEins=erstesArray[i]+summeArrayEins;
		} 
		System.out.println(summeArrayEins); //Rückgabe Summe Array 1
		
		for( int i = 0; i<3; i++ ){
			summeArrayZwei=zweitesArray[i]+summeArrayZwei;
		}
		System.out.println(summeArrayZwei); //Rückgabe Summe zweites Array
		
		double gesamtSumme = summeArrayEins + summeArrayZwei;//Die Summe aus beiden Arrays
		System.out.println(gesamtSumme); //Gesamtsumme
		System.out.println(summeArrayEins+summeArrayZwei);//Auch so bekommst du die Gesamtsumme
	}
}

Insgesamt bekommst du vier Konsolenausgaben.
Wobei du bei der Ausgabe der Gesamtsumme, entscheiden kannst - wie du es machst.

Natürlich kannst du dir auch die Teilsummen in einer For-Schleife ausgeben lassen.

Auch das geht.

Dafür brauchst du nur eine Schleife.
Und in dieser lässt du dir die Summe berechnen.
Und gleichzeitig lässt du dir die Bildschirmausgabe zurückgeben.

Du benötigst für die Summe dann auch nur noch eine Variable "gesamtSumme".


public class ArraysVerrechnen {

	public static void main(String[] args) {
		double[] erstesArray = new double[3];
		double[] zweitesArray = new double[3];	
		
		double gesamtSumme=0; //lokale Variable benötigt wieder eine Wertzuweisung
		
		//Füllen des ersten Arrays
		erstesArray[0]= 2.2; //Fach 1 mit Wert 2,2
		erstesArray[1]= 4.0; //Fach 2 mit Wert 4
		erstesArray[2]= 333; //Fach 3 mit Wert 333
				
		//Füllen des zweiten Array
		zweitesArray[0]=7.6; //Fach 1 mit Wert 7,6
		zweitesArray[1]=10; //Fach 2 mit Wert 10
		zweitesArray[2]=14.7; //Fach 3 mit Wert 14,7
		
		//Werte aus beiden Arrays lesen
		for( int i = 0; i<3; i++ ){
			gesamtSumme=erstesArray[i]+zweitesArray[i]+gesamtSumme;
			System.out.println(gesamtSumme);
		} //Schleifenende
	}
}

Lass uns auch diese Schleife einmal gedanklich durchspielen.

Die Schleife startet bei i =0.
Die Schleifenbedingung lautet i soll kleiner als die Länge der Arrays sein. (i<3) Der Schleifenzähler i ist kleiner als die Schleifenbedingung i<3. Also ab in den Schleifenrumpf.

java Arrays Gesamtsumme 1 Durchlauf

Die "gesamtSumme" ist zu diesem Zeitpunkt null.
I hat den Wert 0. An der Stelle des ersten Arrays erstesArray[i], bei i =0, steht der Wert 2,2.
Dieser Wert wird mit dem des zweiten Arrays verrechnet (2,2+7,6).
Dazu kommt noch die Summe 0.
Insgesamt hat die "gesamtSumme" einen Wert, nach dem ersten Durchlauf, von 9,8.
I wird wieder um eins erhöht und hat jetzt den Wert 1.

Nächster Durchlauf.
I = 1.
gesamtSumme = 9,8.
Schleifenzähler "i" ist immer noch kleiner als die Schleifenbedingung (i<3). Also rein in die Schleife.

Java Arrays Gesamtsumme 2 Durchlauf

An der Stelle i =1 haben die Arrays folgende Werte:
arrayEins=4,0
arrayZwei=10
Die Schleifenanweisung ergibt somit eine neue Gesamtsumme von (4,0+10,0 +9,8) 23,8.

Und der dritte Durchlauf.
I wurde erhöht und hat den Wert zwei.
Die gesamtsumme beträgt vor dem Schleifenantritt 23,8.

Java Arrays Gesamtsumme 3 Durchlauf

An der Stelle zwei wurden folgende Werte in den Arrays gespeichert.
arrayEins=333
arrayZwei=14,7.
Somit ergibt sich eine neue Gesamtsumme von (333+14,7+23,8) 371,50.
I wird erhöht und hat somit den Wert drei.

Und damit bricht die Schleife ab.

Cool, oder? 🙂

Jetzt lass uns noch eins tun.
Und zwar optimieren.

So optimierst du deine for-Schleife für den Durchlauf der Java Arrays.

Schau dir die Schleife einmal an.

Die Schleife macht immer drei Durchläufe.
Dies haben wir als Schleifenbedingung so festgehalten. i<3

Das ist aber blöd.
Wenn du nämlich in eines der Arrays zukünftig 4 Werte speichern möchtest, dann würde der vierte Wert nicht mehr gelesen werden.

Wir benötigen also etwas Dynamisches.
Und das hat jedes Array von Anfang an.

Und zwar handelt es sich um eine Variable, welche die Länge des Arrays speichert.
Diese nennt sich length.

Und du kannst diese direkt an einem der Arrays aufrufen.

  • Gib den Namen der Refenzvariablen an: arrayEins oder arrayZwei.
  • Dann setze einen Punkt und leite die Punktnotation ein.
  • Und dann schreibe den Variablennamen: length.

Da so ein Array auch nur ein Objekt ist, besitzt jedes Array so eine eigene Variable.
Du kannst dir die Werte einmal als Bildschirmausgabe anzeigen lassen.

  • System.out.println(erstesArray.length);
  • System.out.println(zweitesArray.length);

In beiden Fällen sollte der Wert drei zurück gegeben werden.
Denn unsere bisherigen Arrays haben die Länge drei.

Wenn du jetzt eines der Arrays änderst, bekommst du andere Längenangaben zurück.
Zum Beispiel schreibe:
double[] erstesArray = new double[4];
Du erhälst dann den Wert vier.

Probiere es aus.

Und diese Variable kannst du im bisherigen Code einsetzen.
Und zwar in beiden For-Schleifen.
So würde der Code dazu aussehen:


public class ArraysVerrechnen {

	public static void main(String[] args) {
		double[] erstesArray = new double[3]; 
		double[] zweitesArray = new double[3];	
		
		double summeArrayEins=0; //lokale Variable benötigt eine Wertzuweisung
		double summeArrayZwei=0; //lokale Variable speichert die Summe des zweiten Arrays
		
		//Füllen des ersten Arrays
		erstesArray[0]= 2.2; //Fach 1 mit Wert 2,2
		erstesArray[1]= 4.0; //Fach 2 mit Wert 4
		erstesArray[2]= 333; //Fach 3 mit Wert 333
				
		//Füllen des zweiten Array
		zweitesArray[0]=7.6; //Fach 1 mit Wert 7,6
		zweitesArray[1]=10; //Fach 2 mit Wert 10
		zweitesArray[2]=14.7; //Fach 3 mit Wert 14,7
		
		//Werte aus ersten Array lesen mit Variable length
		for( int i = 0; i<erstesArray.length; i++ ){
			summeArrayEins=erstesArray[i]+summeArrayEins;
		} //Schleifenende
		System.out.println(summeArrayEins);
		
		//Summe aus zweiten Array lesen mit Variable length
		for( int i = 0; i<zweitesArray.length; i++ ){
			summeArrayZwei=zweitesArray[i]+summeArrayZwei;
		}
		System.out.println(summeArrayZwei);
	}
}

Du hast somit die Fixierung von genau drei Durchläufen (i<3) aufgehoben. Und stattdessen hast du die Anzahl der Durchläufe dynamisch an die Länge eines jeweiligen Arrays angepasst.

  • erstesArray.length
  • zweitesArray.length

Jetzt kannst du die Länge einer Java Arrays beliebig erweitern.
Und neue Werte in das Array speichern.

Die for-Schleife passt sich flexibel der Länge des jeweiligen Arrays an.

Zusammenfassung:

  • Um Werte aus Java Arrays miteinander zu verrechnen, solltest du eine Variable anlegen.
    In dieser Variable würdest du dann die Summe, die Differenz, Produkt oder einen Quotienten speichern.
  • Mit einer For-Schleife kannst du dann die einzelnen Werte eines Arrays herausnehmen.
    Und diese dann deiner Variable hinzurechnen.

Ähnliche Beiträge

Java for Schleifen schachteln – So funktioniert es

Java For Schleifen schachteln

Diese Situation kennst du doch auch…. Du stehst an der Haltestelle und wartest auf den Bus. Dein Blick fällt auf die Uhr.   Oder du wartest an der Ecke auf deinen Freund oder Kollegen. Immer wieder schaust du auf deine Uhr.   Sie ist kaum noch wegzudenken. Die mobile Taschenuhr.   Lange Zeit wurde die […]

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

Java Übung 26 – Das erste kleine Java Spiel

Java Übung Zahlenraten

In dieser Java Übung geht es darum ein kleines Java-Spiel zu erstellen. Und zwar Zahlen raten. Was kannst du dir darunter vorstellen? Du gibst einen bestimmten Wertebereich an. Zum Beispiel 0 bis 100. Und das Java Programm erstellt eine Zufallszahl in diesem Bereich. Dann fordert dich das Programm auf, die Zahl zu raten. Du gibst […]

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

Java lernen – 10 nützliche Tipps für Java Anfänger

Java Lernen Anfänger

Wenn du die Programmiersprache Java lernen möchtest, bist du hier prinzipiell erst einmal richtig. Und wenn du es wirklich ernst meinst und in die Java Programmierung einsteigen möchtest, solltest du auch meinen kostenlosen Java Kurs beanspruchen. Wenn du dabei bist, bekommst du: Eine Lektion pro Woche zu den Basics. Hier geht es um die ersten […]

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

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

Java Übung 18: Berechne die Fakultät

Java Übung Fakultät

In dieser Java Übung geht es um die Fakultät aufeinander folgender Zahlen. Für alle, bei denen der Mathe-Unterricht genauso lange her ist, wie bei mir: 🙂 Die Fakultät ist das Produkt aufeinander folgender natürlicher Zahlen. Zum Beispiel: Die Fakultät von 2 ist: 1*2=2 Die Fakultät von 5 ist: 1*2*3*4*5=120 So – ich hoffe, dass ich […]

Warum Java Kommentare immer ein Mittel der Kommunikation sind

Java Kommentare Kommunikation

Kennst Du die Bücherreihe „Miteinander reden“ von Schulz von Thun? Falls Du an der Uni warst oder bist, gehört dieses Buch zur Standardlektüre im Fach Schlüsselkompetenz. Denn ein Java Entwickler, welcher im Team arbeitet, muss klar und deutlich kommunizieren können. Und klar und deutlich heißt nicht, dass die Aussprache Deiner Worte verständlich sein soll. Nein […]

Du bekommst was du vereinbarst – Die Rückgabewerte von Java Methoden

Java Methoden Rückgabetypen

Was du vereinbarst, das bekommst du zurück. Ach wäre es schön, wenn alles im Leben so funktionieren würde. Aber zum Glück funktioniert dieses Prinzip bei deinen Java Methoden. Denn du kannst den Rückgabetypen im Methodenkopf vereinbaren. Doch bevor ich dir zeige, wie du den Rückgabetypen anlegen kannst…. Lass mich dir zeigen, wofür du den Kram […]