Проверка флага письма (верхний/нижний) внутри строки в Java

Ответ 1

Чтобы определить, содержит ли String верхний регистр и нижний регистр char, вы можете использовать следующее:

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

Это позволяет проверить:

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

По существу, это работает, проверяя, соответствует ли String его строчному или верхнему эквиваленту. Если это не так, то должен быть хотя бы один символ, который имеет верхний или нижний регистр.

Что касается других условий, они могут быть выполнены аналогичным образом:

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

С соответствующими сообщениями об ошибках, как указано выше.

Ответ 2

Цикл, подобный этому:

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
            }

Имеет очевидный логический недостаток: вы вводите его, если первый символ не строчный, а затем проверьте, не является ли второй символ не строчным. В этот момент вы делаете ошибку.

Вместо этого вы должны сделать что-то вроде этого (не полный код, просто пример):

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
}

Конечно, фрагмент кода, который вы предоставили, помимо ошибочной логики, не имел кода для проверки других условий, в которых была выбрана опция "help". Как было указано в одном из других ответов, вы можете использовать регулярные выражения, чтобы ускорить процесс поиска каждой из этих вещей. Например,

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

В коде:

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

Можно объединить эти вещи умными способами - но особенно, когда вы являетесь новичком-пользователем регулярного выражения, гораздо лучше быть немного "медленным и утомительным" и получать код, который работает в первый раз (плюс вы будете быть в состоянии выяснить, что вы сделали через полгода).

Ответ 3

Хотя этот код, вероятно, выходит за рамки понимания новичков, его можно сделать в одной строке, используя регулярное выражение с положительным и отрицательным опережением:

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

Ответ 4

Я оптимизировал ответ @Quirliom выше на функции, которые можно использовать:

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

Ответ 5

Быстрый просмотр документации по регулярному выражению sytanx должен привести к тому, чтобы определить, содержит ли он символ нижнего/верхнего регистра в какой-то точке.

Ответ 6

Что я получил:

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

Подробнее о шаблоне regex здесь: https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html

Ответ 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;
        }

    }
}