你可以使用switch语句返回一个包含值的对象。这里我使用record作为一个不可变类。它也可以是一个常规类。

record Data<T> (T A, T B, T C) {}

Data<Integer> d = getValues(10.6, 10,20,30);
System.out.println(d);
Data<String> d2 = getValues(9.3, "One","Two","Three");
System.out.println(d2);

印刷品

Data[A=30, B=10, C=20]
Data[A=Two, B=One, C=Three]

• 将q转换为int将选择正确的大小写
• 然后返回与q的值相关联的对象
• 如果q超出范围，将引发异常。

public static <T> Data<T> getValues(double q, T x, T y, T z) {           
   return switch((int)(q/5)) {
         case 0 -> new Data<>(y,x,z);
         case 1 -> new Data<>(y,x,z);
         case 2 -> new Data<>(z,x,y);
         case 3 -> new Data<>(z,y,x);
         case 4 -> new Data<>(y,z,x);
         case 5 -> new Data<>(x,z,y);
         default -> throw new IllegalArgumentException("Argument out of range q = " + q);
   
     };
}

假设x、y和z的值在某种程度上是恒定的，您可以创建一个Map，将q值转换为A、B、C的特定赋值。

Map<Long,Assignment> map = new HashMap<>();
map.put(0, new Assignment(x,y,z));
map.put(1, new Assignment(y,x,z));
...
map.put(5, new Assignment(x,z,y));

public Assignment getAssignment(double q) {
  // out of range values of q return null
  return map.get((long)Math.floor(q));
}

让我建议一个简单的数据结构：

public class Foo {
    private static final List<Foo> library;
    static {
        library = new ArrayList<Foo>();
        library.add(new Foo(x, y, z, 0, 1));
        library.add(new Foo(y, x, z, 1, 2));
        library.add(new Foo(z, x, y, 2, 3));
        library.add(new Foo(z, y, x, 3, 4));
        library.add(new Foo(y, z, x, 4, 5));
        library.add(new Foo(x, z, y, 5, 6));
    };
    public static Foo get(double val) {
        for(Foo foo : library) {
            if(foo.lower <= val && foo.upper > val)
                return foo;
        }
        return null;
    }
    public final Object A,B,C;
    private final double lower,upper;
    private Foo(Object A, Object B, Object C, double lower, double upper) {
        this.A = A;
        this.B = B;
        this.C = C;
        this.lower = lower;
        this.upper = upper;
    }
}

然后你就可以像这样接受你的价值观

Foo foo = Foo.get(1.5d);
foo.A; // y