Question

是否可以选择使用.contains()方法忽略大小写？

我有一个ArrayList的DVD对象。每个DVD对象都有一些元素，其中一个是标题。我有一个搜索特定标题的方法。它有效，但我希望它不区分大小写。

Answer 1

如果您使用的是Java 8

List<String> list = new ArrayList<>();

boolean containsSearchStr = list.stream().anyMatch("search_value"::equalsIgnoreCase);

Answer 2

我猜你的意思是在用字符串搜索时忽略大小写？

我不知道，但您可以尝试将字符串转换为搜索到较低或大写，然后搜索。

// s is the String to search into, and seq the sequence you are searching for.
bool doesContain = s.toLowerCase().contains(seq);

编辑：正如Ryan Schipper建议的那样，你也可以（也可能会更好）做seq.toLowerCase（），具体取决于你的情况。

Answer 3

private boolean containsIgnoreCase(List<String> list, String soughtFor) {
    for (String current : list) {
        if (current.equalsIgnoreCase(soughtFor)) {
            return true;
        }
    }
    return false;
}

Answer 4

这可能不是解决您的特定问题的最佳方法，但您可以使用String.matches(String regex)方法或匹配器。我们只需要从您的预期标题中构建一个正则表达式。这里很复杂。

List<DVD> matchingDvds(String titleFragment) {
    String escapedFragment = Pattern.quote(titleFragment);
    // The pattern may have contained an asterisk, dollar sign, etc.
    // For example, M*A*S*H, directed by Robert Altman.
    Pattern pat = Pattern.compile(escapedFragment, Pattern.CASE_INSENSITIVE);
    List<DVD> foundDvds = new ArrayList<>();
    for (DVD dvd: catalog) {
        Matcher m = pat.matcher(dvd.getTitle());
        if (m.find()) {
            foundDvds.add(dvd);
        }
    }
    return foundDvds;
}

但这是低效的，而且它纯粹是用Java完成的。你最好尝试其中一种技术：

了解Collator和CollationKey课程。
如果您别无选择，只能留在Java世界中，请向DVD添加方法boolean matches(String fragment)。让DVD告诉你它匹配的内容。
使用数据库。如果它支持不区分大小写的排序规则，则以此方式声明title表的DVD列。使用JDBC或Hibernate或JPA或Spring Data，无论您选择哪种。
如果数据库支持高级文本搜索，例如Oracle，请使用它。
回到Java世界，使用Apache Lucene，可能还有Apache Solr。
使用针对不区分大小写的匹配项调整的语言。

如果您可以等到Java 8，请使用lambda表达式。你可以通过这种方式构建正则表达式来避免我上面使用的Pattern和Matcher类：

   String escapedFragment = Pattern.quote(titleFragment);
   String fragmentAnywhereInString = ".*" + escapedFragment + ".*";
   String caseInsensitiveFragment = "(?i)" + fragmentAnywhereInString;
   // and in the loop, use:
   if(dvd.getTitle().matches(caseInsensitiveFragment)) {
        foundDvds.add(dvd);
    }

但是这种模式编译的次数太多了。低层套管怎么样？

if (dvd.getTitle().toLowerCase().contains(titleFragment.toLowerCase()))

恭喜;你刚刚发现了土耳其问题。除非您在toLowerCase中说明语言环境，否则Java会找到当前的语言环境。并且下壳很慢，因为它必须考虑土耳其无点我和点缀I.至少你没有图案，也没有匹配。

Answer 5

在Java 8中，您可以使用Stream接口：

return dvdList.stream().anyMatch(d -> d.getTitle().equalsIgnoreCase("SomeTitle"));

Answer 6

您无法保证始终会获得String个对象，或者您在List中使用的对象实现了忽略大小写的方法。

如果您确实希望将集合中的String与独立于案例的内容进行比较，您需要迭代集合并进行比较，无需大小写。

String word = "Some word";
List<String> aList = new ArrayList<>(); // presume that the list is populated

for(String item : aList) {
    if(word.equalsIgnoreCase(item)) {
        // operation upon successful match
    }
}

Answer 7

将两个操作数转换为小写（或大写）的直观解决方案具有为每个项目实例化额外String对象的效果，这对大型集合无效。此外，正则表达式比简单字符比较慢一个数量级。

String.regionMatches()允许以不区分大小写的方式比较两个String区域。使用它，可以编写一个不区分大小写的“包含”方法的有效版本。我使用以下方法;它基于Apache commons-lang的代码：

public static boolean containsIgnoreCase(final String str, final String searchStr) {
    if (str == null || searchStr == null) {
        return false;
    }
    final int len = searchStr.length();
    final int max = str.length() - len;
    for (int i = 0; i <= max; i++) {
        if (str.regionMatches(true, i, searchStr, 0, len)) {
            return true;
        }
    }
    return false;
}

Answer 8

 private List<String> FindString(String stringToLookFor, List<String> arrayToSearchIn)
 {
     List<String> ReceptacleOfWordsFound = new ArrayList<String>();

     if(!arrayToSearchIn.isEmpty())
     {
         for(String lCurrentString : arrayToSearchIn)
         {
             if(lCurrentString.toUpperCase().contains(stringToLookFor.toUpperCase())
                 ReceptacleOfWordsFound.add(lCurrentString);
         }
     }
  return ReceptacleOfWordsFound;
 }

Answer 9

对于Java 8，您可以再添加一个解决方案，如下所示

List<String> list = new ArrayList<>();
String searchTerm = "dvd";

if(String.join(",", list).toLowerCase().contains(searchTerm)) {
  System.out.println("Element Present!");
}

Answer 10

如果您正在寻找包含＆不等于然后我会提出以下解决方案。唯一的缺点是，如果您在以下解决方案中的searchItem是“ DE”，那么它也会匹配

    List<String> list = new ArrayList<>();
    public static final String[] LIST_OF_ELEMENTS = { "ABC", "DEF","GHI" };
    String searchItem= "def";

     if(String.join(",", LIST_OF_ELEMENTS).contains(searchItem.toUpperCase())) {
            System.out.println("found element");
            break;
    }

Answer 11

对dvdList和您的searchString进行空检查

    if (!StringUtils.isEmpty(searchString)) {
        return Optional.ofNullable(dvdList)
                       .map(Collection::stream)
                       .orElse(Stream.empty())
                       .anyMatch(dvd >searchString.equalsIgnoreCase(dvd.getTitle()));
      }

Answer 12

我知道我参加聚会有点晚了，但是在Kotlin中，您可以轻松使用：

fun Collection<String>.containsIgnoreCase(item: String) = any {
    it.equals(item, ignoreCase = true)
}


val list = listOf("Banana")

println(list.contains("banana"))
println(list.containsIgnoreCase("BaNaNa"))

Answer 13

Kotlin开发人员，请选择any / none

private fun compareCategory(
        categories: List<String>?,
        category: String
    ) = categories?.any { it.equals(category, true) } ?: false

Answer 14

对于 Java 8+，我建议使用以下库方法。

<块引用>

org.apache.commons.lang3.StringUtils

list.stream()
   .filter(text -> StringUtils.containsIgnoreCase(text, textToSearch))

Answer 15

你可以应用这个小技巧。
将所有字符串更改为相同案例：上限或小写
对于C＃代码：

列出searchResults = sl.FindAll（s =＆gt; s.ToUpper（） .Contains（ seachKeyword.ToUpper（）））;

对于Java代码：

import java.util.*; 

class Test
{
    public static void main(String[] args)
    {
        String itemCheck="check";
        ArrayList<String> listItem =new ArrayList<String>();
        listItem.add("Check");
        listItem.add("check");
        listItem.add("CHeck");
        listItem.add("Make");
        listItem.add("CHecK");
        for(String item :listItem)
        {
            if(item.toUpperCase().equals(itemCheck.toUpperCase()))
            {
                System.out.println(item);
            }
        }

    }

}

使用.contains方法忽略大小写的选项？

15 个答案: