Java ArrayList包含大小写敏感度

我目前正在使用ArrayList类的contains方法进行搜索。有没有办法在java中使此搜索不区分大小写？我发现在C#中可以使用OrdinalingOrecase。是否有java等价物或其他方法可以做到这一点？

---

谢谢。

contains方法基于存储在

数组列表中的对象的
方法所返回的值。因此，如果使用
等于
的对象使用不区分大小写的比较，这是可能的

例如，您可以使用这样的类（代码可能仍然包含一些拼写错误）

假设您有一个
ArrayList

List<String> name_lowercase_list = new ArrayList<>();
for(int i =0 ; i<name_list.size(); i++){
 name_lowercase_list.add(name_list.get(i).toLowerCase().toString()); 
}

for(int i =0 ; i<name_list.size(); i++){
  String lower_case_name =  name_list.get(i).toLowerCase().toString();
  if(name_list.get(i).contains(your compare item) ||
   name_lowercase_list.get(i).contains(your compare item) ){
     //this will return true
   }
}

我能想到的唯一方法是围绕字符串创建一个非常简单的包装类，并覆盖equals和hashcode以忽略大小写，尽可能利用
equalsIgnoreCase（）
。然后您将拥有一个
ArrayList
。这是一个很糟糕的想法。
通过使用compareToIgnoreCase，你应该能够做你想做的事情
 您可以像使用任何其他ArrayList一样使用它。您可以将此列表传递给其他代码，外部代码不必理解任何字符串包装器类

public class CustomStringList3 extends ArrayList<String> {
    @Override
    public boolean contains(Object o) {
        String paramStr = (String)o;
        for (String s : this) {
            if (paramStr.equalsIgnoreCase(s)) return true;
        }
        return false;
    }
}

公共类CustomStringList3扩展了ArrayList{
@凌驾
公共布尔包含（对象o）{
字符串paramStr=（字符串）o；
for（字符串s:此）{
if（paramStr.equalsIgnoreCase）返回true；
}
返回false；
}
}
查看，对于contains没有这样的方法

但你至少可以做两件事：

使用自己的或equalsIgnoreCase（str）重写ArrayList对象中的equals方法
编写自己的contains方法，该方法应遍历ArrayList实体，并进行手动检查

ArrayList<String> list = new ArrayList<String>();
...
containsIgnoreCase("a", list);

public boolean containsIgnoreCase(String str, ArrayList<String> list){
    for(String i : list){
        if(i.equalsIgnoreCase(str))
            return true;
    }
    return false;
}

ArrayList list=new ArrayList（）；
...
containsIgnoreCase（“a”，列表）；
公共布尔containsSignoreCase（字符串str，ArrayList列表）{
for（字符串i:列表）{
if（i.等信号情况（str））
返回true；
}
返回false；
}

ArrayList的contains（）方法通过对提供的对象（而不是数组中的对象）调用equals（）方法来检查相等性。因此，一种略显粗俗的方法是围绕String对象创建一个包装器类，如下所示：

class InsensitiveStringComparable {
    private final String val;

    public InsensitiveStringComparable(String val) {
        this.val = val;
    }

    @Override
    public boolean equals(Object x) {
        if (x == this)
            return true;
        else if (x == null)
            return false;
        else if (x instanceof InsensitiveStringComparable)
            return ((InsensitiveStringComparable) x).val.equalsIgnoreCase(val);
        else if (x instanceof String)
            /* Asymmetric equals condition */
            return val.equalsIgnoreCase((String) x);
        else
            return false;
    }

    @Override
    public int hashCode() {
        return val.toUpperCase().hashCode();
    }
}

然后您可以使用它来执行测试。“手动”测试用例示例：

public class Test {
    public static void main(String[] args) {
        ArrayList<Object> a = new ArrayList<Object>();
        a.add("test");
        System.out.println(a.contains(new InsensitiveStringComparable("TEST")));
        System.out.println(a.contains(new InsensitiveStringComparable("tEsT")));
        System.out.println(a.contains(new InsensitiveStringComparable("different")));
    }
}

公共类测试{
公共静态void main（字符串[]args）{
ArrayList a=新的ArrayList（）；
a、 添加（“测试”）；
System.out.println（a.contains（新的不敏感项比较（“测试”））；
System.out.println（a.contains（新的不敏感项比较（“测试”））；
System.out.println（a.contains（新的不敏感项比较（“不同”））；
}
}
另一种解决方案：

public class IgnorecaseList extends ArrayList<String>{

    @Override
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    } 

    @Override
    public int indexOf(Object o) {
        if(o instanceof String){
            for (int i = 0; i < this.size(); i++) {
                if(((String)o).equalsIgnoreCase(get(i))){
                    return i;
                }
            }
        }
        return -1;
    }
}

公共类IgnorecaseList扩展了ArrayList{
@凌驾
公共布尔包含（对象o）{
返回索引of（o）>=0；
} 
@凌驾
public int indexOf（对象o）{
如果（字符串的o实例）{
对于（int i=0；i

contains（）
方法使用。。。在这个解中，您还可以知道字符串的位置<代码>列表。添加（“a”）
->
列表。索引（“a”）==0
或
列表。索引（“a”）==0

您还应该考虑使用SET而不是列表。
传统上，您可以开发自己的逻辑来比较AN所持有的字符串。有几种方法可以做到这一点，如下所示
public boolean containsCaseInsensitive(String strToCompare, ArrayList<String>list)
{
    for(String str:list)
    {
        if(str.equalsIgnoreCase(strToCompare))
        {
            return(true);
        }
    }
    return(false);
}

public boolean containscasensitive（字符串strotcompare，ArrayListlist）
{
for（字符串str:list）
{
if（str.equalsIgnoreCase（strToCompare））
{
返回（真）；
}
}
返回（假）；
}

为什么不应该使用一些直接和方便的方式，如下面显示的带？的SortedSet

Set a=new TreeSet（String.CASE不区分大小写\u顺序）；
a、 添加（“a”）；
a、 添加（“B”）；
a、 添加（“C”）；
Set b=新树集（字符串不区分大小写顺序）；
b、 添加（“a”）；
b、 添加（“b”）；
b、 添加（“c”）；
系统输出println（b等于（a））；

将比较两个不同的集合忽略大小写并返回
true
，在这种特定情况下，您的比较将不会出现任何问题。
如果您使用的是Java 8，请尝试：

List<String> list = ...;
String searchStr = ...;
boolean containsSearchStr = list.stream().filter(s -> s.equalsIgnoreCase(searchStr)).findFirst().isPresent();

List=。。。；
字符串searchStr=。。。；
布尔containsSearchStr=list.stream（）.filter（s->s.equalsIgnoreCase（searchStr））.findFirst（）.isPresent（）；
对于附加函数，不需要将比较的字符串转换为大写或小写，即可获得所需的结果

（我知道评论中已经提出了这一点，但并没有作为一个完整的答案提供）

例如：根据JTextField提供的输入过滤JList的内容时忽略大小写：

private ArrayList<String> getFilteredUsers(String filter, ArrayList<User> users) {
    ArrayList<String> filterUsers = new ArrayList<>();
    users.stream().filter((user) -> (user.getUsername().toUpperCase().contains(filter.toUpperCase()))).forEach((user)-> {
        filterUsers.add(user.getUsername());
    });
    this.userList.setListData(filterUsers.toArray());
    return filterUsers;
    /** 
     *  I see the redundancy in returning the object... so even though,
     *  it is passed by reference you could return type void; but because
     *  it's being passed by reference, it's a relatively inexpensive
     *  operation, so providing convenient access with redundancy is just a 
     *  courtesy, much like putting the seat back down. Then, the next
     *  developer with the unlucky assignment of using your code doesn't 
     *  get the proverbially dreaded "wet" seat.
     */
}

专用ArrayList getFilteredUsers（字符串筛选器，ArrayList用户）{
ArrayList filterUsers=新的ArrayList（）；
users.stream（）.filter（（用户）->（user.getUsername（）.toUpperCase（）.contains（filter.toUpperCase（）））.forEach（（用户）->{
添加（user.getUsername（））；
});
this.userList.setListData（filterUsers.toArray（））；
返回过滤器；
/** 
*我在返回对象时看到了冗余…所以即使，
*它是通过引用传递的，您可以返回类型void；但是因为
*它是通过引用传递的，这是一种相对便宜的方法
*操作，因此提供方便的访问和冗余只是一个简单的问题
*礼貌，就像把座位放下来。然后，下一个
*不幸被指派使用您的代码的开发人员不会
*坐上众所周知的“湿”座位。
*/
}
您可以从中使用iterabluetils和谓词
private ArrayList<String> getFilteredUsers(String filter, ArrayList<User> users) {
    ArrayList<String> filterUsers = new ArrayList<>();
    users.stream().filter((user) -> (user.getUsername().toUpperCase().contains(filter.toUpperCase()))).forEach((user)-> {
        filterUsers.add(user.getUsername());
    });
    this.userList.setListData(filterUsers.toArray());
    return filterUsers;
    /** 
     *  I see the redundancy in returning the object... so even though,
     *  it is passed by reference you could return type void; but because
     *  it's being passed by reference, it's a relatively inexpensive
     *  operation, so providing convenient access with redundancy is just a 
     *  courtesy, much like putting the seat back down. Then, the next
     *  developer with the unlucky assignment of using your code doesn't 
     *  get the proverbially dreaded "wet" seat.
     */
}

List<String> pformats= Arrays.asList("Test","tEst2","tEsT3","TST4");

Predicate<String> predicate  = (s) -> StringUtils.equalsIgnoreCase(s, "TEST");
if(IterableUtils.matchesAny(pformats, predicate)) {
    // do stuff
}

List<String> list = Arrays.asList("XYZ", "ABC");
String matchingText = "xYz";

boolean isMatched = list.stream().anyMatch(matchingText::equalsIgnoreCase);

List<String> name_list = new ArrayList<>();
name_list.add("A");
name_list.add("B");

List<String> name_lowercase_list = new ArrayList<>();
for(int i =0 ; i<name_list.size(); i++){
 name_lowercase_list.add(name_list.get(i).toLowerCase().toString()); 
}

for(int i =0 ; i<name_list.size(); i++){
  String lower_case_name =  name_list.get(i).toLowerCase().toString();
  if(name_list.get(i).contains(your compare item) ||
   name_lowercase_list.get(i).contains(your compare item) ){
     //this will return true
   }
}

If (yourArrayList.contains (parameterInput.toLowerCase()) {
    // your code here
}

If (yourArrayList.contains (parameterInput.toUpperCase ()) {
    // your code here
}

public boolean isStringInList(final List<String> myList, final String stringToFind) {
    return myList.stream().anyMatch(s -> s.equalsIgnoreCase(stringToFind));
}  

List<String> myList = new ArrayList<String>(); //The list you're checking
String wordToFind = "Test"; //or scan.nextLine() or whatever you're checking

//If your list has mix of uppercase and lowercase letters letters create a copy...
List<String> copyList = new ArrayList<String>();
for(String copyWord : myList){
   copyList.add(copyWord.toLowerCase());
}

for(String myWord : copyList){
   if(copyList.contains(wordToFind.toLowerCase()){
      //do something
   }
}

import org.apache.commons.lang3.StringUtils;
...
StringUtils.equalsAnyIgnoreCase(null, (CharSequence[]) null) = false
StringUtils.equalsAnyIgnoreCase(null, null, null)    = true
StringUtils.equalsAnyIgnoreCase(null, "abc", "def")  = false
StringUtils.equalsAnyIgnoreCase("abc", null, "def")  = false
StringUtils.equalsAnyIgnoreCase("abc", "abc", "def") = true
StringUtils.equalsAnyIgnoreCase("abc", "ABC", "DEF") = true

  List<String> list = Arrays.asList("XYZ", "ABC");
    String matchingText = "XYZ1";
        boolean isMatched = list.stream().anyMatch(matchingText::equalsIgnoreCase);
        System.out.println(isMatched);

List<String> list1= Arrays.asList("XYZ", "ABC");
String searchStr = "abC";
boolean containsSearchStr = list1.stream().filter(searchStr::equalsIgnoreCase).findFirst().isPresent();
System.out.println(containsSearchStr);

fun Array<String>.contains(element: String, ignoreCase: Boolean): Boolean {
  forEach { if (it.equals(element, ignoreCase = ignoreCase)) return true }
  return false
}