73

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

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

4

17 回答 17

186

如果您使用的是 Java 8

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

boolean containsSearchStr = list.stream().anyMatch("search_value"::equalsIgnoreCase);
于 2016-07-18T11:21:05.907 回答
34

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

我不知道，但是您可以尝试将要搜索的字符串转换为小写或大写，然后进行搜索。

// 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()，具体取决于您的情况。

于 2013-04-05T02:08:30.663 回答
15 
private boolean containsIgnoreCase(List<String> list, String soughtFor) {
    for (String current : list) {
        if (current.equalsIgnoreCase(soughtFor)) {
            return true;
        }
    }
    return false;
}
于 2014-07-18T16:14:47.177 回答
8

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

return dvdList.stream().anyMatch(d -> d.getTitle().equalsIgnoreCase("SomeTitle"));
于 2016-07-25T21:43:02.580 回答
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 中完成的。您最好尝试以下技术之一：

  1. 学习Collator和CollationKey类。
  2. 如果您别无选择，只能留在 Java 世界中，请在 DVD 中添加一个方法，boolean matches(String fragment). 让 DVD 告诉您匹配的内容。
  3. 使用数据库。如果它支持不区分大小写的排序规则，则以这种方式声明表的title列DVD。使用 JDBC 或 Hibernate 或 JPA 或 Spring Data，无论您选择哪个。
  4. 如果数据库支持高级文本搜索，如 Oracle，请使用它。
  5. 回到 Java 世界，使用Apache Lucene并可能使用Apache Solr.
  6. 使用针对不区分大小写匹配而调整的语言。

如果您可以等到 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()))

恭喜；你刚刚发现了土耳其问题。除非您在 中声明语言环境，否则toLowerCaseJava 会查找当前语言环境。小写字母很慢，因为它必须考虑土耳其的无点 i 和带点 I。至少你没有模式和匹配器。

于 2013-04-05T02:34:36.387 回答
3

我知道我参加聚会有点晚了，但在 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"))
于 2020-11-04T14:23:01.720 回答
3

Kotlin 开发者，选择任何/无

private fun compareCategory(
        categories: List<String>?,
        category: String
    ) = categories?.any { it.equals(category, true) } ?: false
于 2020-11-13T07:31:45.420 回答
2

你不能保证你总是能取回String对象，或者你在List实现中使用的对象是一种忽略大小写的方法。

如果您确实想将String集合中的 s 与不区分大小写的内容进行比较，则需要遍历集合并在不区分大小写的情况下比较它们。

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
    }
}
于 2013-04-05T02:04:18.330 回答
2

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

String.regionMatches()允许以不区分大小写的方式比较两个字符串区域。使用它，可以编写不区分大小写的“包含”方法的有效版本。以下方法是我使用的；它基于 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;
}
于 2014-08-19T23:24:00.510 回答
2

您可以使用 stream() 将 contains() 替换为 equalsIgnoreCase，如下所示

    List<String> names = List.of("One","tWo", "ThrEe", "foUR", "five", "Six", "THREE");
    boolean contains = names.stream().filter(i -> i.equalsIgnoreCase("three")).collect(Collectors.toList()).size() > 0;
于 2022-01-27T16:02:42.800 回答
1

使用 Kotlin 扩展功能的强大功能非常简单，这个答案可能对 Java 和 Kotlin 开发人员有所帮助。

inline fun List<String>.contains(text: String, ignoreCase: Boolean = false) = this.any { it.equals(text, ignoreCase) }

// Usage
list.contains("text", ignoreCase = true)
于 2021-09-28T11:46:33.067 回答
0 
 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;
 }
于 2013-11-27T17:27:39.830 回答
0

对于 Java 8，您可以使用以下另一种解决方案

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

if(String.join(",", list).toLowerCase().contains(searchTerm)) {
  System.out.println("Element Present!");
}
于 2017-11-07T08:41:26.950 回答
0

如果您正在寻找包含 & 不等于，那么我会提出以下解决方案。唯一的缺点是，如果您在以下解决方案中的 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;
    }
于 2019-10-11T18:04:23.120 回答
0

对 thedvdList和您的进行空检查searchString

    if (!StringUtils.isEmpty(searchString)) {
        return Optional.ofNullable(dvdList)
                       .map(Collection::stream)
                       .orElse(Stream.empty())
                       .anyMatch(dvd >searchString.equalsIgnoreCase(dvd.getTitle()));
      }
于 2020-07-23T21:25:44.397 回答
0

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

org.apache.commons.lang3.StringUtils

list.stream()
   .filter(text -> StringUtils.containsIgnoreCase(text, textToSearch))
于 2021-07-26T11:30:03.397 回答
-1

您可以对此应用小技巧。
将所有字符串更改为相同的大小写：大写或小写
对于 C# 代码：

列出 searchResults = sl.FindAll(s => 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);
            }
        }

    }

}
于 2015-07-27T07:51:23.223 回答