Question

某些上下文：我正在解析一个会计分类帐，其account1和account2类型为int。每个都是[0,99999]范围内的数字。我有很多组合需要考虑。

理想情况下，我想使用像

这样的东西

switch (account1, account2){
    case (1,1):
        /*account1 is 1, account2 is 1*/
    case (2,1):
        /*account1 is 2, account2 is 1*/
}

等等。（我只需要考虑大约20种可能的组合）。

有没有办法在Java中实现这个目标？

我已经考虑了这个问题Storing number pairs in java

和可以构建一个IntPair类。也许如果我定义bool equals，那么我可以switch在一个实例上，以类似的方式切换java.lang.String。

Answer 1

唉，这在Java中是不可能的。您只能从Java版本7开启整数类型或 java.lang.String。（您无法通过覆盖equals和{来构建此功能到您自己的类型中来自hashCode）的{1}}。

但是可以激励你做一个黑客攻击：

java.lang.Object

我发现这是令人惊讶的可读性。

Answer 2

编辑：

也许这个？

public enum Account{

    ACC_512_401(512,401), 
    ACC_512_402(512,402);

    private final int accA;
    private final int accB;

    Account(int accA, int accB){
        this.accA=accA;
        this.accB=accB;
    }

    private int getAccA(){
        return accA;
    }
    private int getAccB(){
        return accB;
    }
    public static Account getEnum(int accA, int accB){
        for(Account acc : values()){
            if(accA == acc.getAccA() && accB == acc.getAccB()){
                return acc;
            }
        }
        return null;
    }
}



public class testswitch {
    public static void main(String[] args) {
        test(Account.getEnum(512, 401));
    }

    public static void test(Account acc){

        switch (acc){
        case ACC_512_401:
            System.out.println("A");
            break;
        case ACC_512_402:
            System.out.println("A");
            break;
            default:
                break;
        }
    }
}

你切换你的枚举。

编辑：我添加了getEnum方法来获取int输入的值。现在它就是你想要的。

Answer 3

一种可能的策略就是这样，@ Morgan的回答略有不同：

public enum AccountRelationship {
    BOSS_ACCOUNTS,
    SECRET_SWISS_TAX_AVOIDING_ACCOUNTS,
    OTHER;
}

public static final Map<AccountPair,AccountRelationship> relationships = new HashMap<>();
static {
    relationships.put(new AccountPair(1,1),AccountRelationship.BOSS_ACCOUNTS);
    relationships.put(new AccountPair(1,5),AccountRelationship.BOSS_ACCOUNTS);
    relationships.put(new AccountPair(2,2),AccountRelationship.SECRET_SWISS_TAX_AVOIDING_ACCOUNTS);
}

public void doSomething(AccountPair pair) {
    AccountRelationship rel = relationships.getOrDefault(pair, AccountRelationship.OTHER);
    switch (rel) {
    case BOSS_ACCOUNTS: receiveLotsOfBonus(); break;
    case SECRET_SWISS_TAX_AVOIDING_ACCOUNTS: laughAllTheWayToTheBank(); break;
    case OTHER: payLotsOfTaxes();
    }
}

这将决定做什么与调用动作的逻辑分开，使事情更易读，更容易扩展。更不用说您可以轻松地单独测试所有内容。

正如你所看到的，它虽然很冗长。

还有一个潜在的陷阱：relationships地图。如果您有多个需要相同操作的帐户对，这很好，但是当您向AccountRelationship添加新值时，很容易忘记更新此地图。

Answer 4

仅仅是使用质数的乐趣：（在上述范围内是安全的，但是在高整数上肯定会失败）

案例计算将在编译时完成。

public class Switch {

    public static void main(String[] args) {
        int i = 1;
        int j = 2;
        switch (i * 2 + j * 3) {
        case 1 * 2 + 2 * 3:
            System.out.println("match");
        }
    }
}

打开一对`int`s

4 个答案: