Regexp Java для проверки пароля

Ответ 1

Попробуйте следующее:

^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\S+$).{8,}$

Пояснение:

^                 # start-of-string
(?=.*[0-9])       # a digit must occur at least once
(?=.*[a-z])       # a lower case letter must occur at least once
(?=.*[A-Z])       # an upper case letter must occur at least once
(?=.*[@#$%^&+=])  # a special character must occur at least once
(?=\S+$)          # no whitespace allowed in the entire string
.{8,}             # anything, at least eight places though
$                 # end-of-string

Легко добавлять, изменять или удалять отдельные правила, поскольку каждое правило является независимым "модулем".

Конструкция (?=.*[xyz]) использует всю строку (.*) и обратную трассировку для первого вхождения, где [xyz] может совпадать. Это удается, если найдено [xyz], иначе он не работает.

Альтернативой будет использование неохотного классификатора: (?=.*?[xyz]). Для проверки пароля это вряд ли имеет значение, поскольку для более длинных строк это может быть более эффективным вариантом.

Самый эффективный вариант (но наиболее трудный для чтения и поддержания, следовательно, самый подверженный ошибкам) ​​был бы (?=[^xyz]*[xyz]), конечно. Для регулярного выражения этой длины и для этой цели я бы рекомендовал сделать это таким образом, поскольку он не имеет реальных преимуществ.

Ответ 2

простой пример с использованием regex

public class passwordvalidation {
    public static void main(String[] args) {
      String passwd = "[email protected]"; 
      String pattern = "(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,}";
      System.out.println(passwd.matches(pattern));
   }
}

Пояснения:

• (?=.*[0-9]) цифра должна появляться по крайней мере один раз
• (?=.*[a-z]) строчная буква должна появляться как минимум раз
• (?=.*[a-z]) письмо с верхним регистром должно происходить по крайней мере один раз
• (?=.*[@#$%^&+=]) специальный символ должен появляться по крайней мере один раз
• (?=\\S+$) пробелы не разрешены во всей строке
• .{8,} не менее 8 символов

Ответ 3

Все ранее предоставленные ответы используют тот же (правильный) метод, чтобы использовать отдельный просмотр для каждого требования. Но они содержат пару неэффективности и потенциально массивную ошибку, в зависимости от того, что на самом деле будет использовать пароль.

Я начну с регулярного выражения из принятого ответа:

^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\S+$).{8,}$

Прежде всего, поскольку Java поддерживает \A и \z, я предпочитаю использовать их, чтобы убедиться, что вся строка проверена независимо от Pattern.MULTILINE. Это не влияет на производительность, но позволяет избежать ошибок при повторном использовании регулярных выражений.

\A(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\S+$).{8,}\z

Проверка того, что пароль не содержит пробелов, и проверка его минимальной длины может быть выполнена за один проход, используя все сразу, поместив квантификатор переменной {8,} в стенографию \S, которая ограничивает допустимые символы:

\A(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])\S{8,}\z

Если предоставленный пароль содержит пробел, все проверки будут выполнены только для того, чтобы окончательная проверка завершилась с ошибкой. Этого можно избежать, заменив все точки на \S:

\A(?=\S*[0-9])(?=\S*[a-z])(?=\S*[A-Z])(?=\S*[@#$%^&+=])\S{8,}\z

Точка должна использоваться только в том случае, если вы действительно хотите разрешить любой символ. В противном случае используйте (отрицаемый) класс символов, чтобы ограничить регулярное выражение только теми символами, которые действительно разрешены. Хотя в этом случае мало что имеет значения, не использовать точку, когда что-то еще более подходит, является очень хорошей привычкой. Я вижу слишком много случаев катастрофического обратного отслеживания, потому что разработчику было слишком ленив, чтобы использовать что-то более подходящее, чем точка.

Так как есть хорошая вероятность, что начальные тесты найдут подходящий символ в первой половине пароля, ленивый квантификатор может быть более эффективным:

\A(?=\S*?[0-9])(?=\S*?[a-z])(?=\S*?[A-Z])(?=\S*?[@#$%^&+=])\S{8,}\z

Но теперь для действительно важной проблемы: ни один из ответов не упоминает тот факт, что исходный вопрос, похоже, написан кем-то, кто думает в ASCII. Но в Java строки Unicode. В паролях разрешены символы, отличные от ASCII? Если они есть, пробелы только ASCII запрещены или все исключения Unicode исключаются.

По умолчанию \S соответствует только пробелу ASCII, поэтому его обратный \S соответствует всем символам Unicode (пробелы или нет) и всем символам ASCII без пробелов. Если символы Юникода разрешены, но в Unicode нет, флаг UNICODE_CHARACTER_CLASS может быть указан, чтобы сделать \S исключать пробелы Unicode. Если символы Unicode недопустимы, вместо \S можно использовать [\x21-\x7E] для соответствия всем символам ASCII, которые не являются пробелом или управляющим символом.

Это приводит нас к следующей потенциальной проблеме: хотим ли мы разрешать контрольные символы? Первым шагом в написании правильного регулярного выражения является точное указание того, что вы хотите сопоставить, а что нет. Единственный 100% -ный технически правильный ответ заключается в том, что спецификация пароля в вопросе неоднозначна, поскольку она не указывает, разрешены ли определенные диапазоны символов, такие как управляющие символы или символы, отличные от ASCII, или нет.

Ответ 4

Нельзя использовать слишком сложное Regex (если вы можете избежать их), потому что они

• трудно читать (по крайней мере для всех, кроме вас самих)
• трудно расширить
• трудно отлаживать

Несмотря на то, что при использовании многих небольших регулярных выражений может быть небольшая накладная производительность, точки выше легко выгружают.

Я бы выполнил следующее:

bool matchesPolicy(pwd) {
    if (pwd.length < 8) return false;
    if (not pwd =~ /[0-9]/) return false;
    if (not pwd =~ /[a-z]/) return false;
    if (not pwd =~ /[A-Z]/) return false;
    if (not pwd =~ /[%@$^]/) return false;
    if (pwd =~ /\s/) return false;
    return true;
}

Ответ 5

Требование к паролю:

• Пароль должен содержать не менее восьми (8) символов, где система может его поддерживать.

• Пароли должны содержать символы, по крайней мере, из двух (2) этих группировок: альфа, числовые и специальные символы.

  ^.*(?=.{8,})(?=.*\d)(?=.*[a-zA-Z])|(?=.{8,})(?=.*\d)(?=.*[[email protected]#$%^&])|(?=.{8,})(?=.*[a-zA-Z])(?=.*[[email protected]#$%^&]).*$
  

Я тестировал его, и он работает

Ответ 6

Для всех, кто интересуется минимальными требованиями к каждому типу персонажа, я бы предложил сделать следующее расширение для ответа Томалака:

^(?=(.*[0-9]){%d,})(?=(.*[a-z]){%d,})(?=(.*[A-Z]){%d,})(?=(.*[^0-9a-zA-Z]){%d,})(?=\S+$).{%d,}$

Обратите внимание, что это строка форматирования, а не окончательный шаблон регулярного выражения. Просто замените% d минимальными требуемыми вхождениями для: цифр, строчных, прописных, нецифровых/символьных и всего пароля (соответственно). Максимальные вхождения маловероятны (если вы не хотите max 0, эффективно отклоняя любые такие символы), но они также могут быть легко добавлены. Обратите внимание на дополнительную группировку вокруг каждого типа, чтобы ограничения min/max допускали несоответствующие совпадения. Это сработало чудесами для системы, где мы могли бы централизованно настроить, сколько из каждого типа символов мы требуем, а затем на веб-сайте, а также на двух разных мобильных платформах извлекаем эту информацию, чтобы построить шаблон регулярного выражения на основе указанной выше строки форматирования.

Ответ 7

Метод Java готов для вас, с параметрами

Просто скопируйте и вставьте и установите нужные параметры.

Если вам не нужен модуль, просто прокомментируйте его или добавьте "если", как я сделал для специального символа

//______________________________________________________________________________
/**
 * Validation Password     */
//______________________________________________________________________________
private static boolean validation_Password(final String PASSWORD_Arg)    {
    boolean result = false;
    try {
        if (PASSWORD_Arg!=null) {
            //_________________________
            //Parameteres
            final String MIN_LENGHT="8";
            final String MAX_LENGHT="20";
            final boolean SPECIAL_CHAR_NEEDED=true;

            //_________________________
            //Modules
            final String ONE_DIGIT = "(?=.*[0-9])";  //(?=.*[0-9]) a digit must occur at least once
            final String LOWER_CASE = "(?=.*[a-z])";  //(?=.*[a-z]) a lower case letter must occur at least once
            final String UPPER_CASE = "(?=.*[A-Z])";  //(?=.*[A-Z]) an upper case letter must occur at least once
            final String NO_SPACE = "(?=\\S+$)";  //(?=\\S+$) no whitespace allowed in the entire string
            //final String MIN_CHAR = ".{" + MIN_LENGHT + ",}";  //.{8,} at least 8 characters
            final String MIN_MAX_CHAR = ".{" + MIN_LENGHT + "," + MAX_LENGHT + "}";  //.{5,10} represents minimum of 5 characters and maximum of 10 characters

            final String SPECIAL_CHAR;
            if (SPECIAL_CHAR_NEEDED==true) SPECIAL_CHAR= "(?=.*[@#$%^&+=])"; //(?=.*[@#$%^&+=]) a special character must occur at least once
            else SPECIAL_CHAR="";
            //_________________________
            //Pattern
            //String pattern = "(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,}";
            final String PATTERN = ONE_DIGIT + LOWER_CASE + UPPER_CASE + SPECIAL_CHAR + NO_SPACE + MIN_MAX_CHAR;
            //_________________________
            result = PASSWORD_Arg.matches(PATTERN);
            //_________________________
        }    

    } catch (Exception ex) {
        result=false;
    }

    return result;
}        

Ответ 8

Я думаю, что это может сделать это также (как более простой режим):

^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])[^\s]{8,}$

[Regex Demo]

Ответ 9

простой

( "^ (? =. * [0-9]) (? =. * [az]) (? =. * [AZ]) (? =. * [\\ W _]) [\\ S ] {8,10} $" )

• (? = anything) → означает положительный внешний вид во всей входной строке и убедитесь, что это условие записано .sample(? =. * [0-9]) → означает, что одно цифровое число записано в все string.if не написано return false                   .

• (! anything) → (vise versa) означает отрицательный взгляд вперед, если условие написано возвращает false.

  <условие > ) (условие) (состояние) [\ S] {8,10} $

Ответ 10

String s=pwd;
int n=0;
for(int i=0;i<s.length();i++)
{
    if((Character.isDigit(s.charAt(i))))
    {
        n=5;
        break;
    }
    else
    {

    }
}
for(int i=0;i<s.length();i++)
{
    if((Character.isLetter(s.charAt(i))))
    {
        n+=5;
        break;
    }
    else
    {

    }

}

if(n==10)
{
    out.print("Password format correct <b>Accepted</b><br>");

}
else
{
    out.print("Password must be alphanumeric <b>Declined</b><br>");
}

Объяснение:

1. Сначала установите пароль в виде строки и создайте целочисленный набор o.
2. Затем проверьте каждый символ для цикла.
3. Если он находит число в строке, то n добавляет 5. Затем переходите к следующему циклу for. Character.isDigit(s.charAt (я))
4. Этот цикл проверяет любые алфавиты, помещенные в строку. Если его найти, то добавьте еще 5 в n. Character.isLetter(s.charAt (я))
5. Теперь проверьте целое число n с помощью условия if. Если n = 10 истинно, данная строка является буквенно-цифровой, иначе это не так.

Ответ 11

Этот проверяет каждый специальный символ:

^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=\S+$).*[A-Za-z0-9].{8,}$

Ответ 12

Также вы можете сделать это.

 public boolean isPasswordValid(String password) {


    String regExpn =
            "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,}$";

    CharSequence inputStr = password;

    Pattern pattern = Pattern.compile(regExpn,Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher(inputStr);

    if(matcher.matches())
        return true;
    else
        return false;
}