Fehler bei .contains auf Double Liste

[Zaphot42]

Hallo Leute,
ich bin ziemlich neu in Java und habe deshalb noch nicht viel Ahnung von der Sprache habe aber schon ein Problem das ich selber nicht lösen kann

Es geht um folgendes Programm:

import java.util.List;
import java.util.Locale; 
import java.util.Arrays;  
import java.util.Scanner;
import java.util.regex.Pattern;
import static java.lang.System.out;
import static java.lang.System.in;

public final class Aufgabe3 {
    private Aufgabe3() { }

    private static final Scanner EINGABE = new Scanner(in);
    private static final Pattern NOTE = Pattern.compile("\\d\\D\\d");

    public static void main(final String[] args) {
        Locale.setDefault(Locale.GERMANY);

        out.println("Noten im Format Ganze,Zehntel "
                    + "oder Ganze.Zehntel eingeben (Ende mit Strg-D):");

        Double[] noten_arr =  {1.0, 1.3, 1.7,  2.0, 2.3, 2.7, 3.0, 3.3, 3.7, 4.0, 5.0};//gueltige Noten
        int[] noten_count = new int[11];//zum zaehlen der noten
        List<Double> noten_list = Arrays.asList(noten_arr);//Zum einfachen suchen mit .contains als List


        while (EINGABE.hasNext(NOTE)) {
            String note = EINGABE.next(NOTE);
            int ganzeNote = note.charAt(0) - '0';
            char komma = note.charAt(1);
            int zehntelNote = note.charAt(2) - '0';
            double note_dbl = ganzeNote + ((double)zehntelNote)*0.1;//zerstueckelte note in double konvertieren
            
           //pruefen ob eingegebene Note in Liste von gueltigen noten steht    
           if(noten_list.contains(note_dbl)){
              noten_count[noten_list.indexOf(note_dbl)]++;//Anzahl variable der eigegebenen Note inkrementieren
           }else{
              out.printf("Unzulaessige Note %s wird ignoriert!\n",note);
           }
           
        } // while
       
       //Beruecksichtigte Noten berechnen
       int sum = 0;
       for (int i : noten_count) { //foreach über noten_count (addiert die Anzahl aller noten) 
           sum += i;
       }
       out.printf("\nAnzahl beruecksichtigter Noten: %d",sum);
       
       //Beste Note berechnen
       for (int j=0;j<noten_count.length;j++) {
           if(noten_count[j]>0){
             out.printf("\nBeste Note: %.1f", noten_list.get(j));
             break;
           }
       }
       
       //Schlechteste Note berechnen
      for (int k=(noten_count.length-1);k>0;k--) {
           if(noten_count[k]>0){
             out.printf("\nSchlechteste Note: %.1f", noten_list.get(k));
             break;
           }
       }
       
       //Durchschnitt berechnen
       double durchschnitt=0.0;
       for (int l=0;l<noten_count.length;l++){
          durchschnitt+=noten_list.get(l)*noten_count[l];
       }
       durchschnitt/=sum;
       out.printf("\nDurchschnitt: %.1f",durchschnitt);
       
       //Durchfallquote ausgeben
       double dfQoute= ((double)noten_count[noten_count.length-1]*100)/(double)sum;
       out.printf("\nDurchfallqoute: %.1f%%\n",dfQoute);
    
    } // main
}

Dass Programm soll einfach beliebig viele Noten einlesen und am Ende eine Statistik ausgeben.
Nur die Noten die in der Liste sind gültig, bei allen anderen soll ausgegeben werden dass die Note ungültig ist.
Das Programm funktioniert genau so wie es soll außer dass es sagt "ungültige note" wenn ich 1.7 eingebe. Obwohl 1.7 in der Liste der gültigen noten steht.
Bei allen anderen Noten aus der Liste funktioniert es Tadellos nur die 1.7 macht, aus mir unerfindlichen Gründen, Probleme.
Ich habe keine Ahnung was das Problem ist..

Wäre schön wenn ihr erklären könnt wo der Fehler liegt.

MfG
Zaphot42

 

[eRaaaa]

Weil du nicht genau auf 1.7 prüfst. Schau dir doch mal an was du bei [c]System.out.println(note_dbl);[/c] erhälst bei der Eingabe von 1.7.
Wieso machst du dir das Leben eig. so schwer und umständlich mit dem Umrechnen?
Scanner hat doch die Methode

nextDouble()

, ansonsten gäbe es auch noch [c]Double.parseDouble(note)[/c]

 

[Gelöschtes Mitglied 6946]

Das Problem ist, dass Fließkommazahlen nicht unendlich genau sein können und an irgendeiner Stelle Rundungsfehler auftreten können. Da du die Zahl, die gesucht ist, zusammenrechnest, kann genau das passieren, so wid statt 1.7 eben 1.666666666669 oder 1.70000000001 oder sowas in der Art rauskommen und das ist eben nicht gleich 1.7. Deshalb sollte man beim Vergleich von Fließkommazahlen ein Interval checken, also so in der Art:

double eps = 1e-6;
boolean noteFound = false;
for (int i = 0; i < noten_list.size(); i++) {
    if (Math.abs(note_dbl - noten_list[i]) > eps) {
        noten_count[i]++;
        noteFound = true;
        break;
    }
}

Allerdings denke ich gäbe es sicher schickere Wege, wie man das Problem lösen könnte, so dass man dieses Fließkommazahlproblem ganz umgeht. Beispielsweise könnte man die Überprüfung der Eingabe auf String-Level durchführen, also "1.7" und Konsorten, man könnte ne Map nutzen, in der die Noten-Strings die Schlüssel sind und die Zählvariable ist der Wert dahinter oder sonstwas. Aber auf solche Dinge stößt du bestimmt auch mit der Zeit

 

[Zaphot42]

Ihr habt recht es entsteht ein Rundungsfehler
Habe das problem jetzt behoben!
Besten Dank für die Hilfe. :toll:

 

[Andi_CH]

Wir umgehen im aktuellen Projekt das Problem indem wir mit int rechnen (das hat auch noch andere Gründe, aber die sind hier nicht relevant)

Die Eingaben (Meter) werden alle mit 10'000 multiplizert und somit sind wir auf 0.1mm genau

Bei den Noten könnte der Faktor eine 10 sein, denn wird wohl nur mit einer Kommastellte gerechnet.

Einfach so als Hinweis - der Faktor muss natürlich eine globale Konstante sein Ziffern gehören nicht in den Code ;-) Die Umstellung hier von 1mm Genauigkeit auf 0,1mm dauerte keine Minute