在Java中检查三个或更多字符串的相等性[重复]

Question

我知道这是一个非常基本的问题，但我一直在努力寻找使我的代码尽可能干净简洁的方法。有没有办法在单个if() 语句中比较三个或更多字符串的相等性？我目前正在使用&& 运算符逐步比较每个字符串。但是，正如您可以想象的那样，在长变量名和被调用的方法之间，这些if() 语句很快就会变得非常混乱。此外，我计划拥有未知数量的这些字符串，并希望避免复杂的for 循环，其中嵌套了杂乱的if()s。这是我的代码目前的样子：

String a = new String("a");
String b = new String("b");
String c = new String("c");
if(a.equals(b) && b.equals(c)) {
    doSomething();
}

有没有一种方法，或者我可以使用的某种集合，可以让我更像这样比较这些值：

if(a.equals(b).equals(c)) {
    doSomething();
}

Answer 1

没有像这样链接equals() 命令的简单方法。为了能够以这种方式链接它们，equals() 必须返回对 String 本身的引用。但是，它不能再返回表示比较结果的布尔值。

另外，我认为不是特别成问题，像在您的第一个示例中那样分别比较三个字符串。确保您的代码格式正确，即使变量名较长，也易于理解：

if(myValueAWithALongName.equals(myValueBWithALongName) &&
   myValueBWithALongName.equals(myValueCWithALongName) &&
   myValueCWithALongName.equals(myValueDWithALongName) &&
   ... ) {

或者，您可以使用此线程中提出的其他解决方案之一，并将您的值包装到 Collection 中并编写一个辅助方法。但请注意，这可能会对内存使用、性能和可能的可读性产生负面影响。

---

附带说明，您永远不应该使用构造函数new String() 创建字符串。只需将字符串文字直接分配给您的变量：

String a = "a";

Answer 2

这样的事情怎么样：

boolean allEqual(List<String> elements) {
    if(elements.isEmpty() || elements.size() == 1) {
        return true;
    }
    String current = elements.get(0);
    if(current == null) {
        return false;
    }
    for(int i = 1; i < elements.size(); i++) {
        if(!current.equals(elements.get(i))) {
            return false;
        }
        current = elements.get(i);
    }
    return true;
}

不完全漂亮，但你只需要编写一次，它适用于任意数量的字符串。

Answer 3

如果您有多个相同类型的对象，最好将它们组织成数组或列表等数据结构。所以假设你有一个List 的String 对象：

List<String> strings = Arrays.asList("a", "b", "a", ...);

您想知道列表中的所有字符串是否彼此相等。这可以通过多种方法来完成。可能最短的是：

if(new HashSet<>(strings).size() == 1) {
    // all strings are equal
}

@niceguy 提出了更长但更优化的解决方案。如果你使用的是 Java-8，你也可以这样做：

if(strings.stream().distinct().count() == 1) {
    // all strings are equal
}

Answer 4

另一种方法是使用String 作为Comparable 的实现。

public <T extends Comparable<T>> boolean equality(T... objects) {
    Arrays.sort(objects);
    return objects[0].compareTo(objects[objects.length - 1]) == 0;
}

优点： 此解决方案适用于所有 Comparable 对象。

缺点：如果所有值都等于N（太棒了！）比较，否则N logN max。这里还将为sort 方法分配内存用于临时存储，该方法从非常小到N/2 不等。

Answer 5

根据要比较的String 对象的数量，有不同的方法可以解决此问题。

如果您只有几个 String 对象要比较，并且您几乎需要在应用程序中的一两个地方进行这种比较，您可以将代码包装在需要此类的类中的方法中一个比较，使代码变得更具可读性：

 public boolean isConditionSatisfied(String a,String b,String c) {
    return Objects.equals(a,b) && Objects.equals(b,c);
 }

然后客户端代码被简化并且更具可读性：

if(isConditionSatisfied(a,b,c)) { //doSomething }

请注意，Objects.equals 是自 JDK 1.7 起可用的内置方法。与其他答案相比，使用Object.equals 可以保护您免受NullPointerExcsption 的影响，我认为这是绝对必要的。

如果您发现自己经常需要这种比较（不仅针对String 对象），为什么还要寻找仅用于比较String 对象的解决方案？为什么不找到适用于任何种类或数量的对象的通用解决方案？

public class ObjectUtils {

    public static boolean multipleEquals(Object... objectsToCompare) {

        if (null == objectsToCompare) {
            return false;
        } else if (objectsToCompare.length == 0) {
            return false;
        } else if (objectsToCompare.length == 1)      {
            return true;
        }

        boolean allEqual = true;
        for (int curr = 1; curr < objectsToCompare.length; ++curr) {
            if(!Objects.equals(objectsToCompare[0],objectsToCompare[curr])) {
                allEqual = false;
                break;
            }
        }

        return allEqual;
    }
}

好的，你想比较 4 个 String 对象，为什么不呢：

if(ObjectUtils.multipleEquals("1","1","1","1") { }

但现在你想比较 5 个Integer 对象，没问题：

if(ObjectUtils.multipleEquals(1,2,3,4,5) { }

你甚至可以混合和匹配对象：

if(ObjectUtils.multipleEquals("1",2,"3",4) { }

Answer 6

此外，我计划拥有未知数量的这些字符串， 并且希望避免复杂的嵌套 if() 的复杂 for 循环 在他们里面。

我认为 for 循环不会那么复杂。

你当然可以通过尝试来检查是否相等

a.equals(b)
b.equals(c)
etc.

但是将所有内容与a 进行比较将得到相同的结果。如果一切都等于a，那么一切都彼此相等。

a.equals(b)
a.equals(c)
etc.

这使得 for 循环更简单。如果您不介意将 a 与自身进行比较的开销，您可以简单地检查整个数组或集合（或其他）是否相等。

if 看起来也不混乱。 return 在一对字符串不相等时立即从函数中返回。

Answer 7

这可能是一个不寻常的想法，但在这种情况下，一点元编程可能会派上用场。

public static void nEquals(int nOverloads, PrintStream out) {
    if (nOverloads < 2)
        throw new IllegalArgumentException();

    for (int i = 2; i <= nOverloads; ++i) {
        out.println("public static boolean equals(");
        out.print("        Object obj0");

        for (int j = 1; j < i; ++j) {
            out.print(", Object obj" + j);
        }

        out.println(") {");
        out.print("    return obj0.equals(obj1)");

        for (int j = 2; j < i; ++j) {
            out.print(" && obj0.equals(obj" + j + ")");
        }

        out.println(";");
        out.println("}");
    }
}

nEquals(4, System.out); 打印以下内容：

public static boolean equals(
        Object obj0, Object obj1) {
    return obj0.equals(obj1);
}
public static boolean equals(
        Object obj0, Object obj1, Object obj2) {
    return obj0.equals(obj1) && obj0.equals(obj2);
}
public static boolean equals(
        Object obj0, Object obj1, Object obj2, Object obj3) {
    return obj0.equals(obj1) && obj0.equals(obj2) && obj0.equals(obj3);
}

您可以根据需要生成任意数量的重载，无需可变参数。只需复制并粘贴到实用程序类即可。

if (Util.equals(a, b, c)) {
    doSomething();
}

对于这样一个简单的代码生成，出错的余地很小。唯一的缺点是可维护性，因为如果有人确实需要修改它（例如更改 null 的处理，这在我和您的示例中都被忽略了），他们需要修改生成器并再次运行它。