# Wetterstation



## Aitschigiga (14. Jan 2019)

Ich muss folgendes machen und weiß nicht wie, wäre nett wenn ihr mir helft

Schreiben Sie eine Software für eine Messdatenauswertung für eine Wetterstation die Temperaturwerte inkl. Zeit und Ort aufzeichnet.

Die Temperaturwerte werden in einer eigenen Klasse _Temperaturmesswert _gespeichert:

Diese Klasse enthält folgende Variablen:

- double temperatur
- String ort
- int stunde
- int minute
Die Werte sollen über den Konstruktor initialisiert werden und über Getter Methoden abgefragt werden.


Zur Auswertung der Messdaten schreiben Sie eine Klasse _MesswertAuswertung_.

Diese Klasse besteht aus:

- Einer ArrayList _temperaturMesswerte_ in der die Temperaturwerte gespeichert sind.

- addTemperaturMesswert(Temperaturmesswert t)
Fügt einen Temperaturmesswert hinzu

- getTemperaturmesswert(int index)
gibt den Temperaturmesswert mit dem dem Index index zurück. Wenn es keinen Wert mit dem Index gibt soll null zurückgegeben werden. 

- getMaxTemperatur()
gibt den Temperaturmesswert  mit der maximalen Temperatur zurück.

- getMinTemperatur()


gibt den Temperaturmesswert  mit der minimalen Temperatur zurück.



- getMaxTemperatur(String Ort)


gibt den Temperaturmesswert  mit der maximalen Temperatur für einen bestimmten Ort zurück. Existiert der angegebene Ort nicht soll null zurückgegeben werden.



- getMinTemperatur(String Ort)


gibt den Temperaturmesswert  mit der minimalen Temperatur für einen bestimmten Ort zurück. Existiert der angegebene Ort nicht soll null zurückgegeben werden.


----------



## VfL_Freak (14. Jan 2019)

Moin,
poste doch mal (mit Code-Tags) was Du bisher hast !! 
VG Klaus


----------



## Aitschigiga (14. Jan 2019)

Naja ich hab in der ersten Klasse folgendes und in der zweiten Klasse sehe ich mich gar nicht hinaus. Und niicht wundern ich bin neu im Programmieren


```
public class Temperaturmesswert {
    double temperatur;
    String ort;
    int stunde;
    int minute;
 
    public void TemperaturMesswert(double temperatur, String ort, int stunde, int minute) {
        this.temperatur = temperatur;
        this.ort = ort;
        this.stunde = stunde;
        this.minute = minute;
     
}
 
}
```

so?


----------



## Javinner (14. Jan 2019)

Bitte den Code in Code-Tabs setzen [code=Java]Dein Code[/code]


----------



## VfL_Freak (14. Jan 2019)

und danach versuch mal, die Methodendeklarationen vom Aufgabenzettel in Deinen Code zu übernehmen!


----------



## Javinner (14. Jan 2019)

Aitschigiga hat gesagt.:


> Naja ich hab in der ersten Klasse folgendes und in der zweiten Klasse sehe ich mich gar nicht hinaus


Der Aufgabenstellung nach soll die Klasse `Temperaturmesswert` ein Element der Menge (Klasse) `MesswertAuswertung` werden. Oder einfach gesagt, der Apfelkorb hat viele Apfel


----------



## Aitschigiga (14. Jan 2019)

Und wie kann ich die ganzen Methoden in die Klasse MesswertAuswertung einfügen?


----------



## Javinner (14. Jan 2019)

Aitschigiga hat gesagt.:


> Und wie kann ich die ganzen Methoden in die Klasse MesswertAuswertung einfügen?


Zur Auswertung der Messdaten schreiben Sie eine Klasse _MesswertAuswertung_.
Diese Klasse besteht aus:

- Einer *ArrayList  *_temperaturMesswerte
https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html_


----------



## Aitschigiga (14. Jan 2019)

Also im Prinzip so ? 

```
import java.util.ArrayList;
public class MesswertAuswertung {
    ArrayList<Temperaturmesswert>temperaturMesswerte = new ArrayList<>();
   
   }
```


----------



## Javinner (14. Jan 2019)

@Aitschigiga 
Jepp, jetzt noch die Getter für die Klasse TemperaturMessung und die Klasse MesswertAuswertung, so dass du an die Attribute der jeweiligen Klasse rankommst und dann noch das Aufgabenspezifische


----------



## Aitschigiga (14. Jan 2019)

Ich hab das jetzt so erweitert aber es funktioniert nicht ganz



```
public class Temperaturmesswert {
    double temperatur;
    String ort;
    int stunde;
    int minute;
    public double getTemperatur() {
        return temperatur;
    }
    public String getOrt() {
        return ort;
    }
    public int getStunde() {
        return stunde;
    }
    public int getMinute() {
        return minute;
    }
    public static void add(Temperaturmesswert t) {
    }
}
```


```
import java.util.ArrayList;
public class MesswertAuswertung {
    static int max = 0;
    int min = 0;
    Temperaturmesswert temp = new Temperaturmesswert();
    ArrayList<Temperaturmesswert> temperaturMesswerte;
    public void addTemperaturMesswert(Temperaturmesswert t) {
        Temperaturmesswert.add(t);
    }
    public static int getTemperaturmesswert(int index) {
        for (int i = t.temperaturmesswert.size(); i++) {
            index  ++;
        }
        return index;
    }
    public static int getMaxTemperatur() {
        for (int i = 0; i < temp.temperatur; i++) {
        Durchschnitt = Durchschnitt + temp.temperatur[i];
            if (temp.temperatur[i] > max) {
                max = temp.temperatur[i];
            }
        }
        return 0;
    }
    public static int getMinTemperatur() {
        return 0;
    }
    public static int getMaxTemperatur(String Ort) {
        Temperaturmesswert temp = new Temperaturmesswert();
        return 0;
    }
    public static String getMinTemperatur(String Ort) {
        return Ort;
    }
}
```


----------



## Javinner (14. Jan 2019)

In der Klasse Temperaturmesswert fehlt der Konstruktor, den die Daten wie Temperatur, Ort, Stunde und Minute
müssen mit der Instanz der Klasse initialisiert werden. Ebenso würde ich die ArrayList der Klasse MesswertAuswertung beim Aufruf (Konstruktor) initialisieren, so dass es zu keiner Exception kommt. 

Wie der Methodenname bereits verrät, sollst du den Temperaturmesswert an Stelle von index zurückgeben, sprich den Platz in der Reihe in der ArrayList

```
public static int getTemperaturmesswert(int index) {
    for (int i = t.temperaturmesswert.size(); i++) {
        index  ++;
    }
    return index;
}
```


```
public static int getMaxTemperatur() {
        for (int i = 0; i < temp.temperatur; i++) {
        Durchschnitt = Durchschnitt + temp.temperatur[i];
            if (temp.temperatur[i] > max) {
                max = temp.temperatur[i];
            }
        }
        return 0;// Egal wie, wird Null geliefert
}
```

?

```
public static String getMinTemperatur(String Ort) {
        return Ort;
}
```


----------



## Aitschigiga (14. Jan 2019)

Ok Danke!


----------



## mihe7 (14. Jan 2019)

Aitschigiga hat gesagt.:


> ```
> public class MesswertAuswertung {
> static int max = 0;
> int min = 0;
> ```


Wenn hier nicht die pure Verzweiflung zum Ausdruck kommt...


----------



## Xyz1 (16. Jan 2019)

Mir war gerade bisschen langweilig :


```
import java.util.ArrayList;
import java.util.Comparator;
import java.util.stream.Collectors;

/**
 */
public class MesswertAuswertung {
    public static void main(String[] args) {
        MesswertAuswertung m = new MesswertAuswertung();

        m.addTemperaturMesswert(
                new Temperaturmesswert(1, "hier1", "12"));
        m.addTemperaturMesswert(
                new Temperaturmesswert(3, "hier2", "13"));
        m.addTemperaturMesswert(
                new Temperaturmesswert(2, "hier3", "14"));

        System.out.println(m.getTemperaturmesswert(2).getWo());
        System.out.println(m.getMaxTemperatur());
        System.out.println(m.getTemperatur("hier1"));
    }
    ArrayList<Temperaturmesswert> temperaturMesswerte = new ArrayList<>();

    void addTemperaturMesswert(Temperaturmesswert t) {
        temperaturMesswerte.add(t);
    }

    Temperaturmesswert getTemperaturmesswert(int index) {
        Temperaturmesswert g = temperaturMesswerte.get(index);
        return g;
    }

    float getMaxTemperatur() {
        return temperaturMesswerte.stream().max(Comparator.comparing(Temperaturmesswert::getTemperatur)).orElseThrow().getTemperatur();
    }

    float getMinTemperatur() {
        return temperaturMesswerte.stream().min(Comparator.comparing(Temperaturmesswert::getTemperatur)).orElseThrow().getTemperatur();
    }

    float getTemperatur(String ort) {
        return temperaturMesswerte.stream().filter(t -> ort.equals(t.getWo())).collect(Collectors.collectingAndThen(Collectors.toList(), l -> l.get(0).getTemperatur()));
    }
}

class Temperaturmesswert {
    float temperatur;
    String wo;
    String zeit;

    public Temperaturmesswert(float t, String w, String z) {
        temperatur = t;
        wo = w;
        zeit = z;
    }

    float getTemperatur() {
        return temperatur;
    }

    String getWo() {
        return wo;
    }

    String getZeit() {
        return zeit;
    }
}
```


----------



## Xyz1 (17. Jan 2019)

Gibt es dafür


horstiii2 hat gesagt.:


> temperaturMesswerte.stream().filter(t -> ort.equals(t.getWo())).collect(Collectors.collectingAndThen(Collectors.toList(), l -> l.get(0).getTemperatur()))


noch eine kürzere Schreibweise/bessere, um den Temperaturwert an einem Ort ("wo") herauszufinden?

Weil mir das zu lange erscheint.  

(Btw. der obige Code enthält noch einige Fehler (Sichtbarkeit und Fehlerbehandlung usw))


----------



## httpdigest (17. Jan 2019)

Nicht unbedingt kürzer, aber du brauchst zumindest nicht in eine Liste collecten, nur um den ersten Eintrag zu holen, der auf das Filter-Prädikat matched. Dafür gibt es findFirst():

```
float getTemperatur(String ort) {
  return temperaturMesswerte
      .stream()
      .filter(t -> ort.equals(t.getWo()))
      .map(t -> t.temperatur)
      .findFirst()
      .orElseThrow();
}
```


----------



## mihe7 (17. Jan 2019)

@horstiii2 meinst Du?

```
temperaturMesswerte.stream()
    .filter(t -> ort.equals(t.getWo())
    .map(t -> t.getTemperatur())
    .findFirst();
```

@httpdigest war schneller...


----------



## Xyz1 (17. Jan 2019)

jo danke für eure Antworten, ich hatte danach gesucht (bei SO) - und es dann falsch adaptiert.  Ich denke, der te könnte seine Aufgabenstellungen jetzt selber lösen, falls nicht, dann Dich, @Aitschigiga , nochmal hier melden.


----------

