So kannst du Werte aus zwei oder mehreren Java Arrays verrechnen

Schlagwörter: Java Arrays, Java Programmierung

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.

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.

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

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

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.

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.

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.

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.

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.

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.

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

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.