我目前正在使用属于 ArrayList 类的 contains 方法进行搜索。有没有办法让这个搜索在java中不区分大小写？我发现在 C# 中可以使用 OrdinalIgnoreCase。是否有 java 等价物，或另一种方法来做到这一点？ 谢谢。
【问题讨论】：
contains 方法基于存储在 ArrayList 中的对象的 equals 方法返回的内容。所以是的，如果您使用 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();
}
}
【讨论】：
o.equalsIgnoreCase(contents)而不是o.toUpperCase().equals(contents.toUpperCase())？ equalsIgnoreCase() 可以更好地优化，并且可能不需要为两个大写字符串分配对象。
equalsIgnoreCase 确实是一个改进，我会相应地编辑我的回复
假设你有一个ArrayList<String>
我能想到的唯一方法是围绕字符串创建一个非常轻量级的包装类，并覆盖等于和哈希码以忽略大小写，尽可能利用equalsIgnoreCase()。然后你会有一个ArrayList<YourString>。不过，这有点丑陋。
【讨论】：
通过使用 compareToIgnoreCase，http://docs.oracle.com/javase/1.3/docs/api/java/lang/String.html#compareToIgnoreCase%28java.lang.String%29 你应该可以做你想做的事！
【讨论】：
您可以像使用任何其他 ArrayList 一样使用它。您可以将此 List 传递给其他代码，外部代码不必理解任何字符串包装类。
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;
}
}
【讨论】：
查看Java API，contains没有这种方法。
但你至少可以做两件事：
编写您自己的 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 的 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") == 0 或 list.indexOf("a") == 0 ..
您还应该考虑使用 Set 而不是 List。
【讨论】：
传统上，您可以开发自己的逻辑来比较 ArrayList 保存的字符串。可能有几种方法可以做到这一点，如下所示。
public boolean containsCaseInsensitive(String strToCompare, ArrayList<String>list)
{
for(String str:list)
{
if(str.equalsIgnoreCase(strToCompare))
{
return(true);
}
}
return(false);
}
为什么不应该使用一些直接方便的方式，例如如下所示的 SortedSet 和 case insensitive comparator?。
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，在这种特殊情况下，您的比较将毫无问题地进行。
【讨论】：
如果您使用的是 Java 8，请尝试：
List<String> list = ...;
String searchStr = ...;
boolean containsSearchStr = list.stream().filter(s -> s.equalsIgnoreCase(searchStr)).findFirst().isPresent();
【讨论】：
anyMatch 示例
不需要额外的功能，可以通过将比较的字符串转换为大写或小写来实现所需的结果
（我知道这已在 cmets 中提出，但没有完整地提供作为答案）
例如：在根据 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.
*/
}
【讨论】：
您可以使用来自 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
【讨论】：
在 Java8 中，使用 anyMatch
List<String> list = Arrays.asList("XYZ", "ABC");
String matchingText = "xYz";
boolean isMatched = list.stream().anyMatch(matchingText::equalsIgnoreCase);
【讨论】：
stream() 和 anyMatch() 需要 API 24。
这是将列表项转换为小写的最佳方式。转换后，您将使用包含方法。喜欢
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
}
}
【讨论】：
对于 java8
list.stream().anyMatch(s -> s.equalsIgnoreCase(yourString))
对于
【讨论】：
在我的例子中，因为我在 ArrayList 中的所有字符串都是小写的，所以我只对 contains() 参数执行 String.toLowerCase() 方法。像这样：
If (yourArrayList.contains (parameterInput.toLowerCase()) {
// your code here
}
如你所见，如果你的 arrayList 有大写字符串，你可以做相反的事情：
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));
}
【讨论】：
如果不想新建函数，可以试试这个方法：
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
}
}
【讨论】：
不要重新发明轮子。使用经过良好测试的 API。为您的目的使用Apache Commons StringUtils。
来自 Javadoc： 将给定的字符串与 searchStrings 的 CharSequences vararg 进行比较 如果字符串等于任何 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);
【讨论】：
虽然这个问题是专门针对 Java 提出的，但 Kotlin 中也存在同样的问题。
您可以为此使用适用于 List、Array 和 ArrayList 的扩展
fun Array<String>.contains(element: String, ignoreCase: Boolean): Boolean {
forEach { if (it.equals(element, ignoreCase = ignoreCase)) return true }
return false
}
【讨论】：