ArrayList包含区分大小写

2020/12/31 22:51 · java ·  · 0评论

我目前正在使用属于ArrayList类的contains方法进行搜索。有没有办法使此搜索在Java中不区分大小写?我发现在C#中可以使用OrdinalIgnoreCase。是否有等效的Java或另一种方式来做到这一点?谢谢。

您可以像使用其他任何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;
    }
}

在Java8中,使用anyMatch

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

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

如果您使用的是Java 8,请尝试:

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

传统上,您可以开发自己的逻辑来比较持有的字符串ArrayList可能有以下几种方式可以做到这一点。

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

为什么不应该使用一些直接且方便的方式,例如不区分大小写的比较器使用如下所示的SortedSet

Set<String> a = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);

a.add("A");
a.add("B");
a.add("C");


Set<String> b = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);

b.add("a");
b.add("b");
b.add("c");

System.out.println(b.equals(a));

true在这种特殊情况下,将比较两个不同的集合而不考虑case和return ,并且您的比较将毫无问题地进行。

看一下Java API,没有包含这种方法。

但是您至少可以做两件事:

  1. 用您自己的或equalsIgnoreCase(str)覆盖ArrayList对象中的equals方法
  2. 编写您自己的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<String>

我能想到的唯一方法是在String周围创建一个非常轻巧的包装类,并覆盖equals和hashcode以忽略大小写,equalsIgnoreCase()并尽可能利用然后,您将拥有一个ArrayList<YourString>不过,这有点丑陋。

您可以使用collections4(apache)中的IterableUtils和Predicate。

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

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

IterableUtils(collections4):org.apache.commons.collections4.IterableUtils.html

contains方法基于equals您的ArrayList退货中存储的对象方法因此,可以,如果您使用的对象equals使用不区分大小写的比较。

因此,您可以例如使用此类(代码可能仍包含一些错字)

public class CaseInsensitiveString{
  private final String contents;

  public CaseInsensitiveString( String contents){ this.contents = contents; }

  public boolean equals( Object o ){
    return o != null && o.getClass() == getClass() && o.contents.equalsIgnoreCase( contents);
  }

  public int hashCode(){
    return o.toUpperCase().hashCode();
  }
}

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

另一个解决方案:

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

contains()方法使用indexOf ...在这种解决方案中,您还可以知道字符串在何处。list.add("a")->list.indexOf("A") == 0list.indexOf("a") == 0..

您还应该考虑使用Set而不是List。

对于java8

list.stream()。anyMatch(s-> s.equalsIgnoreCase(yourString))

对于<java8

  • 正如上述Aaron J Lang所建议
  • 或者,如果您知道列表的大小写(全部大写/全部小写),则在比较之前将搜索字符串转换为适当的大小写

就我而言,由于ArrayList中的所有字符串均为小写形式,因此我只执行String。contains()参数上的toLowerCase()方法。像这样:

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

如您所见,如果arrayList具有upperCase字符串,则可以做相反的事情:

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

使用这种方法,您无需覆盖任何内容。当您的arrayList包含大小写混合时,例外。

我会这样:

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

不需要附加功能,可以通过将比较的字符串转换为大写或小写字母来实现所需的结果

(我知道这已在评论中提出,但并未提供完整答案)

例如:根据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.
     */
}

不要重新发明轮子。使用经过良好测试的API。为了您的目的,请使用Apache Commons StringUtils

从Javadoc:
将给定的字符串与searchStrings的CharSequences变量比较,如果该字符串等于任何searchStrings,则返回true,忽略大小写。

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

这是将列表项转换为小写字母的最佳方法。转换后,您将使用包含方法。喜欢

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

使用上面创建的创建小写列表 name_list

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
   }
}

如果您不想创建新函数,可以尝试以下方法:

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
   }
}

通过使用compareToIgnoreCase(http://docs.oracle.com/javase/1.3/docs/api/java/lang/String.html#compareToIgnoreCase%28java.lang.String%29),您应该能够执行想要的操作!

本文地址:http://java.askforanswer.com/arraylistbaohanqufendaxiaoxie.html
文章标签: ,  
版权声明:本文为原创文章,版权归 admin 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!