Регулярное выражение Java для проверки пароля

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

public class passwordvalidation {
    public static void main(String[] args) {
      String passwd = "aaZZa44@"; 
      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 персонажи

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

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

^(?=.*[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 соответствует всем символам Юникода (пробелам или нет) и всем символам ASCII без пробелов. Если символы Юникода разрешены, но пробелы Юникода нет, то UNICODE_CHARACTER_CLASS флаг может быть установлен, чтобы сделать \S исключить пробелы в Юникоде. Если символы Юникода не разрешены, то [\x21-\x7E] можно использовать вместо \S чтобы соответствовать всем символам ASCII, которые не являются пробелом или управляющим символом.

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

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

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

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

Я бы реализовал так:

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

Требование К Паролю:

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

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

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

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

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

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

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

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

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

[Regex Demo]

легкий

("^ (?=.* [0-9]) (?=.* [a-z]) (?=.* [A-Z]) (?=.* [\\W_]) [\\S] {8,10}$")

1. (?= anything) - > означает, что положительный смотрит вперед во всей входной строке и убедитесь, что для этого условия написано .образец(?=.*[0-9]) - > означает, что один цифровой номер записывается во все строки.если не написано возвращение ложные .

2. (?! что угодно ) - >(наоборот) означает отрицательный взгляд вперед, если условие написано возвращение ложные.

   закрыть значение ^(условие)(условие)(условие) (условие)[\S] {8,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. Затем перейти к следующий за петлей. символ.isDigit(С. используя метод charat(я))
4. этот цикл проверяет все алфавиты, помещенные в строку. Если его найти то добавьте еще один 5 в n. символ.островок (s. charAt (i))
5. теперь проверьте целое число n с помощью условия if. Если N=10 верно данная строка является буквенно-цифровой иначе ее нет.