Versuche seit geraumer Zeit ein kleines Problemchen zu lösen. Zwei Array von gleichem Datentyp aber unterschiedlicher Länge sollen zusamenaddiert werden, d.h. Element für Element. Und dann das Resultat als String ausgegeben werden.
Schritt 1: Die Länge von beiden Arrays vergleichen > Die Länge des kleineren als ein Int-Wert in eine Variable packen und einer neuen Int[]-Variable zuweisen
Schritt 2: Die Elemente beider Arrays durch eine for-Schleife durchiterieren. Die Anzahl der Iterationen ist gleich der Länge der eben zuvor belegten int[]-Variable.
So sieht´s dann aus
Die ausführende Methode:
import java.util.Arrays;
public class TestOne {
public static void main(String[] args) {
Ergebnis P = new Ergebnis();
int[]array1 = {1,2,3};
int[]array2 = {4,5,6,7,8};
P.setArrayOne(array1);
P.setArrayTwo(array2);
System.out.println(Arrays.toString(array1));
System.out.println(Arrays.toString(array2));
P.LVergleich();
P.Summe()
System.out.println(Arrays.toString(P.Summe());
}
}
public int[] getEquivalentTwo() {
return equivalentTwo;
}
public void setEquivalentTwo(int[] equivalentTwo) {
this.equivalentTwo = equivalentTwo;
}
public int getEquivalentOne() {
return equivalentOne;
}
public void setEquivalentOne(int equivalentOne) {
this.equivalentOne = equivalentOne;
}
public int[] getArrayOne() {
return arrayOne;
}
public void setArrayOne(int[] arrayOne) {
this.arrayOne = arrayOne;
}
public int[] getArrayTwo() {
return arrayTwo;
}
public void setArrayTwo(int[] arrayTwo) {
this.arrayTwo = arrayTwo;
}
public int[] LVergleich () {
if (arrayOne.length > arrayTwo.length) {
equivalentOne = arrayTwo.length;
}
int[]equivalentTwo = new int[equivalentOne];
return equivalentTwo;
}
public int[] Summe () {
int[]sum = equivalentTwo;
for (int z = 0; z <equivalentTwo.length; z++) {
sum[z] = arrayOne[z] + arrayTwo[z];
}
return sum;
}
}
Und das ist die Exception bei dem Ausführungsversuch:
Exception in thread "main" java.lang.NullPointerException: Cannot read the array length because "this.equivalentTwo" is null
Also ich stehe gerade so richtig aus dem Schlauch und komme nicht weiter. Wenn mir lemand helfen könnte den/die Fehler in meinem Code zu verstehen wäre ich dankbar.
Kennt jemand vielleicht, wie mann die Arrays sonst aufaddieren kann? Für die Info wäre ich ebenfalls dankbar 🥺
PS: Sorry für die unakkurate CodeFormatierung. Habe erst grade bemerkt 😬
Wenn One kleiner als Two ist, dann bleibt equivalentOne gleich 0 und damit ist equvalentTwo ein leeres Array.
Du solltest noch etwas an deiner Benamung arbeiten, da schwirrt einem ja der Kopf... und zusätzlich noch generell: Klassennamen mit einem Großbuchstaben am Anfang, Variablen- und Methodennamen mit einem Kleinbuchstaben am Anfang.
Wenn One kleiner als Two ist, dann bleibt equivalentOne gleich 0 und damit ist equvalentTwo ein leeres Array.
Du solltest noch etwas an deiner Benamung arbeiten, da schwirrt einem ja der Kopf... und zusätzlich noch generell: Klassennamen mit einem Großbuchstaben am Anfang, Variablen- und Methodennamen mit einem Kleinbuchstaben am Anfang.
Viel Kreativität ist da nicht notwendig. Der Name sollte aussagekräftig in Hinblick auf die Funktion der Methode/Variablen sein. Im einfachsten Fall nimm einfach das als Name.
"equivalentOne" speichert die Länge des kürzeren Arrays: "shortArrayLength" wäre mal ein Ansatz für einen aussagekräftigen Namen.
Ähmmm. Ich copiere es trotzdm nicht. Das ist doch die Bedingung, wenn One kleiner als Two ist, dann soll seine Länge (in diesem Fall 3) der Eq.One als int-wert zugewiesen werden. eq.One soll dann 3 sein. Warum ist es 0?
Viel Kreativität ist da nicht notwendig. Der Name sollte aussagekräftig in Hinblick auf die Funktion der Methode/Variablen sein. Im einfachsten Fall nimm einfach das als Name.
"equivalentOne" speichert die Länge des kürzeren Arrays: "shortArrayLength" wäre mal ein Ansatz für einen aussagekräftigen Namen.
Ähmmm. Ich copiere es trotzdm nicht. Das ist doch die Bedingung, wenn One kleiner als Two ist, dann soll seine Länge (in diesem Fall 3) der Eq.One als int-wert zugewiesen werden. eq.One soll dann 3 sein. Warum ist es 0?
Du deklarierst eine Instanzvariable "equivalentOne", die mit 0 initialsiert wird. Dann sagst du: Wenn One größer ist als Two, setze diese Variable auf die Länge von Two. Ansonsten bleibt sie halt 0.
publicint[]LVergleich(){// ...// hier deklarierst du eine NEUE lokale Variable equivalentTwo, welche die// Instanzvariable equivalentTwo überdeckt. Diese neue Variable wird zwar// zurückgegeben, aber beim Aufruf der Methode machst du nichts damit.int[] equivalentTwo =newint[equivalentOne];return equivalentTwo;}
publicint[]LVergleich(){// ...// hier deklarierst du eine NEUE lokale Variable equivalentTwo, welche die// Instanzvariable equivalentTwo überdeckt. Diese neue Variable wird zwar// zurückgegeben, aber beim Aufruf der Methode machst du nichts damit.int[] equivalentTwo =newint[equivalentOne];return equivalentTwo;}
Yeeeees! Jetzt leuchtet´s mir ein. Sorry nochmal, ich hab das mit Instanz- und Lokalvariablen noch nicht so richtig verstanden. Ich brauche dringend mehr Übung.
