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 Methoden mit variabler Argumentenanzahl – VarArgs

Java Methoden mit variabler Argumentenanzahl VarArgs

Du kennst das noch. Kopfrechnen und zwar auf Zeit. So etwas ist das Standardprogramm in den Schulklassen 1 bis 5. Irgendwann, in Klasse 6 oder 7, kommt der Taschenrechner ins Spiel und Kopfrechnen ist aus dem Schulalltag gestrichen. Schade eigentlich. Dabei kann man diese Disziplin auch wunderbar in kleinen Spielen unterbringen. Ich erinnere mich noch: […]

Polymorphie bringt Vorteile für Java Arrays

Java Polymorphie Arrays

Wenn Java Arrays, Schubladen oder Container sein sollen… Dann wäre der Gebrauch einer solchen Schublade ziemlich einseitig und festgefahren. Denn in jedes Array passen zwar mehrere Daten – aber immer nur vom gleichen Datentyp. Immer gleicher Datentyp? Also eine Schublade nur für Socken, Unterwäsche und der ganze andere Kram passt dann eben nicht hinein. Um […]

Java Binärzahl in Dezimalzahl umwandeln – So geht’s.

Java-Binärzahl-umrechnen

Erinnerst du dich? In einer der letzten Beiträge haben wir uns die Zusammenhänge zwischen dem dualen und dem dezimalen Zahlensystem angeschaut. Aber wir haben noch keine Java Binärzahl in eine Dezimalzahl verwandelt. Zumindestens nicht praktisch…. Stattdessen…. Haben wir festgestellt, dass beide Zahlensysteme im Grunde genommen sehr ähnlich sind. Beim Dezimalsystem spielt die Zahl 10, als […]

Nutze das Keyword this für deine Java Konstruktoren

Java konstruktoren this

Es ist gemein. Wahrscheinlich hast den Beitrag zu den lokalen Variablen gelesen. Vielleicht hast du auch den Artikeln zum Anlegen und Überladen von Java Konstruktoren gelesen. Und wenn du die beschriebene Inhalte selbst ausprobiert hast…… Dann hast du dir wahrscheinlich sehr viele lokale Variablennamen für die Parameterliste ausdenken müssen.

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

So richtest du einen Schreibschutz für deine Java Variablen ein

Stell dir vor: Du hast erfolgreich dein erstes Programm für die Personalabteilung aufgesetzt. Du hast deine ersten 1000 Datensätze schön sauber angelegt. Und nun kommt dein Kollege und überschreibt die Vornamen der ersten 100 Mitarbeitern. Na schöne Sch…. 🙂 Wie kann das passieren? Wie kann man das verhindern? Du brauchst eigentlich nur deine Java Variablen […]

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