Java中根据from、to参数获取FOO实体value的最优实现方式

嘿，我来帮你梳理下这两个问题的解决思路，结合你给出的FOO代码，咱们一步步来：

1. 给定实体其他属性时，获取实体值的最简单方法 #

其实这个问题的答案很直接——给FOO类添加Getter方法就好！这是Java里最符合规范、也最易懂的做法。

你提供的FOO代码里只定义了构造器和静态实例，但没有对外暴露属性的访问方法，所以第一步先补全Getter：

public class FOO {
    private long from;
    private long to;
    private String value;

    public FOO(long from, long to, String value) {
        this.from = from;
        this.to = to;
        this.value = value;
    }

    // 新增Getter方法，让外部能访问属性
    public long getFrom() { return from; }
    public long getTo() { return to; }
    public String getValue() { return value; }

    // 原有的静态实例与列表（注意要把列表初始化放在静态代码块里，不然会编译报错）
    public static FOO ONE = new FOO(6000000, 7000000, "60 - 70");
    public static FOO TWO = new FOO(7000000, 8000000, "70 - 80");
    public static FOO THREE = new FOO(8000000, 9000000, "80 - 90");
    private static List<FOO> VALID_FOOS = new ArrayList<>();

    static {
        VALID_FOOS.add(ONE);
        VALID_FOOS.add(TWO);
        VALID_FOOS.add(THREE);
    }
}

这样之后，不管你手里有FOO的实例，还是想直接用静态实例，获取值都超简单：

• 比如获取ONE的value：FOO.ONE.getValue()
• 比如获取TWO的from值：FOO.TWO.getFrom()

完全不需要复杂的逻辑，直接通过Getter访问就是最简洁的方式。

2. 以from、to为参数获取对应value：迭代之外的优雅实现 #

迭代查找是最基础的实现方式，但确实有更优雅、可读性更强的方案，甚至还能优化性能：

基础迭代实现（没问题但不够优雅） #

先贴一下基础的迭代写法，作为对比：

public static String getValueByFromTo(long from, long to) {
    for (FOO foo : VALID_FOOS) {
        if (foo.getFrom() == from && foo.getTo() == to) {
            return foo.getValue();
        }
    }
    return null; // 没找到可以返回null，或者抛出IllegalArgumentException之类的异常
}

更优雅：Java 8+ Stream API #

用Stream的链式调用，代码更简洁，逻辑也一目了然：

public static String getValueByFromToWithStream(long from, long to) {
    return VALID_FOOS.stream()
            .filter(foo -> foo.getFrom() == from && foo.getTo() == to)
            .map(FOO::getValue)
            .findFirst()
            .orElse(null); // 没找到时的默认值，也可以用orElseThrow()抛异常
}

这种写法把“过滤-转换-获取结果”的逻辑拆解得很清晰，比循环迭代更符合现代Java的编码风格。

性能优化：提前构建缓存Map（适合频繁查询场景） #

如果这个查询操作会被频繁调用，那可以提前把所有FOO的(from, to)和value映射成一个Map，这样每次查询都是O(1)的时间复杂度，性能更好：

// 静态缓存Map，类加载时初始化一次
private static final Map<AbstractMap.SimpleEntry<Long, Long>, String> FOO_CACHE;

static {
    FOO_CACHE = VALID_FOOS.stream()
            .collect(Collectors.toMap(
                    foo -> new AbstractMap.SimpleEntry<>(foo.getFrom(), foo.getTo()),
                    FOO::getValue
            ));
}

// 用Map查询的方法
public static String getValueByFromToWithMap(long from, long to) {
    return FOO_CACHE.get(new AbstractMap.SimpleEntry<>(from, to));
}

这里用AbstractMap.SimpleEntry作为Map的键，来存储from和to的组合。如果你的项目里有Guava或者Apache Commons这类工具库，也可以用它们提供的Pair类来替代SimpleEntry，代码会更整洁一点。

内容的提问来源于stack exchange，提问作者Rpj