Java 8如何判断Double值是否处于指定区间？

Great question! While Java 8 doesn’t offer a direct DoubleStream equivalent to IntStream.rangeClosed() for this kind of range checking, there are several clean, idiomatic ways to categorize your double value into the Light/Moderate/Vigorous tiers without messy if/else blocks. Here are two solid approaches:

1. Use an Enum for Reusable, Maintainable Range Definitions #

This is my go-to solution for fixed range categories—it’s type-safe, easy to extend, and makes your intent crystal clear. Define an enum that encapsulates each intensity level and its range check logic:

import java.util.Arrays;
import java.util.function.Predicate;

public enum IntensityLevel {
    LIGHT(val -> val >= 0.0 && val < 3.0),
    MODERATE(val -> val >= 3.0 && val < 6.0),
    VIGOROUS(val -> val >= 6.0);

    private final Predicate<Double> rangeMatcher;

    IntensityLevel(Predicate<Double> rangeMatcher) {
        this.rangeMatcher = rangeMatcher;
    }

    // Method to resolve the intensity level from a double value
    public static IntensityLevel fromValue(double val) {
        return Arrays.stream(values())
                .filter(level -> level.rangeMatcher.test(val))
                .findFirst()
                .orElseThrow(() -> new IllegalArgumentException("Value out of valid range: " + val));
    }
}

To use this, simply call:

double val = 4.5;
IntensityLevel intensity = IntensityLevel.fromValue(val);
// Now you can use the enum for logic, logging, etc.
System.out.println("Intensity: " + intensity.name()); // Outputs MODERATE

This approach keeps all your range logic in one place—if you ever need to adjust the thresholds, you only modify the enum, not scattered if/else statements.

2. Stream of Range Checks for One-Off Scenarios #

If you don’t need a reusable enum (e.g., this is a one-time check), you can create a stream of entry pairs (label + condition) and filter to find the matching category:

import java.util.Map;
import java.util.Optional;
import java.util.stream.Stream;

public class IntensityChecker {
    public static Optional<String> getIntensity(double val) {
        return Stream.of(
                Map.entry("Light", val >= 0.0 && val < 3.0),
                Map.entry("Moderate", val >= 3.0 && val < 6.0),
                Map.entry("Vigorous", val >= 6.0)
        )
        .filter(Map.Entry::getValue)
        .map(Map.Entry::getKey)
        .findFirst();
    }
}

Usage example:

double val = 7.2;
Optional<String> intensity = IntensityChecker.getIntensity(val);
intensity.ifPresent(level -> System.out.println("Intensity: " + level)); // Outputs Vigorous

The Optional here is useful for handling values that fall outside your defined ranges (like negative numbers) gracefully, instead of throwing an exception.

A Quick Note on Double Precision #

Keep in mind that floating-point values can have precision quirks (e.g., a calculation that should result in 3.0 might actually be 2.9999999999999996). If this is a concern, adjust your conditions to account for a small epsilon, like:

val >= 3.0 - 1e-9 && val < 6.0

This ensures minor precision errors don’t incorrectly categorize your value.

内容的提问来源于stack exchange，提问作者gene b.