¿Existe un método de biblioteca existente que compruebe si una cadena es mayúscula o minúscula en Java?

Question

Sé que hay muchos métodos upper() en Java y otros frameworks como Apache commons lang, que convierten un String en mayúsculas.

¿Hay alguna biblioteca común que proporcione un método como isUpper(String s) y isLower(String s), para comprobar si todos los caracteres en la cadena son mayúsculas o minúsculas?

EDIT:

Muchas buenas respuestas acerca de la conversión de Alto y comparando con esto. Creo que debería haber sido un poco más específico, y dije que ya había pensado en eso, pero esperaba poder usar un método existente para esto.

Buen comentario sobre la posible inclusión de esto en apache.commons.lang.StringUtils. Alguien ha enviado un parche (20090310). Con suerte, veremos esto pronto. https://issues.apache.org/jira/browse/LANG-471

EDIT:

Lo que necesitaba este método para, era capitalizar nombres de hoteles que a veces venían en mayúsculas. Solo quería capitalizarlos si fueran mayúsculas o minúsculas. me he corrido en que los problemas con caracteres no carta mencionados en algunos de los puestos, y terminé haciendo algo como esto:

private static boolean isAllUpper(String s) { 
    for(char c : s.toCharArray()) { 
     if(Character.isLetter(c) && Character.isLowerCase(c)) { 
      return false; 
     } 
    } 
    return true; 
} 

Esta discusión y soluciones diferentes (con diferentes problemas), muestra claramente que existe una necesidad de un buen método sólido es AllUpper (String s) en commons.lang

Hasta entonces supongo que el myString.toUpperCase().equals(myString) es la mejor manera de hacerlo.

Answer 1

de guayaba CharMatchers tienden a ofrecer soluciones muy expresivos y eficientes a este tipo de problema.

CharMatcher.javaUpperCase().matchesAllOf("AAA"); // true 
CharMatcher.javaUpperCase().matchesAllOf("A SENTENCE"); // false 
CharMatcher.javaUpperCase().or(CharMatcher.whitespace()).matchesAllOf("A SENTENCE"); // true 
CharMatcher.javaUpperCase().or(CharMatcher.javaLetter().negate()).matchesAllOf("A SENTENCE"); // true 
CharMatcher.javaLowerCase().matchesNoneOf("A SENTENCE"); // true 

Un importación estática para com.google.common.base.CharMatcher.* puede ayudar a hacer estos más sucinta.

javaLowerCase().matchesNoneOf("A SENTENCE"); // true 

Answer 2

No es que yo sepa.

Puede copiar la cadena y convertir la copia a mayúscula/minúscula y compararla con la original.

O cree un bucle que verifique los caracteres individuales si se trata de mayúsculas o minúsculas.

Answer 3

Este método puede ser más rápido que la comparación de una cadena en su versión en mayúsculas, ya que requiere sólo 1 paso:

public static boolean isUpper(String s) 
{ 
    for(char c : s.toCharArray()) 
    { 
     if(! Character.isUpperCase(c)) 
      return false; 
    } 

    return true; 
} 

Tenga en cuenta que puede haber algunos problemas de localización con diferentes juegos de caracteres. No tengo ninguna experiencia de primera mano, pero creo que hay algunos idiomas (como el turco) donde las letras minúsculas diferentes se pueden asignar a la misma letra mayúscula.

Answer 4

Puede usar java.lang.Character.isUpperCase() Luego puede escribir fácilmente un método que verifique si su cadena está en mayúscula (con un simple bucle).

Enviar el mensaje aUpperCase() a su cadena y luego comprobar si el resultado es igual a su cadena será probablemente más lenta.

Answer 5

Desafortunadamente no es una función de biblioteca, pero es bastante fácil de hacer la suya propia. Si la eficiencia es una preocupación, esto podría ser más rápido que en el caso de UpperCase(). Equals (s) porque puede rescatar temprano.

public static boolean isUpperCase(String s) 
{ 
    for (int i=0; i<s.length(); i++) 
    { 
     if (!Character.isUpperCase(s.charAt(i))) 
     { 
      return false; 
     } 
    } 
    return true; 
} 

Editar: Como han señalado otros carteles y comentaristas, debemos tener en cuenta el comportamiento cuando la cadena contiene caracteres que no sean letras: debe isUpperCase ("hello1") devuelven verdadero o falso? La función anterior devolverá falso porque '1' no es un carácter en mayúscula, pero posiblemente este no sea el comportamiento que desea. Una definición alternativa que devolvería verdadera en este caso sería:

public static boolean isUpperCase2(String s) 
{ 
    for (int i=0; i<s.length(); i++) 
    { 
     if (Character.isLowerCase(s.charAt(i))) 
     { 
      return false; 
     } 
    } 
    return true; 
} 

Answer 6

Pruebe esto, puede ayudar.

import java.util.regex.Pattern; 

private static final String regex ="^[A-Z0-9]"; //alpha-numeric uppercase 
public static boolean isUpperCase(String str){ 
    return Pattern.compile(regex).matcher(str).find(); 
} 

con este código, solo cambiamos la expresión regular.

Answer 7

Ahora en StringUtils isAllUpperCase

Answer 8

Esta condición, si se puede obtener el resultado esperado:

String input = "ANYINPUT"; 

if(input.equals(input.toUpperCase()) 
{ 
    // input is all upper case 
} 
else if (input.equals(input.toLowerCase()) 
{ 
    // input is all lower case 
} 
else 
{ 
    // input is mixed case 
}