Java 将一个字符串与一个表达式中的多个值进行比较

我有一个字符串变量，

str

和可能的值，

val1

，

val2

和

val3

我想使用if语句将（大小写相同的）

str

与所有这些值进行比较，例如：

if("val1".equalsIgnoreCase(str)||"val2".equalsIgnoreCase(str)||"val3".equalsIgnoreCase(str))
{
      //remaining code
}

Set<String> strings = new HashSet<String>();
strings.add("val1");
strings.add("val2");

String str = "Val1";

if (strings.contains(str.toLowerCase()))
{
}

有没有办法避免使用多个OR（| |）运算符并在一个表达式中比较值？例如，像这样：

 if(("val1" OR "val2" OR "val3").equalsIgnoreCase(str)   //this is only an idea.

---

您可以将要与

str

进行比较的所有字符串存储到集合中，并检查该集合是否包含

str

。将集合中的所有字符串存储为小写，并在查询集合之前将

str

转换为小写。例如：

if("val1".equalsIgnoreCase(str)||"val2".equalsIgnoreCase(str)||"val3".equalsIgnoreCase(str))
{
      //remaining code
}

Set<String> strings = new HashSet<String>();
strings.add("val1");
strings.add("val2");

String str = "Val1";

if (strings.contains(str.toLowerCase()))
{
}

Set strings=newhashset（）；
字符串。添加（“val1”）；
字符串。添加（“val2”）；
字符串str=“Val1”；
if（strings.contains（str.toLowerCase（）））
{
}

不，没有这种可能性。 尽管如此，人们可以想象：

public static boolean contains(String s, Collection<String>c) {
    for (String ss : c) {
       if (s.equalsIgnoreCase(ss)) return true;
    }
    return false;
}

公共静态布尔包含（字符串s，集合c）{
for（字符串ss:c）{
如果（s.equalsIgnoreCase（ss））返回true；
}
返回false；
}

只需使用var args并编写自己的静态方法：

public static boolean compareWithMany(String first, String next, String ... rest)
{
    if(first.equalsIgnoreCase(next))
        return true;
    for(int i = 0; i < rest.length; i++)
    {
        if(first.equalsIgnoreCase(rest[i]))
            return true;
    }
    return false;
}

public static void main(String[] args)
{
    final String str = "val1";
    System.out.println(compareWithMany(str, "val1", "val2", "val3"));
}

publicstaticbooleanecomparewithmany（先字符串，后字符串，字符串…rest）
{
if（第一个相等信号案例（下一个））
返回true；
for（int i=0；i

您可以通过Collections框架实现这一点。把你所有的选项放在一个集合中，比如说

集合选项

---

然后通过此循环将字符串与列表元素进行比较，如果是，则可以返回布尔值true，否则返回false。

我找到了更好的解决方案。这可以通过正则表达式实现：

if (str.matches("val1|val2|val3")) {
     // remaining code
}

对于不区分大小写的匹配：

if (str.matches("(?i)val1|val2|val3")) {
     // remaining code
}

---

ArrayUtils

可能会有所帮助

ArrayUtils.contains(new String[]{"1", "2"}, "1")

---

对完全有效的小增强：可以使用以下语法：

class A {

  final Set<String> strings = new HashSet<>() {{
    add("val1");
    add("val2");
  }};

  // ...

  if (strings.contains(str.toLowerCase())) {
  }

  // ...
}

A类{
final Set strings=new HashSet（）{{
添加（“val1”）；
添加（“val2”）；
}};
// ...
if（strings.contains（str.toLowerCase（）））{
}
// ...
}

它允许您初始化

设置

!string.matches("a|b|c|d") 

对我来说效果很好。
在Java 8+中，您可以将and与以下内容一起使用

if (Stream.of("val1", "val2", "val3").anyMatch(str::equalsIgnoreCase)) {
    // ...
}

请记住，在Java中，带引号的字符串仍然是字符串对象。因此，您可以使用String函数contains（）使用以下方法测试一系列字符串或整数：

if ("A C Viking G M Ocelot".contains(mAnswer)) {...}

对于数字来说，这有点复杂，但仍然有效：

if ("1 4 5 9 10 17 23 96457".contains(String.valueOf(mNumAnswer))) {...} 

还有另一种选择（类似于上文），使用apache commons库中的StringUtils：

apachecommons集合类

equalsAny（CharSequence字符串、CharSequence…SearchString）

所以在你的情况下，应该是

马蹄莲（str，“val1”，“val2”，“val3”）
 这里是一个具有多个可选项的性能测试（一些区分大小写，另一些不区分大小写）：

很抱歉回答这个老问题，对于Java 8+，我认为最好的解决方案是Elliott Frisch（
Stream.of（“str1”、“str2”、“str3”）。anyMatches（str:：equalsIgnoreCase）
）提供的解决方案，但它似乎缺少了最老版本Java的一个最简单的解决方案：

if(Arrays.asList("val1", "val2", "val3", ..., "val_n").contains(str.toLowerCase())){
...
}

您可以通过检查变量
str
的非空性，以及在创建列表后缓存列表，使用ArrayList加速长列表的搜索，来应用一些错误预防：

// List of lower-case possibilities
List<String> list = new ArrayList<>(Arrays.asList("val1", "val2", "val3", ..., "val_n"));

if(str != null && list.contains(str.toLowerCase())){

}

//小写可能性列表
List List=newarraylist（Arrays.asList（“val1”、“val2”、“val3”、“valn”））；
if（str！=null&&list.contains（str.toLowerCase（）））{
}
既然这个问题已经被重新打开，我不妨提出一个
enum
解决方案

enum ValidValues {
   VAL1, VAL2, VAL3;

   public static boolean isValid(String input) {
       return Stream.of(ValidValues.values())
                    .map(ValidValues::name)
                    .anyMatch(s -> s.equalsIgnoreCase(input));
   }
}

或者，您可以将stream语句用于

Stream.of("val1", "val2", "val3")
      .anyMatch(s -> s.equalsIgnoreCase(str))

如果您只在一个地方使用它。
从Java 9开始，您可以使用以下任一选项

List.of("val1", "val2", "val3").contains(str.toLowerCase())

Set.of("val1", "val2", "val3").contains(str.toLowerCase());

建议的解决方案很多，大多数都是有效的解决方案。然而，我必须在此补充一点，人们建议使用regex，即
str.matches（“val1 | val2 | val3”）
是可以的

如果多次调用该方法/代码，则无法执行
它不安全
我建议使用ApacheCommons lang3 stringUtils
stringUtils.equalsAny（str，“val1”、“val2”、“val3”）

测试：

对于那些来这里进行精确的平等性检查（不忽略案例）的人，我发现

if (Arrays.asList(str1, str2, str3).contains(strToCheck)) {
    ...
}

是最简洁的解决方案之一，在java 7上可用。
对于值得考虑的集合，如HashSet，容器（）有更有效的实现。真的，但（可能是一个未知数），相等和均等信号不会产生相同的结果。当然，这可以通过将字符串存储为小写并将要查找的键小写来克服，但是，可以使用所需的任何值填充集合。如果
str
是
“val”
，那么在我回答的代码中
strings.contains（）
将返回
false
。不，不，我是说如果有人将str值作为“val”传递，而“val”与“Val1”、“Val2”、“Val3”不相等。这意味着将str值作为“val”传递“一定失败了。。但在您的情况下，这将是通过的。不满足我的条件。从问题来看，由于存在
equalsIgnoreCase（）
，因此大小写不相关。如果传递了
“Val”
，并且
字符串
包含
“val1”
、
“val2”
和
“val3”
，则
包含（）
将返回
假
。看，你用HashSet来存储字符串。好的，我得到了这个。或者
新的树集（字符串。不区分大小写\u顺序）
<代码>如果（strings.contains（str））{…}
。无需调用
String.toLowerCase（）
我喜欢这个的可能重复！我可能是奥夫
public static void main(String[] args) {
        String var = "val1";
        long t, t1 = 0, t2 = 0;

        for (int i = 0; i < 1000; i++) {
            t = System.currentTimeMillis();
            var.matches("val1|val2|val3");
            t1 += System.currentTimeMillis() - t;

            t = System.currentTimeMillis();
            StringUtils.equalsAny(var, "val1", "val2", "val3");
            t2 += System.currentTimeMillis() - t;
        }
        System.out.println("Matches took + " + t1 + " ms\nStringUtils took " + t2 + " ms");
    }

Matches took + 18 ms
StringUtils took 7 ms

if (Arrays.asList(str1, str2, str3).contains(strToCheck)) {
    ...
}