ทดสอบว่าสตริงมีสตริงใด ๆ จากอาร์เรย์หรือไม่

ฉันจะทดสอบสตริงเพื่อดูว่ามันมีสตริงใด ๆ จากอาร์เรย์ได้อย่างไร

แทนที่จะใช้

if (string.contains(item1) || string.contains(item2) || string.contains(item3))

แก้ไข: นี่คือการปรับปรุงโดยใช้ Java 8 Streaming API ทำความสะอาดมาก ยังสามารถใช้ร่วมกับนิพจน์ปกติได้เช่นกัน

public static boolean stringContainsItemFromList(String inputStr, String[] items) {
    return Arrays.stream(items).parallel().anyMatch(inputStr::contains);
}

นอกจากนี้หากเราเปลี่ยนประเภทอินพุตเป็นรายการแทนที่จะเป็นอาร์เรย์ที่เราสามารถitems.parallelStream().anyMatch(inputStr::contains)ใช้ได้

คุณสามารถใช้.filter(inputStr::contains).findAny()หากคุณต้องการส่งคืนสตริงที่ตรงกัน

คำตอบเดิมเล็กน้อยวันที่:

นี่คือวิธีคงที่ (ขั้นพื้นฐานมาก) โปรดทราบว่ามันเป็นกรณีที่สำคัญในสตริงการเปรียบเทียบ ดั้งเดิมวิธีที่จะทำให้มันกรณีตายจะโทรtoLowerCase()หรือtoUpperCase()ทั้งเข้าและสายการทดสอบ

หากคุณต้องการทำอะไรที่ซับซ้อนกว่านี้ฉันขอแนะนำให้ดูที่คลาสPatternและMatcherและเรียนรู้วิธีการทำนิพจน์ทั่วไป เมื่อคุณเข้าใจสิ่งเหล่านั้นคุณสามารถใช้คลาสเหล่านั้นหรือString.matches()วิธีการช่วยเหลือ

public static boolean stringContainsItemFromList(String inputStr, String[] items)
{
    for(int i =0; i < items.length; i++)
    {
        if(inputStr.contains(items[i]))
        {
            return true;
        }
    }
    return false;
}

import org.apache.commons.lang.StringUtils;

String Utils

ใช้:

StringUtils.indexOfAny(inputString, new String[]{item1, item2, item3})

มันจะกลับดัชนีของสตริงพบหรือ -1 ถ้าไม่พบ

คุณสามารถใช้วิธีการจับคู่ String #ดังนี้:

System.out.printf("Matches - [%s]%n", string.matches("^.*?(item1|item2|item3).*$"));

วิธีที่ง่ายที่สุดอาจจะเป็นการแปลงอาร์เรย์เป็น java.util.ArrayList เมื่ออยู่ในรายการอาร์เรย์คุณสามารถใช้วิธีการได้อย่างง่ายดาย

public static boolean bagOfWords(String str)
{
    String[] words = {"word1", "word2", "word3", "word4", "word5"};  
    return (Arrays.asList(words).contains(str));
}

หากคุณใช้Java 8หรือสูงกว่าคุณสามารถพึ่งพาStream APIเพื่อทำสิ่งนี้:

public static boolean containsItemFromArray(String inputString, String[] items) {
    // Convert the array of String items as a Stream
    // For each element of the Stream call inputString.contains(element)
    // If you have any match returns true, false otherwise
    return Arrays.stream(items).anyMatch(inputString::contains);
}

สมมติว่าคุณมีชุดStringทดสอบขนาดใหญ่จำนวนมากเพื่อทดสอบคุณสามารถเปิดการค้นหาแบบขนานโดยการโทรจากparallel()นั้นโค้ดจะเป็น:

return Arrays.stream(items).parallel().anyMatch(inputString::contains); 

นี่คือทางออกหนึ่ง:

public static boolean containsAny(String str, String[] words)
{
   boolean bResult=false; // will be set, if any of the words are found
   //String[] words = {"word1", "word2", "word3", "word4", "word5"};

   List<String> list = Arrays.asList(words);
   for (String word: list ) {
       boolean bFound = str.contains(word);
       if (bFound) {bResult=bFound; break;}
   }
   return bResult;
}

ตั้งแต่เวอร์ชั่น 3.4 Apache ทั่วไป Lang 3 ใช้containsAnyวิธี

วิธี groovyesque ที่มากขึ้นคือการใช้injectร่วมกับmetaClass :

ฉันชอบที่จะพูดว่า:

String myInput="This string is FORBIDDEN"
myInput.containsAny(["FORBIDDEN","NOT_ALLOWED"]) //=>true

และวิธีการจะเป็น:

myInput.metaClass.containsAny={List<String> notAllowedTerms->
   notAllowedTerms?.inject(false,{found,term->found || delegate.contains(term)})
}

หากคุณต้องการcontainsAnyที่จะนำเสนอสำหรับการใด ๆ ตัวแปร String อนาคตแล้วเพิ่มวิธีการที่จะแทนระดับของวัตถุที่:

String.metaClass.containsAny={notAllowedTerms->
   notAllowedTerms?.inject(false,{found,term->found || delegate.contains(term)})
}

ลองสิ่งนี้:

if (Arrays.asList(item1, item2, item3).stream().anyMatch(string::contains))

และหากคุณกำลังมองหาการจับคู่แบบตัวพิมพ์เล็กและใหญ่ให้ใช้รูปแบบ

Pattern pattern = Pattern.compile("\\bitem1 |item2\\b",java.util.regex.Pattern.CASE_INSENSITIVE);

    Matcher matcher = pattern.matcher(input);
    if(matcher.find() ){ 

}

หากคุณกำลัง seraching สำหรับทั้ง คำพูดที่คุณสามารถทำเช่นนี้ที่ทำงานกรณี ตาย

private boolean containsKeyword(String line, String[] keywords)
{
    String[] inputWords = line.split(" ");

    for (String inputWord : inputWords)
    {
        for (String keyword : keywords)
        {
            if (inputWord.equalsIgnoreCase(keyword))
            {
                return true;
            }
        }
    }

    return false;
}

เราสามารถทำสิ่งนี้เช่นกัน:

if (string.matches("^.*?((?i)item1|item2|item3).*$"))

(?i): used for case insensitive
.*? & .*$: used for checking whether it is present anywhere in between the string.

ด้านล่างควรใช้กับคุณโดยสมมติว่าStringsคืออาร์เรย์ที่คุณกำลังค้นหาภายใน:

Arrays.binarySearch(Strings,"mykeytosearch",mysearchComparator);

โดยที่ mykeytosearch เป็นสตริงที่คุณต้องการทดสอบการมีอยู่ภายในอาเรย์ mysearchComparator - เป็นตัวเปรียบเทียบที่จะใช้ในการเปรียบเทียบสตริง

อ้างถึงArrays.binarySearchสำหรับข้อมูลเพิ่มเติม

if (Arrays.asList(array).contains(string))