Option pour ignorer la casse avec .contient de la méthode?

Si vous êtes à l'aide de Java 8

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

boolean containsSearchStr = list.stream().anyMatch("search_value"::equalsIgnoreCase);

Ce n'est probablement pas la meilleure façon pour votre problème particulier, mais vous pouvez utiliser le String.matches(String regex) méthode ou le matcher équivalent. Nous avons juste besoin de construire une expression régulière à partir de votre éventuel titre. Ici, il devient complexe.

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

Mais c'est inefficace, et qu'il se fait purement Java. Vous feriez mieux d'essayer l'une de ces techniques:

1. Apprendre le Collator et CollationKey classes.
2. Si vous n'avez pas d'autre choix que de rester dans le monde Java, ajoutez une méthode de DVD, boolean matches(String fragment). Ont le DVD vous dire à quoi il correspond.
3. Utiliser une base de données. Si elle prend en charge la casse, les classements, déclarer la title colonne de la DVD table de cette façon. L'utilisation de JDBC ou Hibernate ou JPA ou de source de Données, selon que vous choisissez.
4. Si la base de données prend en charge avancée de la recherche de texte, comme Oracle, utilisez-le.
5. De retour dans le monde Java, l'utilisation Apache Lucene et, éventuellement,Apache Solr.
6. L'utilisation d'une langue à l'écoute pour la casse correspond.

Si vous pouvez attendre jusqu'à ce que Java 8, l'utilisation des expressions lambda. Vous pouvez éviter le Pattern et Matcher classe que j'ai utilisé ci-dessus par la construction de l'expression régulière de cette façon:

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

Mais cette compile le motif de trop nombreuses fois. Qu'en est inférieur boîtier tout?

if (dvd.getTitle().toLowerCase().contains(titleFragment.toLowerCase()))

Félicitations; vous venez de découvrir le turc problème. À moins que vous l'état de la locale dans toLowerCase, Java trouve la locale courante. Et le bas du corps est lent car il doit prendre en compte le turc sans point i et parsemée I. Au moins vous n'avez pas de modèles et pas de rapprochement.

Vous ne pouvez pas garantir que vous êtes toujours va obtenir String des objets, ou que l'objet que vous travaillez dans le List met en œuvre un moyen d'ignorer la casse.

Si vous ne souhaitez comparer Strings dans une collection de quelque chose d'indépendant de cas, vous souhaitez effectuer une itération sur la collection et de les comparer sans cas.

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

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

Si vous êtes à la recherche pour le contient & pas des égaux, alors je voudrais vous proposons ci-dessous la solution.
Le seul inconvénient est que si votre searchItem ci-dessous la solution est "DE", puis aussi il pourrait correspondre à

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