Hallo zusammen,
ich bin gerade dabei, mir Streams beizubringen. Nachdem ich Lambdas nun verstanden und selbstständig anwenden und die Vorteile erkennen kann, hadere ich gerade dabei mit der richtigen Verwendung von Streams.
In meinem aktuellen Fall habe ich folgende Situtation:
Klasse MeasurementPoint, beschreibt einen Messpunkt in meinen Daten
Klasse ChannelPoint, beschreibt einen Messlauf in meinen Daten, ein Kanalpunkt besteht also aus mehreren Measurementpoints, je nach Anzahl der Messfühler:
Dazu habe ich dann jetzt einen Check, der auf den eingelesenen ChannelPoints arbeiten soll.
Bei diesem speziellen Check geht es darum, dass die Temperatur für einen Zeitraum t zwischen den Temperaturen Tmin und Tmax sich befinden muss.
Ich hätte das jetzt auf zwei vom Interface Check implementierenden Klassen gelöst. Der erste Check überprüft also nur, welche ChannelPoints zwischen Tmin und Tmax liegen.
TempMinMaxCheck:
Dazu das Interface Check:
Nur wie müsste ich denn hier jetzt an der gekennzeichneten Quellcode-Stelle den Stream schreiben? Lösen könnte ich das über eine ForEach und if Kaskade, denke aber, dass soetwas ja prädestiniert für Streams ist und damit dann auch deutlich schöner zu lesen ist.
ich bin gerade dabei, mir Streams beizubringen. Nachdem ich Lambdas nun verstanden und selbstständig anwenden und die Vorteile erkennen kann, hadere ich gerade dabei mit der richtigen Verwendung von Streams.
In meinem aktuellen Fall habe ich folgende Situtation:
Klasse MeasurementPoint, beschreibt einen Messpunkt in meinen Daten
Java:
public class MeasurementPoint {
private final LocalDateTime timestamp;
private final Double temperature;
public MeasurementPoint(LocalDateTime timestamp, Double temperature) {
this.timestamp = timestamp;
this.temperature = temperature;
}
public LocalDateTime getTimestamp() {
return timestamp;
}
public Double getTemperature() {
return temperature;
}
@Override
public String toString() {
return "MeasurementPoint{" +
"timestamp=" + timestamp +
", temperature=" + temperature +
'}';
}
}
Klasse ChannelPoint, beschreibt einen Messlauf in meinen Daten, ein Kanalpunkt besteht also aus mehreren Measurementpoints, je nach Anzahl der Messfühler:
Java:
public class ChannelPoint {
private final LocalDateTime timestamp;
private final List<MeasurementPoint> measurementPoints;
public ChannelPoint(LocalDateTime timestamp, List<MeasurementPoint> measurementPoints) {
this.timestamp = timestamp;
this.measurementPoints = measurementPoints;
}
public Double getTemperatureMax() {
Optional<MeasurementPoint> result = measurementPoints.stream()
.max(Comparator.comparing(MeasurementPoint::getTemperature));
return result.isPresent() ? result.get().getTemperature() : 0.0;
}
public Double getTemperatureMin() {
Optional<MeasurementPoint> result = measurementPoints.stream()
.min(Comparator.comparing(MeasurementPoint::getTemperature));
return result.isPresent() ? result.get().getTemperature() : 0.0;
}
public List<MeasurementPoint> getMeasurementPoints() {
return measurementPoints;
}
@Override
public String toString() {
return "ChannelPoint{" +
"timestamp=" + timestamp +
", measurementPoints=" + measurementPoints +
'}';
}
}
Dazu habe ich dann jetzt einen Check, der auf den eingelesenen ChannelPoints arbeiten soll.
Bei diesem speziellen Check geht es darum, dass die Temperatur für einen Zeitraum t zwischen den Temperaturen Tmin und Tmax sich befinden muss.
Ich hätte das jetzt auf zwei vom Interface Check implementierenden Klassen gelöst. Der erste Check überprüft also nur, welche ChannelPoints zwischen Tmin und Tmax liegen.
TempMinMaxCheck:
Java:
public class TempMinMaxCheck implements Check{
private final Profile profile;
private final String checkName;
private final Double tempMin;
private final Double tempMax;
private final Duration duration;
private ChannelPoint start;
private ChannelPoint end;
public TempMinMaxCheck(Profile profile, String checkName, Double tempMin, Double tempMax, Duration duration) {
this.profile = profile;
this.checkName = checkName;
this.tempMin = tempMin;
this.tempMax = tempMax;
this.duration = duration;
}
@Override
public boolean execute() {
// ---- hier soll dann über Stream überprüft werden, welche Punkte in dem Temperaturbereich liegen, gleichzeitig soll hier dann ChannelPoint start und ChannelPoint end gesetzt werden. start ist der erste ChannelPoint, bei dem alle MeasurementPoints größergleich Tmin sind, end entsprechend der ChannelPoint, bei dem mindestens ein MeasurementPoint vom ChannelPoint größer Tmax oder aber kleiner Tmin ist.
);
return false;
}
@Override
public String getCheckName() {
return null;
}
@Override
public ChannelPoint getStart() {
return null;
}
@Override
public ChannelPoint getEnd() {
return null;
}
}
Dazu das Interface Check:
Java:
public interface Check {
boolean execute();
String getCheckName();
ChannelPoint getStart();
ChannelPoint getEnd();
}
Nur wie müsste ich denn hier jetzt an der gekennzeichneten Quellcode-Stelle den Stream schreiben? Lösen könnte ich das über eine ForEach und if Kaskade, denke aber, dass soetwas ja prädestiniert für Streams ist und damit dann auch deutlich schöner zu lesen ist.