将一个 String 与一个表达式中的多个值进行比较

我有一个字符串变量，str与可能的值，val1，val2和 val3。

我想使用 if 语句将 str与所有这些值(大小写相同)进行比较，例如:

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

有没有办法避免使用多个 OR (| |)运算符并比较一个表达式中的值？例如，像这样:

 if(("val1" OR "val2" OR "val3").equalsIgnoreCase(str)   //this is only an idea.
163085 次浏览
小开

You could store all the strings that you want to compare str with into a collection and check if the collection contains str. Store all strings in the collection as lowercase and convert str to lowercase before querying the collection. For example:

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


String str = "Val1";


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

No, there is no such possibility. Allthough, one could imagine:

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

Just use var-args and write your own static method:

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"));
}
小开

You can achieve this with Collections framework. Put all your options in a Collection say something like Collection<String> options ;

Then loop throgh this to compare your string with the list elements and if it is you can return a boolean value true and otherwise false.

小开
最佳答案

I found the better solution. This can be achieved through RegEx: 

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

For case insensitive matching:

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

ArrayUtils may be helpful.

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

Small enhancement to perfectly valid @hmjd's answer: you can use following syntax:

class A {


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


// ...


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


// ...
}

It allows you to initialize you Set in-place.

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

works fine for me.

小开

In Java 8+, you might use a Stream<T> and anyMatch(Predicate<? super T>) with something like

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

Remember in Java a quoted String is still a String object. Therefore you can use the String function contains() to test for a range of Strings or integers using this method:

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

for numbers it's a tad more involved but still works:

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

Yet another alternative (kinda similar to https://stackoverflow.com/a/32241628/6095216 above) using StringUtils from the apache commons library: https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/StringUtils.html#equalsAnyIgnoreCase-java.lang.CharSequence-java.lang.CharSequence...-

if (StringUtils.equalsAnyIgnoreCase(str, "val1", "val2", "val3")) {
// remaining code
}
小开

Apache Commons Collection class.

StringUtils.equalsAny(CharSequence string, CharSequence... searchStrings)

So in your case, it would be

StringUtils.equalsAny(str, "val1", "val2", "val3");

小开

Here a performance test with multiples alternatives (some are case sensitive and others case insensitive):

public static void main(String[] args) {
// Why 4 * 4:
// The test contains 3 values (val1, val2 and val3). Checking 4 combinations will check the match on all values, and the non match;
// Try 4 times: lowercase, UPPERCASE, prefix + lowercase, prefix + UPPERCASE;
final int NUMBER_OF_TESTS = 4 * 4;
final int EXCUTIONS_BY_TEST = 1_000_000;
int numberOfMatches;
int numberOfExpectedCaseSensitiveMatches;
int numberOfExpectedCaseInsensitiveMatches;
// Start at -1, because the first execution is always slower, and should be ignored!
for (int i = -1; i < NUMBER_OF_TESTS; i++) {
int iInsensitive = i % 4;
List<String> testType = new ArrayList<>();
List<Long> timeSteps = new ArrayList<>();
String name = (i / 4 > 1 ? "dummyPrefix" : "") + ((i / 4) % 2 == 0 ? "val" : "VAL" )+iInsensitive ;
numberOfExpectedCaseSensitiveMatches = 1 <= i && i <= 3 ? EXCUTIONS_BY_TEST : 0;
numberOfExpectedCaseInsensitiveMatches = 1 <= iInsensitive && iInsensitive <= 3 && i / 4 <= 1 ? EXCUTIONS_BY_TEST : 0;
timeSteps.add(System.currentTimeMillis());
//-----------------------------------------
numberOfMatches = 0;
testType.add("List (Case sensitive)");
for (int j = 0; j < EXCUTIONS_BY_TEST; j++) {
if (Arrays.asList("val1", "val2", "val3").contains(name)) {
numberOfMatches++;
}
}
if (numberOfMatches != numberOfExpectedCaseSensitiveMatches) {
throw new RuntimeException();
}
timeSteps.add(System.currentTimeMillis());


//-----------------------------------------
numberOfMatches = 0;
testType.add("Set (Case sensitive)");
for (int j = 0; j < EXCUTIONS_BY_TEST; j++) {
if (new HashSet<>(Arrays.asList(new String[] {"val1", "val2", "val3"})).contains(name)) {
numberOfMatches++;
}
}
if (numberOfMatches != numberOfExpectedCaseSensitiveMatches) {
throw new RuntimeException();
}
timeSteps.add(System.currentTimeMillis());


//-----------------------------------------
numberOfMatches = 0;
testType.add("OR (Case sensitive)");
for (int j = 0; j < EXCUTIONS_BY_TEST; j++) {
if ("val1".equals(name) || "val2".equals(name) || "val3".equals(name)) {
numberOfMatches++;
}
}
if (numberOfMatches != numberOfExpectedCaseSensitiveMatches) {
throw new RuntimeException();
}
timeSteps.add(System.currentTimeMillis());


//-----------------------------------------
numberOfMatches = 0;
testType.add("OR (Case insensitive)");
for (int j = 0; j < EXCUTIONS_BY_TEST; j++) {
if ("val1".equalsIgnoreCase(name) || "val2".equalsIgnoreCase(name) || "val3".equalsIgnoreCase(name)) {
numberOfMatches++;
}
}
if (numberOfMatches != numberOfExpectedCaseInsensitiveMatches) {
throw new RuntimeException();
}
timeSteps.add(System.currentTimeMillis());


//-----------------------------------------
numberOfMatches = 0;
testType.add("ArraysBinarySearch(Case sensitive)");
for (int j = 0; j < EXCUTIONS_BY_TEST; j++) {
if (Arrays.binarySearch(new String[]{"val1", "val2", "val3"}, name) >= 0) {
numberOfMatches++;
}
}
if (numberOfMatches != numberOfExpectedCaseSensitiveMatches) {
throw new RuntimeException();
}
timeSteps.add(System.currentTimeMillis());


//-----------------------------------------
numberOfMatches = 0;
testType.add("Java8 Stream (Case sensitive)");
for (int j = 0; j < EXCUTIONS_BY_TEST; j++) {
if (Stream.of("val1", "val2", "val3").anyMatch(name::equals)) {
numberOfMatches++;
}
}
if (numberOfMatches != numberOfExpectedCaseSensitiveMatches) {
throw new RuntimeException();
}
timeSteps.add(System.currentTimeMillis());


//-----------------------------------------
numberOfMatches = 0;
testType.add("Java8 Stream (Case insensitive)");
for (int j = 0; j < EXCUTIONS_BY_TEST; j++) {
if (Stream.of("val1", "val2", "val3").anyMatch(name::equalsIgnoreCase)) {
numberOfMatches++;
}
}
if (numberOfMatches != numberOfExpectedCaseInsensitiveMatches) {
throw new RuntimeException();
}
timeSteps.add(System.currentTimeMillis());


//-----------------------------------------
numberOfMatches = 0;
testType.add("RegEx (Case sensitive)");
// WARNING: if values contains special characters, that should be escaped by Pattern.quote(String)
for (int j = 0; j < EXCUTIONS_BY_TEST; j++) {
if (name.matches("val1|val2|val3")) {
numberOfMatches++;
}
}
if (numberOfMatches != numberOfExpectedCaseSensitiveMatches) {
throw new RuntimeException();
}
timeSteps.add(System.currentTimeMillis());


//-----------------------------------------
numberOfMatches = 0;
testType.add("RegEx (Case insensitive)");
// WARNING: if values contains special characters, that should be escaped by Pattern.quote(String)
for (int j = 0; j < EXCUTIONS_BY_TEST; j++) {
if (name.matches("(?i)val1|val2|val3")) {
numberOfMatches++;
}
}
if (numberOfMatches != numberOfExpectedCaseInsensitiveMatches) {
throw new RuntimeException();
}
timeSteps.add(System.currentTimeMillis());


//-----------------------------------------
numberOfMatches = 0;
testType.add("StringIndexOf (Case sensitive)");
// WARNING: the string to be matched should not contains the SEPARATOR!
final String SEPARATOR = ",";
for (int j = 0; j < EXCUTIONS_BY_TEST; j++) {
// Don't forget the SEPARATOR at the begin and at the end!
if ((SEPARATOR+"val1"+SEPARATOR+"val2"+SEPARATOR+"val3"+SEPARATOR).indexOf(SEPARATOR + name + SEPARATOR)>=0) {
numberOfMatches++;
}
}
if (numberOfMatches != numberOfExpectedCaseSensitiveMatches) {
throw new RuntimeException();
}
timeSteps.add(System.currentTimeMillis());


//-----------------------------------------
StringBuffer sb = new StringBuffer("Test ").append(i)
.append("{ name : ").append(name)
.append(", numberOfExpectedCaseSensitiveMatches : ").append(numberOfExpectedCaseSensitiveMatches)
.append(", numberOfExpectedCaseInsensitiveMatches : ").append(numberOfExpectedCaseInsensitiveMatches)
.append(" }:\n");
for (int j = 0; j < testType.size(); j++) {
sb.append(String.format("    %4d ms with %s\n", timeSteps.get(j + 1)-timeSteps.get(j), testType.get(j)));
}
System.out.println(sb.toString());
}
}

Output (only the worse case, that is when have to check all elements without match none):

Test 4{ name : VAL0, numberOfExpectedCaseSensitiveMatches : 0, numberOfExpectedCaseInsensitiveMatches : 0 }:
43 ms with List (Case sensitive)
378 ms with Set (Case sensitive)
22 ms with OR (Case sensitive)
254 ms with OR (Case insensitive)
35 ms with ArraysBinarySearch(Case sensitive)
266 ms with Java8 Stream (Case sensitive)
531 ms with Java8 Stream (Case insensitive)
1009 ms with RegEx (Case sensitive)
1201 ms with RegEx (Case insensitive)
107 ms with StringIndexOf (Case sensitive)

Output provided by Warpspeed SCP, changing the test to fill the collections outside of the loops, simulationg the code when the list of values to test never change (and the collections can be cached).

(don't compare the time of this test with the previous test, since it was executed on different environment, but compare only the time of different strategies for the same test):

Test 4{ name : VAL0, numberOfExpectedCaseSensitiveMatches : 0, numberOfExpectedCaseInsensitiveMatches : 0 }:
26 ms with List (Case sensitive)
6 ms with Set (Case sensitive)
12 ms with OR (Case sensitive)
371 ms with OR (Case insensitive)
14 ms with ArraysBinarySearch(Case sensitive)
100 ms with Java8 Stream (Case sensitive)
214 ms with Java8 Stream (Case insensitive)
773 ms with RegEx (Case sensitive)
946 ms with RegEx (Case insensitive)
37 ms with StringIndexOf (Case sensitive)
小开

Sorry for reponening this old question, for Java 8+ I think the best solution is the one provided by Elliott Frisch (Stream.of("str1", "str2", "str3").anyMatches(str::equalsIgnoreCase)) but it seems like it's missing one of the simplest solution for eldest version of Java:

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

You could apply some error prevenction by checking the non-nullity of variable str, and by caching the list once created.

// List of lower-case possibilities
final List<String> list = Arrays.asList("val1", "val2", "val3", ..., "val_n");
for(String str : somethingYouCouldTheReadStringFrom()){
if(str != null && list.contains(str.toLowerCase())){
//...
}
}
小开

Since this question has been reopened anyway, I might just as well propose an enum solution.

enum ValidValues {
VAL1, VAL2, VAL3;


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

Or you can just use the stream statement with 

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

if you only use it in one place.

小开

Starting from Java 9, you can use either of following

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


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

The are many solutions suggested and most are working solutions. However i must add here that people suggesting using regex i.e str.matches("val1|val2|val3") is okay however

  1. it's not performant if the method/code is called many times
  2. it's not null safe

I would suggest to use apache commons lang3 stringUtils StringUtils.equalsAny(str, "val1", "val2", "val3") instead

Test:

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");
}

Results after 1000 iteration:

Matches took + 18 ms
StringUtils took 7 ms
小开

For those who came here for exact equality checks (not ignoring case), I find that

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

is one of, if the most concise solution, and is available on Java 7.

小开

Kotlin is good enough to make it without regex:

setOf("say", "no", "war").contains(your_string)

提交答案