Como faço para que meu caso de comparação de strings seja insensível?

Eu criei um programa em Java para comparar duas strings:

String s1 = "Hello"; String s2 = "hello"; if (s1.equals(s2)) { System.out.println("hai"); } else { System.out.println("welcome"); } 

Ele exibe “bem-vindo”. Eu entendo é case sensitive. Mas meu problema é que eu quero comparar duas seqüências de caracteres sem diferenciação de maiúsculas e minúsculas. Ou seja, espero que a saída seja hai .

  • O melhor seria usar s1.equalsIgnoreCase(s2) : (veja javadoc )
  • Você também pode convertê-los para maiúsculas / minúsculas e usar s1.equals(s2)

use String.equalsIgnoreCase()

Use a referência da API Java para encontrar respostas como essas.

http://java.sun.com/j2se/1.5.0/docs/api/java/lang/String.html#equalsIgnoreCase(java.lang.String)

http://java.sun.com/j2se/1.5.0/docs/api/

String.equalsIgnoreCase é a opção mais prática para comparação de strings sem distinção entre maiúsculas e minúsculas.

No entanto, é bom estar ciente de que esse método não faz nem o desdobramento nem a decomposição de maiúsculas e minúsculas e, portanto, não pode executar a correspondência sem o uso de um object, conforme especificado no padrão Unicode. Na verdade, as APIs do JDK não fornecem access a informações sobre dados de caracteres de dobra de caso, portanto, esse trabalho é melhor delegado a uma biblioteca de terceiros testada e comprovada.

Essa biblioteca é ICU , e aqui está como se pode implementar um utilitário para comparação de cadeias sem distinção entre maiúsculas e minúsculas:

 import com.ibm.icu.text.Normalizer2; // ... public static boolean equalsIgnoreCase(CharSequence s, CharSequence t) { Normalizer2 normalizer = Normalizer2.getNFKCCasefoldInstance(); return normalizer.normalize(s).equals(normalizer.normalize(t)); } 
  String brook = "flu\u0308ßchen"; String BROOK = "FLÜSSCHEN"; assert equalsIgnoreCase(brook, BROOK); 

Comparações String.equalsIgnoreCase com String.equalsIgnoreCase ou String.equals em strings com letras maiúsculas ou minúsculas falharão até mesmo neste teste simples.

(Observe, entretanto, que o sabor de dobra de caso predefinido getNFKCCasefoldInstance é independente de localidade; para localidades turcas um pouco mais de trabalho envolvendo UCharacter.foldCase pode ser necessário.)

Você tem que usar o método compareToIgnoreCase do object String .

 int compareValue = str1.compareToIgnoreCase(str2); 

if (compareValue == 0) significa que str1 é igual a str2 .

 import java.lang.String; //contains equalsIgnoreCase() /* * */ String s1 = "Hello"; String s2 = "hello"; if (s1.equalsIgnoreCase(s2)) { System.out.println("hai"); } else { System.out.println("welcome"); } 

Agora vai sair: hai

Na API Java padrão, você tem:

 String.CASE_INSENSITIVE_ORDER 

Portanto, você não precisa rewrite um comparador se quiser usar strings com estruturas de dados ordenadas.

 String s = "some text here"; s.equalsIgnoreCase("Some text here"); 

É o que você deseja para verificações de igualdade pura em seu próprio código.

Apenas para mais informações sobre qualquer coisa relacionada à igualdade de Strings em Java. A function hashCode () da class java.lang.String “é sensível a maiúsculas e minúsculas”:

 public int hashCode() { int h = hash; if (h == 0 && value.length > 0) { char val[] = value; for (int i = 0; i < value.length; i++) { h = 31 * h + val[i]; } hash = h; } return h; } 

Então, se você quiser usar um Hashtable / HashMap com Strings como chaves, e ter chaves como "SomeKey", "Someomekey" e "somekey" ser visto como igual, então você terá que quebrar sua string em outra class (você não pode estender Cadeia desde que é uma class final). Por exemplo :

 private static class HashWrap { private final String value; private final int hash; public String get() { return value; } private HashWrap(String value) { this.value = value; String lc = value.toLowerCase(); this.hash = lc.hashCode(); } @Override public boolean equals(Object o) { if (this == o) return true; if (o instanceof HashWrap) { HashWrap that = (HashWrap) o; return value.equalsIgnoreCase(that.value); } else { return false; } } @Override public int hashCode() { return this.hash; } } 

e depois usá-lo como tal:

 HashMap map = new HashMap(); 

Note que você pode querer fazer verificações nulas sobre eles também antes de fazer o seu .equals ou .equalsIgnoreCase.

Um object String nulo não pode chamar um método equals.

ie:

 public boolean areStringsSame(String str1, String str2) { if (str1 == null && str2 == null) return true; if (str1 == null || str2 == null) return false; return str1.equalsIgnoreCase(str2); } 

Você pode usar equalsIgnoreCase

Mais sobre string pode ser encontrado em Classes de String e Tutoriais de String

Para ser nullsafe, você pode usar

 org.apache.commons.lang.StringUtils.equalsIgnoreCase(String, String) 

ou

 org.apache.commons.lang3.StringUtils.equalsIgnoreCase(CharSequence, CharSequence) 
 public boolean newEquals(String str1, String str2) { int len = str1.length(); int len1 = str2.length(); if(len==len1) { for(int i=0,j=0;i