Question

public boolean typeMatch(char c1, char c2) {

    if (c1 == '{' || c1 == '}') {
        return (c2 == '{' || c2 == '}');
    } else if (c1 == '(' || c1 == ')') {
        return (c2 == '(' || c2 == ')');
    } else if (c1 == '[' || c1 == ']') {
        return (c2 == '[' || c2 == ']');
    } else {
        return false;
    }
}

我的程序中有上面的代码，我想知道是否有更好的方法来实现此方法而不使用大量的if / else语句。

Answer 1

字符数组数组中的字符对

您可以将符号对（打开和关闭）提取到char[][]，然后循环遍历该数组以测试匹配。像，

static final char[][] pairs = { { '{', '}' }, { '(', ')' }, { '[', ']' } };

public boolean typeMatch(char c1, char c2) {
    for (char[] pair : pairs) {
        if (c1 == pair[0] || c1 == pair[1]) {
            return c2 == pair[0] || c2 == pair[1];
        }
    }
    return false;
}

字符串数组中的字符对

或者，如果我们使用String实现，可能更容易阅读¹ （s）和String.indexOf(int) ²。像，

public boolean typeMatch(char c1, char c2) { String[] pairs = { "{}", "()", "[]" }; for (String pair : pairs) { if (pair.indexOf(c1) != -1) { return pair.indexOf(c2) != -1; } } return false; }

^{1 _{这绝不是坏事。}}
^{2 _{链接的Javadoc部分地说在任何一种情况下，如果此字符串中没有出现此类字符，则返回-1。}}

Answer 2

Elliott's solution会比我好得多，但我觉得我有一些乐趣。

private static final Map<Character, Set<Character>> pairMap;

public boolean typeMatch(char c1, char c2) {
    Set<Character> s = pairMap.get(c1);
    return s != null && s.contains(c2);
}

static {
    pairMap = new HashMap<>();
    register(makeSet('{', '}'));
    register(makeSet('(', ')'));
    register(makeSet('[', ']'));
}

private static Set<Character> makeSet(char... chars) {
    Set<Character> s = new HashSet<>(chars.length, 1.0f);
    for (char c : chars) {
        s.add(c);
    }
    return s;
}

private static void register(Set<Character> s) {
    for (Character c : s) {
        pairMap.put(c, s);
    }
}

此解决方案的内存要求很严重。它唯一需要推荐的是，如果你需要处理大量的字符等价类而不是三对，它在执行时间方面会更好地扩展。此外，它可以推广到除char之外的其他类型（或者，准确地说，Character）。

Answer 3

private static final String PAIRS = "{}()[]";
public boolean typeMatch(char c1, char c2) {
    int indexOfC1 = PAIRS.indexOf(c1);
    int indexOfC2 = PAIRS.indexOf(c2);
    return indexOfC1 >= 0 && indexOfC2 >= 0 && (indexOfC1 / 2 == indexOfC2 / 2);   
}

有点棘手，也许......

Answer 4

不是最具可读性，但我尝试用有点操作符来做这件事有点乐趣，我想我会发布它

public boolean typeMatch(char c1, char c2) {
    int xor = c1 ^ c2;
    if(xor == 6) { // 2 apart
        return c1 == '{' || c1 == '}' || c1 == '[' || c1 == ']';
    } else if(xor == 1) { // 1 apart
        return c1 == '(' || c1 == ')';
    } else if(xor == 0) { // same
        return c1 == '(' || c1 == ')' || 
                c1 == '{' || c1 == '}' || c1 == '[' || c1 == ']';
    }
    return false;
}

至少应该很快......

Answer 5

这里已经有了一个公认的答案，这是一个很好的答案，但它对于手头的问题非常具体。

对于那些通过搜索更通用的解决方案来到这里的人们，我想提供我最喜欢的模式来取消if / else链：

boolean result = false;
do {
   if(condition1) {
      result = true;
      break;
   }

   if(condition2) {
     break;
   }

   // etc.

} while(false);

return result;

当然，这可以归结为任何返回类型。

如果/ Else替代方案

5 个答案:

字符数组数组中的字符对

字符串数组中的字符对