Java Boolean reagiert nicht

Hallo habe folgende Aufgabe bearbeitet aber es wird nur false zurück gegeben. Hat jemand eine Ahnung wieso?
Beispiel: Ich gebe 1,2,3,6 ein (summe= 12; mittelwert Vor und Nach = 3; 3 ist im array; ausgabe trotzdem false)

AUFGABE:
Erstellen sie die Klasse Functionality.java und bearbeiten sie die folgende aufgabe.

Implementieren sie eine static public methode mit namen "containsMean",
welche ein array vom typ int erhält und einen boolean zurück gibt.

Die MEthode soll den mMittelwert von allen Zahlen aus dem Array berechnen.

Der Mittelwert soll auf eine Ganzzahl ruden. Es wird true zurückgegeben,
wenn der abgerundete Mittelwert im Array selbst enthalten ist.Sollte der Mittelwert nicht enthalten sein oder das Array null sein oder das
Array nicht mindestens ein Element besitzen, dann soll false zurückgegeben werden.

CODE:


Java:
import java.util.Scanner;
import java.util.Arrays;

public class Functionality {
    public static void main(String[]args) {
       
        int laenge = 0;

        System.out.println("Geben Sie die Länge des Arrays ein: ");
        Scanner scan = new Scanner(System.in);
        laenge = scan.nextInt();
       
        int array[] = new int[laenge];   
           
        System.out.println(containsMean(array));
       
    }
   
    public static boolean containsMean(int array[]) {
   
        Scanner scan = new Scanner(System.in);
       
        int mittelwertVor = 0;
        int mittelwertNach = 0;
        int summe = 0;
        int anzahl = 0;
        boolean check = true;
       
        for(int i = 0; i < array.length; i++)
        {   
            System.out.println("Geben Sie die Arraywerte ein: ");
            array[i] = scan.nextInt();
            anzahl++;
            summe = summe + array[i];        
        }
        
        mittelwertVor = summe/anzahl;
        mittelwertNach = Math.round(mittelwertVor);
        
        for(int i = 0; i < array.length; i++)
        {
            if(array[i] == mittelwertNach)
            {
                check = true;
            }
            else if(summe == 0)
            {
                check = false;
            }
            else if(anzahl < 1)
            {
                check = false;
            }
            else
            {
                check = false;
            }
        }    
        
        System.out.println("vor: " +mittelwertVor);
        System.out.println("nach: "+mittelwertNach);
        return check;
    }
}
 
Zuletzt bearbeitet von einem Moderator:
1. Code bitte immer in Code-Tags posten. Entweder direkt über [code=Java]Dein Code[/code] oder über den Editor --> "3 Punkte" --> Code
2. Die Prüfung ob das Array null oder leer ist fehlt. (die Prüfung ob anzahl < 1 sollte aus der Schleife raus).
3. Wieso darf die Summe bei dir nicht 0 sein?
4. Du bekommst momentan false heraus, weil deine Schleife weiter läuft, auch wenn du bereits weißt, dass der Mittelwert im Array enthalten ist. Du veränderst den boolean `check` bei jedem Durchlauf. Sprich bei dir würde es gerade nur true ergeben, wenn der letzte Eintrag im Array gleich dem Mittelwert ist. Sobald du weißt, dass du den Mittelwert im Array gefunden hast, kannst du auch aufhören durch das Array zu iterieren.
 
Hallo,

als erstes: Bitte Code immer in [CODE][/CODE] - denn sonst werden Eckige Klassern ausgewertet und dein i Index sorgt dann für kursive Schrift....

Dein Problem ist, dass Du in der for Schleife ständig prüfst. Also als Beispiel hast Du ein Array mit mehreren Werten und der Mittelwert ist NICHT am Ende:
Du kommst also zu dem Mittelwert. Dieser wird erkannt und check wird auf true gesetzt.
Nun kommt er zu dem nächsten Wert und dieser ist kein Mittelwert, daher wird check auf false gesetzt.

Das Pattern ist bei so Suchen immer gleich:
- Das Gefunden flag wird auf falsch gesetzt (noch ist es nicht gefunden).
- Dann suchst du und wenn du es findest, dann setzt Du es auf true. (Aber kein else Zweig!)

Die übrigen Checks sind nicht in der Schleife notwendig. Diese kannst Du außerhalb der Schleife abfragen.
 
Zusätzlich zu den anderen Hinweisen sollte es auch
Code:
array[i]
heissen. Daneben kann man auch die Stream-API verwenden: https://www.baeldung.com/java-array-sum-average.
Ein paar Vorschläge (//Änderung) mit NetBeans:
Code:
package functionality;

import java.util.Scanner;
import java.util.Arrays;

public class Functionality {
public static void main(String[]args) {

int laenge = 0;

System.out.println("Geben Sie die Länge des Arrays ein: ");
Scanner scan = new Scanner(System.in);
laenge = scan.nextInt();

int array[] = new int[laenge];

System.out.println(containsMean(array));

}

public static boolean containsMean(int array[]) {

Scanner scan = new Scanner(System.in);

int mittelwertVor = 0;
int mittelwertNach = 0;
int summe = 0;
int anzahl = 0;
boolean check = false;  //Änderung

for(int i = 0; i < array.length; i++)
{
System.out.println("Geben Sie die Arraywerte ein: ");
array[i] = scan.nextInt();
anzahl++;
summe = summe + array[i];
}

mittelwertVor = summe/anzahl;
mittelwertNach = Math.round(mittelwertVor);

for(int i = 0; i < array.length; i++)
{
if(array[i] == mittelwertNach)
{
check = true;
}
/*else if(summe == 0)  //Änderung in Kommentar
{
check = false;
}
else if(anzahl < 1)
{
check = false;
}
*/
/*else
{
check = false;
}

*/ }

System.out.println("vor: " +mittelwertVor);
System.out.println("nach: "+mittelwertNach);
System.out.println("check-Resultat:" +check);
return check;

}
}
 
Ein paar weitere Hinweise möchte ich mir auch noch erlauben:
a) Methoden sollten keine unerwarteten Ergebnisse haben und auch nur eine Sache machen: "containsMean(Array)" sollte also nur genau das machen: Prüfen, ob der Mittelwert in dem Array drin ist. Da sollte also keine Eingabe abgefragt werden und das Array verändert werden. (contains prüft etwas aber verändert nichts!) Hier wäre also die Eingabe heraus zu ziehen und ggf. eine neue Methode einzuführen.

b) Berechnung des Mittelwerts: Da Du den Mittelwert direkt in einem int speicherst hast Du bereits eine entsprechende ganze Zahl. Du musst also nichts mehr runden.

c) anzahl musst Du nicht durch hochzählen ermitteln. Du hast ja die Array Größe, die ja auch in der for Schleife verwendet wird. Daher ist klar: Anzahl wird die Größe des Arrays. Es spricht nichts gegen so eine Variable, aber da würde ich diese dann direkt setzen (int anzahl = array.length; und dann nicht mehr verändern. Und dann würde ich statt array.length direkt anzahl verwenden.

d) Namensgebung: Du solltest Variablen sinnvoll benennen. array ist ein Array, aber was ist da drin? Das sind z.B. die Werte, mit denen du arbeitest, so dass "werte" schon besser wäre.

Edit: Ganz wichtig: Das ist "meckern auf sehr hohem Niveau" - Daher auch erst das späte erwähnen. Konzentriere dich auf die ersten Antworten bezüglich der eigentlichen Problematik. Die Punkte sind dann später ggf. ein "nice to have".
 
Zuletzt bearbeitet:
Hier ist meine Lösung


Java:
import java.util.Scanner;
import java.util.Arrays;


public class Functionality {
	//Main Methode
	public static void main(String[]args) {
		
		int mittelwert = 0;
		int laenge = 0;
		int summe = 0;
		
		System.out.println("Geben Sie die Länge des Arrays ein: ");
		Scanner scan = new Scanner(System.in);
		laenge = scan.nextInt();
		
		int werte[] = new int[laenge];	
		int anzahl = werte.length;
		
		//Array-Werte einlesen
		for(int i = 0; i < werte.length; i++) 
		{	
			System.out.println("Geben Sie die Arraywerte ein: ");
			werte[i] = scan.nextInt();
			summe = summe + werte[i];		
		}
		
		//Methode 'containsMean' aufrufen bzw. ausgeben des Ergebnisses (return) der Methode
		System.out.println(containsMean(werte, anzahl, summe, mittelwert));	
	}
	
	//'containsMean' Methode
	public static boolean containsMean(int werte[], int anzahl, int summe, int mittelwert) {
	
		boolean check = true;
		
		
		mittelwert = summe/anzahl;

		for(int i = 0; i < anzahl; i++)
		{
			if(werte[i] == mittelwert)
			{
				check = true;
			}
		}
		
		if(summe == 0)
		{
			check = false;
		}
		if(anzahl < 1)
		{
			check = false;
		}
		else
		{
			System.out.println("");
		}
		
		System.out.println("Mittelwert: " +mittelwert);

		return check;
	}
}
 
Hier ist meine Lösung


Java:
import java.util.Scanner;
import java.util.Arrays;


public class Functionality {
	//Main Methode
	public static void main(String[]args) {
		
		int mittelwert = 0;
		int laenge = 0;
		int summe = 0;
		
		System.out.println("Geben Sie die Länge des Arrays ein: ");
		Scanner scan = new Scanner(System.in);
		laenge = scan.nextInt();
		
		int werte[] = new int[laenge];	
		int anzahl = werte.length;
		
		//Array-Werte einlesen
		for(int i = 0; i < werte.length; i++) 
		{	
			System.out.println("Geben Sie die Arraywerte ein: ");
			werte[i] = scan.nextInt();
			summe = summe + werte[i];		
		}
		
		//Methode 'containsMean' aufrufen bzw. ausgeben des Ergebnisses (return) der Methode
		System.out.println(containsMean(werte, anzahl, summe, mittelwert));	
	}
	
	//'containsMean' Methode
	public static boolean containsMean(int werte[], int anzahl, int summe, int mittelwert) {
	
		boolean check = true;
		
		
		mittelwert = summe/anzahl;

		for(int i = 0; i < anzahl; i++)
		{
			if(werte[i] == mittelwert)
			{
				check = true;
			}
		}
		
		if(summe == 0)
		{
			check = false;
		}
		if(anzahl < 1)
		{
			check = false;
		}
		else
		{
			System.out.println("");
		}
		
		System.out.println("Mittelwert: " +mittelwert);

		return check;
	}
}


ist die Methode so minimalistisch genug programmiert?
 
Weil Du eine Methode schreiben sollst, die ein Array erhält und ein boolean liefern soll. Deine Methode erhält nicht nur ein Array sondern drei weitere Parameter.
 
Meiner Meinung nach nicht wirklich. Aber ich bringe jetzt ein paar Dinge mit rein, die evtl. etwas fortgeschrittener sind. Du scheinst aber sehr interessiert zu sein und daher will ich versuchen, Dir diese Dinge zu erläutern.

Es handelt sich hier um eine kleine Aufgabe, d.h. es ist leicht, tolle Optimierungen zu haben. In diesem Fall berechnest Du die Summe direkt bei der Eingabe. Das kann man auf jeden Fall so machen, aber ist eher unüblich.

Was man im Bereich Clean Code (= möglichst sauberen Code schreiben - dahinter verbergen sich viele einzelne Punkte) hier eher erwarten würde, wäre eine klare Auftrennung:

- Eine Methode, die nichts anderes macht, als x Integer Werte einzulesen und dann in einem Array zurück zu geben. Also z.B. so eine Signatur verwendet: int[] getIntegersFromUser(final int count) (das final kannst Du Dir wegdenken. Das wird von Manchen gerne genommen, damit klar ist: Am Parameter selbst ändere ich nichts - und so prüft das auch der Compiler.)
Diese Methode würde also ein neues int[] Array für count Elemente erzeugen und dann in einer Schleife diese Werte vom Anwender abfragen. (Und keine Summe berechnen!)
- Dann könnte man die Summe der Werte in einer Methode ermitteln: int getSum(final int[] values).
Also wieder eine Schleife, die über alle Werte drüber geht und aufaddiert. (Das Array alleine reicht als Parameter, die Anzahl benötigt man nicht.)
- Dann könnte man eine Methode haben, die den Mittelwert berechnet: int getMean(final int[] values). Diese Methode ist relativ einfach, denn diese berechnet die Summe / Anzahl, also ein einfaches return getSum(values) / values.length;
- dann könnte man eine Methode haben, die prüft, ob ein Wert in dem Array enthalten ist. Also sowas wie boolean conatins(final int[] values, final int searchValue). Wieder eine Schleife, Code dafür hast Du ja prinzipiell.
- Die eigentliche Methode, nach der gefragt ist, lässt sich dann mit den vorhandenen Methoden sehr gut schreiben....

Ich habe jetzt den Weg beschritten von einzelnen kleine Implementationen bis hin zur Lösung. Das geht aber auch anders herum. Man kann sich überlegen, was man braucht:
Das Programm soll machen:
- Hole Anzahl der Zahlen vom Anwender
- Frage die Zahlen ab
- Mach die gewünschte Prüfung
- Gib das Ergebnis aus.

Das kann man dann so wie es ist als Code schreiben:

Code:
int count = getCountFromUser();
int[] values = getIntArrayFromUser(count);
boolean result = containsMean(values);
showResultToUser(result);
Jetzt hast du das, was Dein Programm machen soll schon schön aufgeschrieben. Und jetzt fehlen natürlich die ganzen Funktionen und die schreibst du als nächstes. Das wäre dann ein Ansatz, der dann von "Top to Bottom" vorgeht während der erste Ansatz gerne als "Bottom up" bezeichnet wird...

Und wenn Du Dir den Code anschaust, wenn Du sowas schreibst an Code: Du verstehst direkt, was der Code macht, denn durch die sprechenden Namen von Methoden und Variablen ist es fast so zu lesen wie normaler Text.
 
Ach ja - neben dieser Vorgehensweise (mit der ich Dich hoffentlich nicht verwirrt habe): Diese Optimierung, dass eine Summe direkt mit berechnet wird, gibt es natürlich auch. Das geschieht dann aber über einen Objektorientierten Ansatz. Da Du noch mit statischen Elementen arbeitest, würde ich das jetzt nicht vorgreifen wollen.
 
ja oben habe ich es ja nur mit array
Oben ist es aber auch noch mit Eingabe in der Methode, was ebenso falsch ist :)

Aufgaben sind - gerade wenn es um die Anfänge geht - in der Regel so gestellt, dass Du sie wörtlich nehmen und Dich haarklein an die Aufgabenstellung halten kannst. Wenn da z. B. nichts von Eingabe steht, soll die Methode auch keine Eingaben abfragen.

Viele Hinweise hier sind dann fortgeschrittener Natur, aus denen Du lernen kannst. Das bedeutet nicht, dass Du sie in der Aufgabe auch verwenden darfst.

Mal der Reihe nach:
Erstellen sie die Klasse Functionality.java und bearbeiten sie die folgende aufgabe.
Führt zu einer Datei Functionality.java mit dem Inhalt
Java:
public class Functionality { 
}
Die Datei kann bereits übersetzt werden.

Implementieren sie eine static public methode mit namen "containsMean",
welche ein array vom typ int erhält und einen boolean zurück gibt.
Führt zu einer Datei Functionality.java mit dem Inhalt
Java:
public class Functionality {
    public static boolean containsMean(int[] werte) {
    }
}
Die Datei kann nicht übersetzt werden, da containsMean etwas zurückliefern soll. Daher spendieren wir der Methode erstmal noch ein return. Wir geben einfach mal false zurück, als Platzhalter:
Java:
public class Functionality {
    public static boolean containsMean(int[] werte) {
        return false;
    }
}
Als nächstes werden die Anforderungen genannt, die diese Methode erfüllen soll. Ich formuliere die mal als Liste:
  1. Die Methode soll den Mittelwert der Elemente aus dem Array berechnen.
  2. Der Mittelwert soll auf eine Ganzzahl gerundet werden.
  3. Es wird true zurückgegeben, wenn der abgerundete Mittelwert im Array selbst enthalten ist.
  4. Falls das Array null ist, wird false zurückgegeben.
  5. Falls das Array nicht mindestens ein Element besitzt, wird false zurückgegeben.
  6. Sollte der Mittelwert nicht im Array enthalten sein, wird false zurückgegeben.
Bei 2 stellt sich die Frage nach der Rundung: soll immer abgerundet oder immer aufgerundet oder soll bei 0,5 aufgerundet, darunter abgerundet werden? Das wäre nun eine Rückfrage an den Aufgabensteller. Gehen wir mal davon aus, dass Du immer abrunden sollst.

Natürlich willst Du Deine Methode auch testen, daher spendierst Du Deiner Functionality-Klasse eine main-Methode (wenn Du bereits mit mehreren Klassen gearbeitet hast, wäre es besser, diese in eine separate Klasse auszulagern, aber wir bleiben mal beim einfachen Fall). In der main-Methode willst Du nun prüfen, ob die Methode das macht, was sie machen soll.

Da Du weißt, was die Methode bei welcher "Eingabe" liefern soll, kannst Du für jeden der Punkte 3 bis 6 mindestens einen Fall konstruieren:

zu 3: {1} -> true; {1, 2} -> true; {1, 2, 3} -> true
zu 4: null -> false
zu 5: {} -> false
zu 6: {1, 4} -> false, {2,6} -> false

Das kannst Du in Code gießen:
Java:
    public static void main(String[] args) {
        if (!containsMean(new int[]{1})) {
            System.err.println("Für {1} wurde true erwartet, aber false wurde geliefert");
            System.exit(1);
        }
        if (!containsMean(new int[]{1, 2})) {
            System.err.println("Für {1, 2} wurde true erwartet, aber false wurde geliefert");
            System.exit(1);
        }
        if (!containsMean(new int[]{1, 2,3})) {
            System.err.println("Für {1, 2, 3} wurde true erwartet, aber false wurde geliefert");
            System.exit(1);
        }
        if (containsMean(null)) {
            System.err.println("Für null wurde false erwartet, aber true wurde geliefert");
            System.exit(1);
        }
        // usw.
        System.out.println("Tests erfolgreich durchgeführt.");
    }
Natürlich ist der Code hier etwas umständlich und unsauber, aber für einen Anfänger soll es ja noch nachvollziehbar sein. Wenn Du Lust hast, kannst Du Dich ja mal an einer Umstrukturierung (Refactoring) versuchen, Tipps hast Du dazu ja bekommen.

Wenn Du jetzt das Programm ausführst, bekommt Du von diesem erstmal einen Fehler ausgegeben, weil containsMean ja nur false liefert. Jetzt kannst Du Deine containsMean-Methode implementieren und nach jedem Ausführen werden alle Testfälle automatisch überprüft. Natürlich kannst Du weitere hinzufügen (negative Zahlen z. B.). Wenn "Tests erfolgreich durchgeführt" ausgegeben wird und Dir nichts mehr einfällt, wie Du noch einen Fall konstruieren könntest, damit ein Fehler auftritt, arbeitet Deine Methode vermutlich so, wie sie soll :)
 
Meiner Meinung nach nicht wirklich. Aber ich bringe jetzt ein paar Dinge mit rein, die evtl. etwas fortgeschrittener sind. Du scheinst aber sehr interessiert zu sein und daher will ich versuchen, Dir diese Dinge zu erläutern.

Es handelt sich hier um eine kleine Aufgabe, d.h. es ist leicht, tolle Optimierungen zu haben. In diesem Fall berechnest Du die Summe direkt bei der Eingabe. Das kann man auf jeden Fall so machen, aber ist eher unüblich.

Was man im Bereich Clean Code (= möglichst sauberen Code schreiben - dahinter verbergen sich viele einzelne Punkte) hier eher erwarten würde, wäre eine klare Auftrennung:

- Eine Methode, die nichts anderes macht, als x Integer Werte einzulesen und dann in einem Array zurück zu geben. Also z.B. so eine Signatur verwendet: int[] getIntegersFromUser(final int count) (das final kannst Du Dir wegdenken. Das wird von Manchen gerne genommen, damit klar ist: Am Parameter selbst ändere ich nichts - und so prüft das auch der Compiler.)
Diese Methode würde also ein neues int[] Array für count Elemente erzeugen und dann in einer Schleife diese Werte vom Anwender abfragen. (Und keine Summe berechnen!)
- Dann könnte man die Summe der Werte in einer Methode ermitteln: int getSum(final int[] values).
Also wieder eine Schleife, die über alle Werte drüber geht und aufaddiert. (Das Array alleine reicht als Parameter, die Anzahl benötigt man nicht.)
- Dann könnte man eine Methode haben, die den Mittelwert berechnet: int getMean(final int[] values). Diese Methode ist relativ einfach, denn diese berechnet die Summe / Anzahl, also ein einfaches return getSum(values) / values.length;
- dann könnte man eine Methode haben, die prüft, ob ein Wert in dem Array enthalten ist. Also sowas wie boolean conatins(final int[] values, final int searchValue). Wieder eine Schleife, Code dafür hast Du ja prinzipiell.
- Die eigentliche Methode, nach der gefragt ist, lässt sich dann mit den vorhandenen Methoden sehr gut schreiben....

Ich habe jetzt den Weg beschritten von einzelnen kleine Implementationen bis hin zur Lösung. Das geht aber auch anders herum. Man kann sich überlegen, was man braucht:
Das Programm soll machen:
- Hole Anzahl der Zahlen vom Anwender
- Frage die Zahlen ab
- Mach die gewünschte Prüfung
- Gib das Ergebnis aus.

Das kann man dann so wie es ist als Code schreiben:

Code:
int count = getCountFromUser();
int[] values = getIntArrayFromUser(count);
boolean result = containsMean(values);
showResultToUser(result);
Jetzt hast du das, was Dein Programm machen soll schon schön aufgeschrieben. Und jetzt fehlen natürlich die ganzen Funktionen und die schreibst du als nächstes. Das wäre dann ein Ansatz, der dann von "Top to Bottom" vorgeht während der erste Ansatz gerne als "Bottom up" bezeichnet wird...

Und wenn Du Dir den Code anschaust, wenn Du sowas schreibst an Code: Du verstehst direkt, was der Code macht, denn durch die sprechenden Namen von Methoden und Variablen ist es fast so zu lesen wie normaler Text.


vielen dank!!!
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben