Question

我们有n个变量X = {x1,x2,...xn}它们不属于任何结构。

在python中，例如我可以这样做：if (x1 == x2 == x3 == xn):

在java中，我必须这样做：if((x1 == x2) && (x2 == x3) && (x3 == xn)):

您是否知道改进此语法的简单方法？（想象一下很长的变量名称和很多）

感谢。

Answer 1

如果您有很多这些变量，您是否考虑将它们放入集合中而不是将它们作为单独的变量？那时有各种各样的选择。

如果你发现自己做了很多，你可能想要编写辅助方法，可能使用varargs语法。例如：

public static boolean areAllEqual(int... values)
{
    if (values.length == 0)
    {
        return true; // Alternative below
    }
    int checkValue = values[0];
    for (int i = 1; i < values.length; i++)
    {
        if (values[i] != checkValue)
        {
            return false;
        }
    }
    return true;
}

由glowcoder提供的替代方案是强制存在至少一个值：

public static boolean areAllEqual(int checkValue, int... otherValues)
{
    for (int value : otherValues)
    {
        if (value != checkValue)
        {
            return false;
        }
    }
    return true;
}

在任何一种情况下，请使用：

if (HelperClass.areAllEqual(x1, x2, x3, x4, x5))
{
    ...
}

Answer 2

你可以创建一个这样的实用工具方法：

public boolean allEqual(Object... objs) {
    if(objs.length < 2) return true; // 0 or 1 objects are all equal
    Object key = objs[0]; // pick one
    for(Object o : objs) if(!o.equals(key)) return false;
    return true;
}

另一种选择是

public boolean allEqual(Object key, Object... objs) {
    for(Object o : objs) if(!o.equals(key)) return false;
    return true;
}

简化许多样板逻辑。然后去吧

if(allEqual(x,x1,x2,x3))

显然这两者是相互排斥的（它们具有特征性的暧昧）但你可以拥有 allEqual和allEqualWithKey

Answer 3

与@ Jon的解决方案类似，但更短。

public static boolean areAllTheSame(int value, int... values) {
    for (int i: values) if(value != i) return false;
    return true;
}

Answer 4

您可以编写一种方法，使其看起来不那么麻烦：

boolean areAllEqual(Object... values) {
    if (values.length < 2) {
        return true;
    }

    for (int i = 1; i < values.length; i++) {
        if (!values[i].equals(values[0])) {
            return false;
        }
    }

    return true;
}

像这样使用：

if (areAllEqual(x1, x2, x3, x4, x5)) {
    // do something
}

编辑太慢了......！： - （

Answer 5

不幸的是，不，没有可用的语法糖。这是关于Java的常见抱怨。

Answer 6

如果您不喜欢打字，可能会丢失嵌套的括号：

if(x1 == x2 && x2 == x3 && x3 == xn);

Answer 7

另一种快速实现此目的的方法是通过array - ＆gt; List - ＆gt; HashSet转化路线，如：

标准Java：

if(new HashSet<Object>(Arrays.asList(x1, x2, x3, x4, x5)).size() == 1) {

}

Google Guava：

if(Sets.newHashSet(Ints.asList(x1, x2, x3, x4, x5)).size() == 1) {

}

上述解决方案本身看起来并不太干净，所以它绝对应该被隔离成一个具有合理名称的独立实用方法（在这种情况下，你可能很可能）最好的选择是Peter Lawrey或Jon Skeet的解决方案。

我还希望这种方法与至少一个微小的性能影响相关联，因为很清楚必须实例化多个Collection＆amp;填充。

所以重申一下 - 如果你一心想要打一个单线，只能使用这个解决方案。

Answer 8

/*
* reference - basic String to compare against
* entries - all other objects for comparison
*/
public static boolean allEqual(String reference, String... entries) {
        return Arrays.stream(entries)
                .allMatch(entry -> Objects.equals(reference, entry));
}

/*
* Method can be generalized to use <T> instead of String
*/
public static <T>boolean allEqual(T reference, T... entries) {
    return Arrays.stream(entries)
            .allMatch(entry -> Objects.equals(reference, entry));
}

public static void main(String[] args) {
    System.out.println(allEqual("X", "X", "X", "X")); // true
    System.out.println(allEqual("X", "X", "Y"));      // false
    System.out.println(allEqual("X"));                // true

    System.out.println(allEqual(10, 10, 9));          // false
    System.out.println(allEqual(10, 10));             // true
    System.out.println(allEqual(10, new Integer[] {10, 10, 10})); // true
}

Answer 9

我喜欢已经建议的样板逻辑，但通常列表中的任何参数都可以是null，这可能会导致NullPointerException被抛出。因此，我们应首先测试null并使用==比较适当的对象引用：

public static boolean allEqual(Object key, Object... objs) {
    for(Object o : objs)
        if((key != null && !key.equals(o)) || key != o) return false;
    return true;
}

Answer 10

org.apache.commons.lang3.BooleanUtils public static boolean and（final boolean ... array）

Answer 11

只需使这些答案保持最新（Java SE 9）。

 Set.of(x1,x2,...xn).size() == 1

使数学家具有完美的意识。（在这种情况下，我称自己是数学家。）

（很明显，Integer，Integer[]，Set以及（可能在Set内部都有一种装箱费用。）< / p>

编辑：Stuart Marks指出，如果元素重复，则Set.of会抛出IllegalArgumentException。替代：

Set.copyOf(Arrays.asList(x1,x2,...xn)).size() == 1

或取决于您对clean的定义：

copyOf(asList(x1,x2,...xn)).size() == 1

（假设过多的静态导入。）

Answer 12

使用Java 8，我喜欢使用java.util.stream.Stream来执行此操作：

boolean b = Stream.of(obj1, obj2, obj3).anyMatch(it -> it == null)

以确定任何给定对象obj1，obj2或obj3是否为空。

Answer 13

在Java 8中，这可以使用Stream：

作为一行进行

boolean allEqual = Stream.of(x1, x2, x3, x4).distinct().count() == 1;

基本上distinct会过滤流，因此只保留唯一元素。如果该流中只剩下一个元素，则表示所有原始元素都相等。

是否有干净的语法来检查多个变量是否都具有相同的值？

13 个答案: