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

Der bedeutende Unterschied zwischen Klassenvariablen und Instanzvariablen

Java Klassenvariablen

Bei der Java Programmierung unterscheidet man drei Arten von Variablen. Als erste Gruppe sind die lokalen Variablen zu nennen. Auf diese gehe ich in einem separaten Artikel ein. Mich interessieren die zwei anderen Variablentypen. Zum einen existieren Klassenvariablen. Und dann sind da noch die Instanzvariablen. Wo liegt der Unterschied? Instanzvariablen stehen einem Objekt zur Verfügung. […]

So kannst du deine Eclipse Oberfläche anpassen

Eclipse anpassen

In diesem Beitrag möchte ich dir zwei ganz nette Features von Eclipse vorstellen. Es geht um Views und um Perspektiven. Wie du schon weißt, besteht Eclipse aus einer grafischen Oberfläche. Und in dieser Oberfläche stehen dir verschiedene Views zur Verfügung. Was ist so ein View?

Die mathematischen Grundlagen des Dezimalsystems für Java Programmierer

Java Dezimalsystem Mathematik Programmierer

Bei der Java Programmierung benötigst du Kenntnisse über das Dezimalsystem. Allein schon für die technische Umsetzung beim Runden einer Zahl. Oder du möchtest den Kehrwert bzw. den Umkehrwert einer Zahl im Programm bestimmen lassen. Aber auch für das Herausfinden des Stellenwertes – also wieviel Stellen hat eine Zahl – benötigst du das Grundwissen des Dezimalsystems. […]

So kannst du Java Arrays anlegen

Java Arrays anlegen

Java Arrays– Was ist das? Stell es dir einmal als ein Bücherregal vor. In einem Bücherregal befinden sich sämtliche Bücher. Und diese befinden sich schön nebeneinander. Jedes Buch hat seinen festen Platz. Du kannst die Bücher ganz genau lokalisieren. Zum Beispiel kannst du sagen. Das erste Buch von links Das dritte von rechts usw. Und […]

So lassen sich Java Arrays kopieren

Java Arrays kopieren

Java Arrays kopieren oder klonen…. Was heißt das eigentlich? Eine Kopie ist eine Reproduktion bzw. die Nachbildung eines Originals. Somit ist jede Fotographie – die Abbildung einer bestimmten optischen Wirklichkeit, zu einem festen Zeitpunkt. Die Kopie einer Buchseite ist das optische Abbild dieser spezifischen Buchseite – auch zu einem festen Zeitpunkt. Wichtig in diesem Zusammenhang […]

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

Den Java Vererbungsbaum nach dem Ist-Es-Prinzip richtig entwerfen

Java Vererbungsbaum

Vererbungsbaum in Java – klingt erstmal komisch. Dennoch wird dies so bezeichnet. Gemeint sind damit – die einzelnen Hierarchiestufen oder Vererbungsebenen – von der Superklasse bis runter zu den Kindklassen. Wie sieht das nun konkret aus? Vererbung bedeutet: Du definierst einen allgemeinen Typen – zB. Möbel Und dann implementierst du eine Unterklasse, welche die Oberklasse […]

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

Java Übung 16 – Bestimme den größten gemeinsamen Teiler

Java Übung Teiler

In dieser Java Übung möchte ich, dass du den größten gemeinsamen Teiler zwei Zahlen ermittelst. Ich möchte, dass du das Ganze mit einer while-Schleife umsetzt. Und wie? Du legst eine neue Klasse „GGT“ (größter gemeinsamer Teiler) an. In diese Klasse implementierst du eine Klassenmethode „berechneGGT“. Diese erwartet zwei Argumente vom Datentyp Integer.

Der Aufbau von Java Klassen

Java Klassen Aufbau

Jedes Java Programm besteht aus Java Klassen. Doch wie sind diese aufgebaut? Wie setzt sich die Struktur zusammen? Wo befinden sich Klassen hierarchisch? Was kommt in die Klassen rein und wie wird es integriert? Das sind die Fragen, welche ich in diesem Artikel beantworten werde. Doch bevor wir bei den Klassen ansetzen, müssen wir eine […]