ArrayList содержит чувствительность к регистру

В настоящее время я использую метод contains, принадлежащий классу ArrayList для выполнения поиска. Есть ли способ сделать этот регистр поиска нечувствительным в java? Я обнаружил, что в С# можно использовать OrdinalIgnoreCase. Есть ли эквивалент java или другой способ сделать это? Спасибо.

ОТВЕТЫ

Ответ 1

Вы можете использовать это точно так же, как если бы вы использовали любой другой 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;
    }
}

Ответ 2

Если вы используете Java 8, попробуйте:

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

Ответ 3

В Java8, используя anyMatch

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

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

Ответ 4

Традиционно вы можете разработать свою собственную логику для сравнения строк, хранящихся в 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));

Будет сравнивать два разных набора, игнорируя case и return true, в этой конкретной ситуации, и ваше сравнение будет работать без каких-либо проблем.

Ответ 5

Глядя на API Java, такого метода для этого нет.

Но вы могли бы сделать как минимум две вещи:

  • Переопределите метод equals в объекте ArrayList с вашим собственным или equalsIgnoreCase (str)

  • Напишите свой собственный метод 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;
}

Ответ 6

Предполагая, что у вас есть ArrayList<String>

О том, как я могу это сделать, можно было бы создать очень легкий класс-оболочку вокруг строки и переопределить равные и хэш-коды, чтобы игнорировать регистр, используя equalsIgnoreCase(), где это возможно. Тогда у вас будет ArrayList<YourString>. Это своего рода уродливая идея.

Ответ 7

Вы можете использовать IterableUtils и Predicate из collections4 (apache).

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

Ответ 8

Метод 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();
  }
}

Ответ 9

Метод 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")));
    }
}

Ответ 10

Другое решение:

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

Вы также должны рассмотреть возможность использования набора вместо списка.

Ответ 11

Для java8

list.stream(). anyMatch (s → s.equalsIgnoreCase(yourString))

Для < java8

  • как было предложено Aaron J Lang выше
  • Или, если вы знаете случай вашего списка (все верхние/все нижние), затем преобразуйте строку поиска в соответствующий регистр перед сравнением

Ответ 12

В моем случае, поскольку все мои строки в ArrayList находятся в нижнем регистре, я просто запускаю метод String. toLowerCase() в параметре contains(). Вот так:

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

Как вы можете видеть, вы можете сделать oposite, если yout arrayList имеет строки upperCase:

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

Используя этот подход, вам не нужно ничего переопределять. Исключение составляет случай, когда ваш массивList имеет сочетание верхних и нижних регистров.

Ответ 13

Нет необходимости в дополнительной функции, желаемые результаты могут быть достигнуты путем литья сравниваемых строк как в верхнем, так и в нижнем регистре

(Я знаю, что это было предложено в комментариях, но не полностью представлено в качестве ответа)

Ex: игнорирует регистр при фильтрации содержимого JList на основе ввода, предоставленного с помощью JTextField:

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 being passed by reference, it 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.
     */
}

Ответ 14

Это лучший способ конвертировать элемент списка в нижний регистр. После преобразования вы будете использовать метод contains. как

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

Ответ 15

Я бы сделал так:

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

Ответ 16

Если вы не хотите создавать новую функцию, вы можете попробовать этот метод:

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

Ответ 17

Не изобретайте велосипед. Используйте проверенные API. Для вашей цели используйте Apache Commons StringUtils.

Из Javadoc: сравнивает заданную строку с charSequences vararg searchStrings, возвращающим значение true, если строка равна любому из элементов searchStrings, игнорируя регистр.

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