Question

基本上，我想要做的是检查一个给定值的两个整数，因此，通常你会做的是这样的事情：

//just to get some values to check
int a, b;
a = (int)(Math.random()*5);
b = (int)(Math.random()*5);

//the actual thing in question
if(a == 0 || b == 0)
{
//Then do something
}

但是有更简洁的格式吗？可能与此类似（返回错误的操作数类型）：

//just to get some values to check
int a, b;
a = (int)(Math.random()*5);
b = (int)(Math.random()*5);

//the actual thing in question
if((a||b) == 0)
{
//Then do something
}

Answer 1

不幸的是，Java中没有这样的构造。

在您的代码中经常进行这种比较，您可以实现一个小功能来执行检查：

public boolean oneOfEquals(int a, int b, int expected) {
    return (a == expected) || (b == expected);
}

然后你可以像这样使用它：

if(oneOfEquals(a, b, 0)) {
    // ...
}

如果您不想将yourselft限制为整数，可以将上述功能设为通用：

public <T> boolean oneOfEquals(T a, T b, T expected) {
    return a.equals(expected) || b.equals(expected);
}

请注意，在这种情况下，Java运行时将对基本类型（如int）执行自动装箱和取消装箱，这是性能损失。

Answer 2

您可以在普通java

中执行以下操作

snapshot-view-pname

Answer 3

~~我认为有点OR：~~

if ((a | b) == 0) . . .
如果你想专门检查0，

会起作用。我不确定这是否可以节省任何执行时间。更重要的是，它会产生神秘的代码，这将使这个代码的未来维护者诅咒你（即使它自己）。我建议坚持使用更多打字选项。

呸。我误读了OP的原始逻辑。

另一个......

如果要测试许多变量中的任何一个是否等于预期值，通用函数可能会起作用：

public <T> boolean exists(T target, T... values) {
    for (T value : values) {
        if (target == null) {
            if (value == null) {
                return true;
            }
        } else if (target.equals(value)) {
            return true;
        }
    }
    return false;
}

这适用于任何数量的一种类型的对象。基元将被自动装箱，因此它也可以与它们一起使用。您的原始代码将类似于：

if (test(0, a, b)) {
    // do something
}

（甚至需要一个更好的方法名称，甚至考虑这是否比现在的改进更好。即使测试扩展到3或4个变量，我也质疑这种事情的必要性。）注意这个也适用于数组：

int[] values = { . . . };
if (test(0, values)) { . . .

它可用于测试数组（或任何变量集合）是否为null。

Answer 4

if(a == 0 || b == 0)
{
//Then do something
}

为什么不保持可读性？什么不简明扼要？另一方面，

a = (int)(Math.random()*5);

涉及不必要的演员。为什么不使用Random并调用nextInt()？

Answer 5

对于此示例，您可以执行

if (a * b == 0)

或更多变量

if (a * b * c * d == 0)

虽然更简洁但可能不那么清楚。对于较大的值，您需要强制转换为long以避免溢出。

Answer 6

您可以将整数放在一个集合中，看看它是否包含给定值。 Using Guava：

if(newHashSet(a, b).contains(0)){
    // do something
}

但在这种情况下，两个简单的int比较可能更容易理解。

Answer 7

这是对@ buc的答案的修改，可以接受任意数量的任何参数：

public <T> boolean oneOfEquals(T expected, T... os) {
    for (T o : os) {
        if (expected.equals(o)) return true;
    }
    return false;
}

Answer 8

即使您使用了Ted建议的逐位操作，表达式也不相同，因为一个变量需要至少一个变量为零，第二个变量需要它们为零。

关于你的问题，Java中没有这样的捷径。

Answer 9

您可以尝试以下代码：

public static boolean match (Object ref, Object... objects)
{
    if (ref == null)
        return false;
    //
    for (Object obj : objects)
        if (obj.equals (ref))
            return true;
    //
    return false;   
}   //  match

所以如果你能这样检查：

if (match (reference, "123", "124", "125"))
    ;   //  do something

Answer 10

As referenced from this answer：

在Java 8+中，您可以使用Stream和anyMatch。像
这样的东西
if (Stream.of(b, c, d).anyMatch(x -> x.equals(a))) {
    // ... do something ...
}

请注意，如果检查，则有可能运行较慢，因为将这些元素包装到流中的开销很快。

Answer 11

在Java 8中，我们可以使用以下方法实现相同的目的：

private boolean methodName(int variant,int... args){
        if(args.length > 0){ return Arrays.stream(args).anyMatch( x -> x == variant); }
        return false;
    }

如果变体匹配任何可能的输入，则给定的方法将返回true。这用于或条件。

以相同的方式，如果要执行&&（and）条件，则只需使用其他Java 8方法：

注意：这些方法将谓词作为参数。

anyMatch：在第一个谓词返回true时返回true，否则返回false。

allMatch：如果所有谓词均返回true，否则返回false。

noneMatch：如果所有谓词均未返回true，则返回true，否则返回false。

性能注意事项：当您有足够的数据量可以   检查，因为它有一些开销，但是当您使用时它确实很好用   这足以获得足够的数据量。普通方法只适合两个人   条件。

Answer 12

没有特殊的语法。你可以为此做一个功能。至少假设Java 1.5：

public <T> boolean eitherOneEquals(T o1, T o2, T expectedValue) {
  return o1.equals(expectedValue) || o2.equals(expectedValue);
}

if(eitherOneEquals(o1, o2, expectedValue)) {
   // do something...
}

有没有更简单的方法来检查if语句中的一个值的多个值？

12 个答案: