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
.
s1.equalsIgnoreCase(s2)
: (veja javadoc ) 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)
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