Ответ 1

Я подозреваю, что нижнее выражение ниже замедляется просмотром, но он должен работать независимо:

.matches("^(?=.*[A-Z])(?=.*[0-9])[A-Z0-9]+$")

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

Ответ 2

Легче писать и читать, если вы используете два отдельных регулярных выражения:

String s  =  "blah-FOO-test-1-2-3";

String numRegex   = ".*[0-9].*";
String alphaRegex = ".*[A-Z].*";

if (s.matches(numRegex) && s.matches(alphaRegex)) {
    System.out.println("Valid: " + input);
}

Еще лучше, напишите метод:

public boolean isValid(String s) {
    String n = ".*[0-9].*";
    String a = ".*[A-Z].*";
    return s.matches(n) && s.matches(a);
}

Ответ 3

Буква может быть до или после цифры, поэтому это выражение должно работать:

(([A-Z].*[0-9])|([0-9].*[A-Z]))

Вот пример кода, который использует это выражение:

Pattern p = Pattern.compile("(([A-Z].*[0-9])|([0-9].*[A-Z]))");
Matcher m = p.matcher("AXD123");
boolean b = m.find();
System.out.println(b);

Ответ 4

Это должно решить вашу проблему:

^([A-Z]+[0-9][A-Z0-9]*)|([0-9]+[A-Z][A-Z0-9]*)$

Но это нечитаемо. Я бы предложил сначала проверить ввод с помощью "^ [A-Z0-9] + $", затем проверить с помощью "[AZ]", чтобы убедиться, что он содержит хотя бы одну букву, затем проверьте с помощью "[0-9]", чтобы убедиться в этом содержит хотя бы одну цифру. Таким образом, вы можете легко добавлять новые ограничения, и код останется читаемым.

Ответ 5

Вот вам регулярное выражение

Основы:

Соответствует текущей строке строки: .

Соответствие 0 или любое количество символов: *

Сопоставьте что-нибудь в текущей строке: .*

Соответствует любому символу в наборе (диапазоне) символов: [start-end]

Сопоставьте одно из регулярных выражений из группы: (regex1|regex2|regex3)

Обратите внимание, что начало и конец происходит из порядка ASCII, и начало должно быть до конца. Например, вы можете сделать [0-Z], но не [Z-0]. Вот диаграмма ASCII для вашей справки

Проверить строку с регулярным выражением

Просто позвоните yourString.matches(theRegexAsString)

Проверьте, содержит ли строка буквы:

Проверьте, есть ли письмо: yourString.matches(".*[a-zA-Z].*")

Проверьте, есть ли нижняя строчная буква: yourString.matches(".*[a-z].*")

Проверьте, есть ли верхняя строчная буква: yourString.matches(".*[a-z].*")

Проверьте, содержит ли строка числа:

yourString.matches(".*[0-9].*")

Проверьте, содержит ли строка как число, так и букву:

Самый простой способ - совместить дважды буквы и цифры

yourString.matches(".*[a-zA-Z].*") && yourString.matches(".*[0-9].*")

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

yourString.matches(".*([a-zA-Z].*[0-9]|[0-9].*[a-zA-Z]).*")

Дополнительное регулярное выражение для справки:

Проверьте, нет ли строки с буквой

yourString.matches("[a-zA-Z].*")

Проверьте, заканчивается ли строка числом

yourString.matches(".*[0-9]")

Ответ 6

Как насчет ([A-Z].*[0-9]+)|([0-9].*[A-Z]+)?

Ответ 7

Попробуйте использовать (([AZ] + [0-9]) | ([0-9] + [AZ])). Это должно решить.