Arrays aufsummieren

[AbsolutBeginner]

Hi Leute!​

Einen wunderschönen Guten Morgen an alle!​

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());
}
}

Die Klasse mit Untermethoden:​

public class Ergebnis {

private int[] arrayOne;
private int[] arrayTwo;
private int[] equivalentTwo;
private int equivalentOne;

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 😬

 

[temi]

if (arrayOne.length > arrayTwo.length) {
equivalentOne = arrayTwo.length;
}
int[]equivalentTwo = new int[equivalentOne];

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.

 

[AbsolutBeginner]

if (arrayOne.length > arrayTwo.length) {
equivalentOne = arrayTwo.length;
}
int[]equivalentTwo = new int[equivalentOne];

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.

Ja ich weiss 🙄🙏 Es tut mir leid. Ich bin in diesem Punkt nicht gerade besonders kreativ.

 

[temi]

Ich bin in diesem Punkt nicht gerade besonders kreativ.

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.

 

[AbsolutBeginner]

Ja ich weiss 🙄🙏 Es tut mir leid. Ich bin in diesem Punkt nicht gerade besonders kreativ.

Ä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?

 

[AbsolutBeginner]

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.

Danke, das klingt wirklich besser.

 

[temi]

Ä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.

 

[fhoffmann]

int[]equivalentTwo = new int[equivalentOne];

Hier legst du eine lokale (!) Variable equivalentTwo an; dies ist nicht deine Instanzvariable.
Lass an dieser Stelle das "int[]" weg!

 

[temi]

Ich sehe gerade noch einen Fallstrick:

public int[] 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 = new int[equivalentOne];
    return equivalentTwo;
}

 

[AbsolutBeginner]

Hier legst du eine lokale (!) Variable equivalentTwo an; dies ist nicht deine Instanzvariable.
Lass an dieser Stelle das "int[]" weg!

🤩🤝😭 Es klappt endlich. Sorry, mein Gehirn weigert sich seit heute morgen richtig zu arbeiten. Vielen, vielen Dank.

 

[AbsolutBeginner]

Ich sehe gerade noch einen Fallstrick:

public int[] 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 = new int[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.

Und einen Riesendank für Ihre Erklärung 🙏

 

[AbsolutBeginner]

Ich hab das mit richtiger Syntax und Semantik von Java noch nicht richtig drauf.

public int[] vergleich(){

        if (arrayOne.length < arrayTwo.length) {
            equivalentOne = arrayOne.length;
        }else{
            equivalentOne = arrayTwo.length;
        }
        equivalentTwo = new int[equivalentOne];
        return equivalentTwo;

jetzt wird´s ausgeführt, ohne ecxeptions !

Später probiere ich die Eingabeoption von Konsole aus mit Scanner einzubauen, dann ist mein Mikroprogrammchen fertig!