Регулярное выражение для ОДНОГО или большего количества букв/цифр и ZERO-or-more

Ответ 1

Я считаю, что вы можете сделать что-то вроде этого:

([ ]*+[0-9A-Za-z]++[ ]*+)+

Это 0 или более пробелов, за которыми следует не менее 1 алфавита char, за которым следует 0 или более пробелов

^^, что все это хотя бы один раз.

Использование идеи Pshemo для притяжательных кванторов для ускорения регулярного выражения.

Ответ 2

Вы также можете попробовать следующее:

  ^[0-9A-Za-z ]*[0-9A-Za-z]+[ ]*$

Ответ 3

Самый простой ответ

* означает zero or more, эквивалентный {0,}

+ означает one or more, эквивалентный {1,}

посмотрим на это

[A-Z]+ означает at least one Capital Letter, может быть записано как [A-Z]{1,}

[[email protected]#$%&]. означает, что эти специальные символы zero or more times могут быть записаны как [[email protected]#$%&]{0,}

извините, но

the purpose этого answer будет as Simple as possible

Ответ 4

Используйте lookahead:

^(?=.*\s*)(?=.*[a-zA-Z0-9]+)[a-zA-Z0-9 ]+$

Ответ 5

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

boolean ok = (myString.matches("^[A-Za-z0-9 ]+$")  &&  !myString.matches("^ *$"));

Это соответствует одному или нескольким буквам/цифрам и нулевым или большим пробелам, но не только пробелам (или ничего).

Это можно было бы сделать эффективным, предварительно создав отдельный объект-метку для каждого регулярного выражения:

   import  java.util.regex.Matcher;
   import  java.util.regex.Pattern;
public class OnePlusLetterDigitZeroPlusSpace  {
   //"": Unused search string, to reuse the matcher object
   private static final Matcher mtchr1PlusLetterDigitSpc = Pattern.compile("^[a-zA-z0-9 ]+$").matcher("");
   private static final Matcher mtchr0PlusSpc = Pattern.compile("^ *$").matcher("");
   public static final void main(String[] ignored)  {
      test("");
      test(" ");
      test("a");
      test("hello ");
      test(" hello ");
      test("hello there");
   }
   private static final void test(String to_search)  {
      System.out.print("\"" + to_search + "\": ");
      if(mtchr1PlusLetterDigitSpc.reset(to_search).matches()  &&  !mtchr0PlusSpc.reset(to_search).matches())  {
         System.out.println("good");
      }  else  {
         System.out.println("BAD");
      }
   }
}

Вывод:

[C:\java_code\]java OnePlusLetterDigitZeroPlusSpace
"": BAD
" ": BAD
"a": good
"hello ": good
" hello ": good
"hello there": good

Интересный регулярный вопрос дня.

Ответ 6

Вы запрашиваете, чтобы строка (s) удовлетворяла этому условию (обратите внимание: пусть c∈s означает c∈{x|x is a character in s}. Кроме того, [] представляют классы символов regex):

(∀c∈s (c∈[0-9A-Za-z ])) ∧ (∃c∈s ∋ c∈[0-9A-Za-z])

Рассмотрим отрицание:

¬((∀c∈s c∈[0-9A-Za-z ]) ∧ (∃c∈s ∋ c∈[0-9A-Za-z]))
⇔
(∃c∈s ∋ c∉[0-9A-Za-z ]) ∨ (∀c∈s c∉[0-9A-Za-z])
⇔
(∃c∈s ∋ c∈[^0-9A-Za-z ]) ∨ (∀c∈s c∈[^0-9A-Za-z])

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

Первое легко: [^0-9A-Za-z ].
Второе похоже на это: ^[^0-9A-Za-z]*$

Объедините их вместе, чтобы получить: [^0-9A-Za-z ]|^[^0-9A-Za-z]*$

Теперь нам нужно отменить это регулярное выражение. Очевидно, что мы могли бы просто сделать (?![^0-9A-Za-z ]|^[^0-9A-Za-z]*$). Или мы могли бы вручную отменить регулярное выражение:

[^0-9A-Za-z ] становится ^[0-9A-Za-z ]*$
^[^0-9A-Za-z]*$ становится [0-9A-Za-z]. (примечание: мы могли бы с легкостью приехать сюда с самого начала)

Но теперь нам нужно объединить их с AND, а не OR:

Так как [0-9A-Za-z] является подмножеством [0-9A-Za-z ], мы можем просто сделать это:

^[0-9A-Za-z ]*[0-9A-Za-z][0-9A-Za-z ]*$

Обратите внимание, что мы можем упростить его до:

^[0-9A-Za-z ]*[0-9A-Za-z][ ]*$

Это просто требует, чтобы символ, который соответствует [0-9A-Za-z], является последним символом, который может это сделать. Мы могли бы также сделать

^[ ]*[0-9A-Za-z][0-9A-Za-z ]*$

Для этого потребуется, чтобы символ, который соответствует [0-9A-Za-z], является первым символом, который может это сделать.

Итак, теперь все готово. Мы можем использовать один из них или (?![^0-9A-Za-z ]|^[^0-9A-Za-z]*$).

_{Примечание: String#match действует так, как если регулярное выражение ^ + regex + $ (где + является конкатенацией). Это может отбросить несколько вещей.}

Ответ 7

try {
    if (subjectString.matches("(?i)^(?=.*\\s*)(?!.*_)(?=.*[\\w]+)[\\w ]+$")) {
        // String matched entirely
    } else {
        // Match attempt failed
    } 
} catch (PatternSyntaxException ex) {
    // Syntax error in the regular expression
}

Или просто:

^(.*\p{Blank}?\p{Alnum}+.*\p{Blank}?)$

Пример