metodo - Comprobación de mayúsculas y minúsculas(superior/inferior) dentro de una cadena en Java

ignorar mayusculas y minusculas java

Question

El problema que tengo es que no puedo hacer que mi Programa de verificación de contraseñas compruebe una cadena para asegurarse de que, uno de los caracteres está en mayúscula y el otro en minúscula, comprobará toda la cadena de uno de los otro e imprima el mensaje de error según el enunciado que verifica.

Revisé este sitio y encontré una respuesta en Internet y no puedo encontrar ninguno. Esto es tarea.

A continuación está mi código actual.

import java.util.Scanner;

public class password
{
    public static void main(String[] args)
    {
        Scanner stdIn = new Scanner(System.in);
        String password;
        String cont = "y";
        char ch;
        boolean upper = false;
        boolean lower = false;

        System.out.println("Setting up your password is easy. To view requirements enter Help.");
        System.out.print("Enter password or help: ");
        password = stdIn.next();
        ch = password.charAt(0);

        while (cont.equalsIgnoreCase("y"))
        {
            while (password.isEmpty())
            {
                System.out.print("Enter password or help: ");
                password = stdIn.next();       
            }

            if (password.equalsIgnoreCase("help"))
            {
                 System.out.println("Password must meet these requirements." +
                     "/nMust contain 8 characters./nMust contain 1 lower case letter." +
                     "/nMust contain 1 upper case letter./nMust contain 1 numeric digit." +
                     "/nMust contain 1 special character !@#$%^&*/nDoes not contain the word AND or NOT.");

                password = "";
            }
            else if (password.length() < 8)
            {
                System.out.println("Invalid password - Must contain 8 charaters.");
                password = "";
            }
            else if (!(Character.isLowerCase(ch)))
            {
                for (int i=1; i<password.length(); i++)
                {
                    ch = password.charAt(i);

                    if (!Character.isLowerCase(ch))
                    {  
                        System.out.println("Invalid password - Must have a Lower Case character.");
                        password = "";
                    }
                }
            }
            else if (!(Character.isUpperCase(ch)))
            {
                for (int i=0; i<password.length(); i++)
                {       
                    ch = password.charAt(i);

                    if (!Character.isUpperCase(ch))
                    {
                        System.out.println("Invalid password - Must have an Upper Case character.");
                        password = "";
                    }
                }
            }
            else
            {
                System.out.println("Your password is " + password);

                System.out.print("Would you like to change your password? Y/N: ");
                cont = stdIn.next();
                password = "";
            }

            while (!cont.equalsIgnoreCase("y") && !cont.equalsIgnoreCase("n"))
            {
                System.out.print("Invalid Answer. Please enter Y or N: ");
                cont = stdIn.next();
            }
        }
    }
}

Answer 1

Aunque este código probablemente esté más allá de la comprensión de un principiante, se puede hacer en una línea usando una expresión regular con aspecto positivo y negativo:

boolean ok = 
    password.matches("^(?=.*[A-Z])(?=.*[!@#$%^&*])(?=.*//d)(?!.*(AND|NOT)).*[a-z].*");

Answer 2

Eso es lo que obtuve:

    Scanner scanner = new Scanner(System.in);
    System.out.println("Please enter a nickname!");
    while (!scanner.hasNext("[a-zA-Z]{3,8}+")) {
        System.out.println("Nickname should contain only Alphabetic letters! At least 3 and max 8 letters");
        scanner.next();
    }
    String nickname = scanner.next();
    System.out.println("Thank you! Got " + nickname);

Lea sobre el patrón de expresiones regulares aquí: https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html

Answer 3

He simplificado la respuesta de @Quirliom en las funciones que se pueden utilizar:

private static boolean hasLength(CharSequence data) {
    if (String.valueOf(data).length() >= 8) return true;
    else return false;
}

private static boolean hasSymbol(CharSequence data) {
    String password = String.valueOf(data);
    boolean hasSpecial = !password.matches("[A-Za-z0-9 ]*");
    return hasSpecial;
}

private static boolean hasUpperCase(CharSequence data) {
    String password = String.valueOf(data);
    boolean hasUppercase = !password.equals(password.toLowerCase());
    return hasUppercase;
}

private static boolean hasLowerCase(CharSequence data) {
    String password = String.valueOf(data);
    boolean hasLowercase = !password.equals(password.toUpperCase());
    return hasLowercase;
}

Answer 4

Para determinar si una Cadena contiene mayúsculas y minúsculas, puede usar lo siguiente:

boolean hasUppercase = !password.equals(password.toLowerCase());
boolean hasLowercase = !password.equals(password.toUpperCase());

Esto le permite verificar:

if(!hasUppercase)System.out.println("Must have an uppercase Character");
if(!hasLowercase)System.out.println("Must have a lowercase Character");

Básicamente, esto funciona comprobando si la cadena es igual a su equivalente totalmente en minúscula o en mayúscula. Si esto no es cierto, debe haber al menos un carácter mayúsculo o minúsculo.

En cuanto a sus otras condiciones, estas se pueden satisfacer de una manera similar:

boolean isAtLeast8   = password.length() >= 8;//Checks for at least 8 characters
boolean hasSpecial   = !password.matches("[A-Za-z0-9 ]*");//Checks at least one char is not alpha numeric
boolean noConditions = !(password.contains("AND") || password.contains("NOT"));//Check that it doesn''t contain AND or NOT

Con los mensajes de error adecuados como arriba.

Answer 5

Un ciclo como este:

else if (!(Character.isLowerCase(ch)))
            {
                for (int i=1; i<password.length(); i++)
                {
                   ch = password.charAt(i);

                    if (!Character.isLowerCase(ch))
                       {  
                        System.out.println("Invalid password - Must have a Lower Case character.");
                        password = "";
                       }
                     // end if
                } //end for
            }

Tiene un defecto lógico obvio: lo ingresa si el primer carácter no está en minúscula, luego prueba si el segundo carácter no está en minúscula. En ese punto, arrojas un error.

En cambio, debes hacer algo como esto (no el código completo, solo un ejemplo):

boolean hasLower = false, hasUpper = false, hasNumber = false, hasSpecial = false; // etc - all the rules
for ( ii = 0; ii < password.length(); ii++ ) {
  ch = password.charAt(ii);
  // check each rule in turn, with code like this:
  if Character.isLowerCase(ch) hasLower = true;
  if Character.isUpperCase(ch) hasUpper = true;
  // ... etc for all the tests you want to do
}

if(hasLower && hasUpper && ...) {
  // password is good
} 
else {
  // password is bad
}

Por supuesto, el fragmento de código que proporcionó, además de la lógica defectuosa, no tenía código para probar las otras condiciones que imprimió su opción de "ayuda". Como se señaló en una de las otras respuestas, podría considerar usar expresiones regulares para ayudarlo a acelerar el proceso de búsqueda de cada una de estas cosas. Por ejemplo,

hasNumber  : use regex pattern "/d+" for "find at least one digit"
hasSpecial : use regex pattern "[!@#$%^&*]+" for "find at least one of these characters"

En codigo:

hasNumber  = password.matches(".*//d.*");  // "a digit with anything before or after"
hasSpecial = password.matches(".*[!@#$%^&*].*");
hasNoNOT   = !password.matches(".*NOT.*");
hasNoAND   = !password.matches(".*AND.*");

Es posible combinar estas cosas de manera inteligente, pero especialmente cuando eres un usuario de expresiones regulares novato, es mucho mejor ser un poco "lento y tedioso", y obtener un código que funcione la primera vez (además de que serás capaz de descubre lo que hiciste dentro de seis meses).

Answer 6

Una mirada rápida a través de la documentación sobre sytanx de expresión regular debería mostrar formas de decir si contiene un carácter de mayúscula / minúscula en algún punto.

Answer 7

package passwordValidator;

import java.util.Scanner;

public class Main {
    /**
     * @author felipe mello.
     */

    private static Scanner scanner = new Scanner(System.in);

     /*
     * Create a password validator(from an input string) via TDD
     * The validator should return true if
     *  The Password is at least 8 characters long
     *  The Password contains uppercase Letters(atLeastOne)
     *  The Password contains digits(at least one)
     *  The Password contains symbols(at least one)
     */


    public static void main(String[] args) {
        System.out.println("Please enter a password");
        String password = scanner.nextLine();   

        checkPassword(password);
    }
    /**
     * 
     * @param checkPassword the method check password is validating the input from the the user and check if it matches the password requirements
     * @return
     */
    public static boolean checkPassword(String password){
        boolean upperCase = !password.equals(password.toLowerCase()); //check if the input has a lower case letter
        boolean lowerCase = !password.equals(password.toUpperCase()); //check if the input has a CAPITAL case letter
        boolean isAtLeast8 = password.length()>=8;                    //check if the input is greater than 8 characters
        boolean hasSpecial = !password.matches("[A-Za-z0-9]*");       // check if the input has a special characters
        boolean hasNumber = !password.matches(".*//d+.*");            //check if the input contains a digit
        if(!isAtLeast8){
            System.out.println("Your Password is not big enough/n please enter a password with minimun of 8 characters");
            return true;
        }else if(!upperCase){
            System.out.println("Password must contain at least one UPPERCASE letter");
            return true;
        }else if(!lowerCase){
            System.out.println("Password must contain at least one lower case letter");
            return true;
        }else if(!hasSpecial){
            System.out.println("Password must contain a special character");
            return true;
        }else if(hasNumber){
            System.out.println("Password must contain at least one number");
            return true;
        }else{
            System.out.println("Your password: "+password+", sucessfully match the requirements");
            return true;
        }

    }
}