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

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

use s1.equalsIgnoreCase (s2)
http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html#equalsIgnoreCase(java.lang.Object)

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
Intereting Posts