Question

我有以下with('results', $results)代码-

compact

在这段代码中，我想从整数对组合中获取主题名称，例如python，def get_subject_from_stream_id_and_subject_id(stream_id, subject_id): #(stream_id, subject_id): ("subject_name") return { (1, 1): "Accounts", (1, 2): "English", (1, 3): "Organization of Commerce", (2, 1): "Physics", (2, 2): "English", (2, 3): "Biology" }.get((stream_id, subject_id), "None")，例如stream_id用于subject_id。它是使用(1, 2)实现的。

我想在English中实现相同的代码。

有人可以在python tuple中用更好的方式写吗？

Java

谢谢。

Answer 1

我不喜欢重复建议Switching on a pair of `int`s中提出的解决方案。有两个原因：

该解决方案依赖于外部逻辑（Integer.valueOf()和String的切换），虽然可能性不大，但在将来的JDK版本中实现可能会有所不同
开关盒被设计为一系列if语句的简写。不是将输入映射到输出值的最佳解决方案。更好的解决方案是利用Map数据结构

我认为正确的解决方案将涉及某种Java Tuple。尽管JDK中没有Tuple，但是可以很容易地将其构造为用户定义的类。实际上，已经有一个SO答案：A Java collection of value pairs? (tuples?) 因此，如果我们将上述答案中的类用作Map键，则解决方案相当简单且可扩展性更高（例如，您可以从诸如文本文件或DB表之类的外部资源中加载地图）：

// initialized using instance initializer
Map<Pair<Integer, Integer>, String> streamIdAndSubjectIdMap = new HashMap<>()
{
    {
        put(new Pair(1, 1), "Accounts");
        put(new Pair(1, 2), "English");
        put(new Pair(1, 3), "Organization of Commerce");
    }
};

public String getSubjectFromStreamIdAndSubjectId(int streamId, int subjectId) {
    return streamIdAndSubjectIdMap.get(new Pair<>(streamId, subjectId));
}

Answer 2

就个人而言，我真的建议不要在这里使用switch语句，因为任何黑客（例如String串联）都只会使事情复杂化。但是，您可以重构此方法，以使用带有if语句的正则return表达式。

public static String getSubject(int streamId, int subjectId) {
    Pair<Integer> pair = Pair.of(streamId, subjectId);

    if (pair.equals(Pair.of(1, 1))) {
        return "Subject";
    }
    if (pair.equals(Pair.of(1, 2))) {
        return "English";
    }
    if (pair.equals(Pair.of(1, 3))) {
        return "Organization of Commerce";
    }
    if (pair.equals(Pair.of(2, 1))) {
        return "Physics";
    }
    if (pair.equals(Pair.of(2, 2))) {
        return "English";
    }
    if (pair.equals(Pair.of(2, 3))) {
        return "Biology";
    }

    return null;
}

至少在我看来，这看起来很干净，不需要使用if-else表达式。这里要注意的一件事是，Pair类需要针对equals和hashCode正确实现才能正常工作。下面是一个示例实现（很难扩展）：

public class Pair<T> {

    private T first;
    private T second;

    public static <T> Pair<T> of(T first, T second) {
        return new Pair<>(first, second);
    }

    private Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Pair<?> pair = (Pair<?>) o;
        return Objects.equals(first, pair.first) &&
                Objects.equals(second, pair.second);
    }

    @Override
    public int hashCode() {
        return Objects.hash(first, second);
    }
}

Answer 3

它并不总是推荐，但在您的情况下，我将使用嵌套的三元运算符。如果组合的数量超出示例中给出的数量，则此方法可能会导致代码混乱，无法读取。但是，如果您只有那些定义明确的案例：

public static String getSubjectFromStreamIdAndSubjectId(int stream_id, int subject_id) {
    return stream_id == 1 ?
            subject_id == 1 ? "Accounts" : 
            subject_id == 2 ? "English" : 
            subject_id == 3 ? "Organization of Commerce" : "None":
           stream_id == 2 ?
            subject_id == 1 ? "Physics" : 
            subject_id == 2 ? "English" : 
            subject_id == 3 ? "Biology" : "None":
           "None";
}

在Java中为整数对组合切换大小写实现

3 个答案: