Главная » Языки программирования

Java email regexp pattern

Java Email Validation using Regex

Email validation using regular expressions is a common task that may be required in any application accepting email addresses as required information in the registration step. There may be more usecases, but that’s not the point of discussion here.

Let’s directly jump into the main discussion i.e. to validate email in Java using regular expressions.

This one is simplest and only cares about ‘@’ symbol. Before and after ‘@’ symbol, there can be any number of characters. Let’s see a quick example to see what I mean.

List emails = new ArrayList(); emails.add("user@domain.com"); emails.add("user@domain.co.in"); emails.add("user1@domain.com"); emails.add("user.name@domain.com"); emails.add("user#@domain.co.in"); emails.add("user@domaincom"); //Invalid emails emails.add("user#domain.com"); emails.add("@yahoo.com"); String regex = "^(.+)@(.+)$"; Pattern pattern = Pattern.compile(regex); for(String email : emails)
user@domain.com : true user@domain.co.in : true user1@domain.com : true user.name@domain.com : true user#@domain.co.in : true user@domaincom : true user#domain.com : false @yahoo.com : false

This pattern is available in Common lang’s EmailValidator class. So if it fits your need, you can directly use this class.

2. Adding Restrictions on User Name

In this regex, we have added some restrictions on the username part of the email address. Restrictions in the above regex are:

  • [A-Z] characters allowed
  • [a-z] characters allowed
  • 7 numbers allowed
  • Additionally email may contain only dot(.), dash(-) and underscore(_)
  • Rest all characters are not allowed

Let’s test some email addresses against the above regex.

List emails = new ArrayList(); emails.add("user@domain.com"); emails.add("user@domain.co.in"); emails.add("user1@domain.com"); emails.add("user.name@domain.com"); emails.add("user_name@domain.co.in"); emails.add("user-name@domain.co.in"); emails.add("user@domaincom"); //Invalid emails emails.add("@yahoo.com"); String regex = "^[A-Za-z0-9+_.-]+@(.+)$"; Pattern pattern = Pattern.compile(regex); for(String email : emails)
user@domain.com : true user@domain.co.in : true user1@domain.com : true user.name@domain.com : true user_name@domain.co.in : true user-name@domain.co.in : true user@domaincom : true @yahoo.com : false

Please note that a similar restriction can apply to the domain name part as well. Then regular expression will become like this.

Читайте также:  Header function php post

3. Regex for RFC-5322 Validation

This regex example uses all the characters permitted by RFC-5322, which governs the email message format. Some of the permitted characters present a security risk if passed directly from user input to an SQL statement, such as the single quote (‘) and the pipe character (|).

You should be sure to escape sensitive characters when inserting the email address into a string passed to another program to prevent security holes such as SQL injection attacks.

List emails = new ArrayList(); emails.add("user@domain.com"); emails.add("user@domain.co.in"); emails.add("user.name@domain.com"); emails.add("user?name@domain.co.in"); emails.add("user'name@domain.co.in"); //Invalid emails emails.add("@yahoo.com"); String regex = "^[a-zA-Z0-9_!#$%&'*+/=?`<|>~^.-]+@[a-zA-Z0-9.-]+$"; Pattern pattern = Pattern.compile(regex); for(String email : emails)
user@domain.com : true user@domain.co.in : true user.name@domain.com : true user?name@domain.co.in : true user'name@domain.co.in : true @yahoo.com : false

4. Restrict Leading, Trailing, or Consecutive Dots

Both the local part and the domain name can contain one or more dots, but no two dots can appear right next to each other. Furthermore, the first and last characters in the local part and in the domain name must not be dots:

List emails = new ArrayList(); emails.add("user@domain.com"); emails.add("user@domain.co.in"); emails.add("user.name@domain.com"); emails.add("user'name@domain.co.in"); //Invalid emails emails.add(".username@yahoo.com"); emails.add("username@yahoo.com."); emails.add("username@yahoo..com"); String regex = "^[a-zA-Z0-9_!#$%&'*+/=?`<|>~^-]+(?:\\.[a-zA-Z0-9_!#$%&'*+/=?`<|>~^-]+)*@[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)*$"; Pattern pattern = Pattern.compile(regex); for(String email : emails)
user@domain.com : true user@domain.co.in : true user.name@domain.com : true user'name@domain.co.in : true .username@yahoo.com : false username@yahoo.com. : false username@yahoo..com : false

5. Restrict Char Length in Top-level Domain [Recommended]

Now let’s modify the regex such that the domain name must include at least one dot, and that the part of the domain name after the last dot can only consist of letters.

Let’s say domain names are like secondlevel.com or thirdlevel.secondlevel.com. The top-level domain (.com in these examples) must only consist of two to six letters.

List emails = new ArrayList(); emails.add("user@domain.com"); emails.add("user@domain.co.in"); emails.add("user.name@domain.com"); emails.add("user_name@domain.com"); emails.add("username@yahoo.corporate.in"); //Invalid emails emails.add(".username@yahoo.com"); emails.add("username@yahoo.com."); emails.add("username@yahoo..com"); emails.add("username@yahoo.c"); emails.add("username@yahoo.corporate"); String regex = "^[\\w!#$%&'*+/=?`<|>~^-]+(?:\\.[\\w!#$%&'*+/=?`<|>~^-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]$"; Pattern pattern = Pattern.compile(regex); for(String email : emails)
user@domain.com : true user@domain.co.in : true user.name@domain.com : true user_name@domain.com : true username@yahoo.corporate.in : true .username@yahoo.com : false username@yahoo.com. : false username@yahoo..com : false username@yahoo.c : false username@yahoo.corporate : false

This last regex is my recommendation for simple email validation in java. Please note that email validation in java without regular expression may be possible, but it is not recommended. Anywhere you need to deal with patterns, regular expressions are your friend.

Please feel free to use this regex as well as edit it as per your application’s additional needs.

Источник

Регулярные выражениия в Java на примере адреса электронной почты

Известно, что регулярные выражения – это, по сути, шаблоны из символов, которые задают определённое правило поиска. И, среди прочего, с их помощью возможно осуществить проверку определённой строки или строк на соответствие некоему заранее заданному паттерну или стандарту.
Одним из наглядных и довольно простых примеров использования регулярных выражений в Java и не только является проверка проверка данных пользователя, ввёдённых при регистрации на определённом сайте на корректность. В первую очередь это касается адреса электронной почты, так как к нему всегда предъявляются определённые орфографические требования.

Таким образом, предлагаю разобрать частный случай применения регулярных выражений на примере простого Java-приложения, которое могло бы обрабатывать введённый пользователем адрес электронной почты.
Итак, в Java все классы, описывающие регулярные выражения, хранятся в пакете java.util.regex. Нам понадобятся два класса – Pattern и Matcher
Первый класс, как видно из его названия, описывает паттерн или шаблон, которому должены соответствовать введённые нами данные (в нашем случае – адрес электронной почты), второй – собственно сами данные.

public class RegularExpression < public static void main(String [] args) < Pattern pattern = Pattern.compile(“”); Matcher matcher = pattern.matcher(“”); boolean matches = matcher.matches(); >>
  1. Состоять из двух частей, разделённых символом “@”.
  2. Левая часть должна состоять из английских букв или цифр, может содержать точки и тире, притом после точки или тире обязательно должна следовать как минимум одна буква.
  3. Правая часть должна содержать хотя бы одну точку в конце, после которой должны следовать от двух до четырёх букв.
  4. Начинаться обе части должны с буквенных символов.
Pattern pattern = Pattern.compile(“[A-Za-z0-9]”);

Символы в квадратных скобках указывают интервал возможных буквенных значений.
В фигурных скобках мы описываем допустимое количество символов, указанных ранее. Слева от запятой указано минимальное значение (единица), справа – максимальное. Отсутствие значения, как в нашем случае, говорит о том, что количество символов не имеет максимального значения. Паттерн также может содержать и строго фиксированное число символов или не содежать его вовсе. В последнем случае символ может быть использован лишь один раз.
Далее в нашем паттерне может быть знак тире. “Может быть” означает, что символ будет присутствовать в паттерне либо один раз, либо ни разу, следовательно: 

Pattern pattern = Pattern.compile(“[A-Za-z0-9])[\\-]”);

В случае присутствия тире, как мы уже оговорили, после него в обязательном порядке должна следовать хотя бы одна буква, т.е. начальный паттерн повторяется. Символ тире обозначается как [\\-]: 

Pattern pattern = Pattern.compile(“[A-Za-z0-9][\\-][A-Za-z0-9]”);

Помимо этого, в строке также может присутствовать точка ([\\.]), после которой, опять-таки, обязан следовать буквенный символ: 

Pattern pattern = Pattern.compile(“[A-Za-z0-9][\\-][A-Za-z0-9][\\.][A-Za-z0-9]”); 
Pattern pattern = Pattern.compile(“([A-Za-z0-9][\\-][A-Za-z0-9][\\.][A-Za-z0-9])+”);

Знак плюса после общей скобки означает, что паттерн может повторяться от одного раза до неопределённого количества раз.
Так как левую часть от правой отделяет собачка, мы указываем, что после левой части в обязательном порядке будет присутствовать этот символ: 

Pattern pattern = Pattern.compile(“([A-Za-z0-9][\\-][A-Za-z0-9][\\.][A-Za-z0-9])+@”);

Правая часть паттерна должна содержать в себе уже упомянутый набор букв в количестве от одного до бесконечности с обязательным наличием точки в конце. Как и в предыдущем случае, паттерн до точки может повторяться: 

Pattern pattern = Pattern.compile(“([A-Za-z0-9][\\-][A-Za-z0-9][\\.][A-Za-z0-9])+@([A-Za-z0-9][\\-][A-Za-z0-9][\\.][A-Za-z0-9])+[\\.]); 
Pattern pattern = Pattern.compile(“([A-Za-z0-9][\\-][A-Za-z0-9][\\.][A-Za-z0-9])+@([A-Za-z0-9][\\-][A-Za-z0-9][\\.][A-Za-z0-9])+[\\.][a-z]”);

Вот, собственно, и весь паттерн. Не маленький, не находите? К счастью, есть способ несколько сократить этот набор, сделав его более читабельным и лёгким для восприятия.
Для начала, существует способ одновременного выражения наличия тире или точки в паттерне. Вместо того, чтобы отдельно пропсывать все точки ([\\.]) и тире ([\\-]), их можно выразить единым символом — [\\.-]. Используя его, мы можем сократить паттерн до следующего: 

Pattern pattern = Pattern.compile(“([A-Za-z0-9][\\.-][A-Za-z0-9])+@([A-Za-z0-9][\\.-][A-Za-z0-9])+[\\.][a-z]”);

Также, существует символ, который может означать любую букву или цифру — \\w. Т.е. он способен заменить описание типа [A-Za-z0-9]: 

Pattern pattern = Pattern.compile(“(\\w[\\.-]\\w)+@(\\w[\\.-]\\w)+[\\.][a-z]”);

Так как знак плюса означает наличие символа в количестве от одного до бесконечности, описанное выше можно также свести до: 

Pattern pattern = Pattern.compile(“(\\w+[\\.-]\\w+)+@(\\w+[\\.-]\\w+)+[\\.][a-z]”); 
Pattern pattern = Pattern.compile(“(\\w+[\\.-]?\\w+)+@(\\w+[\\.-]?\\w+)+[\\.][a-z]”);

Есть также символ, означающий наличие чего-либо в паттерне неопределённое количество раз, т.е. . Обозначается он как *. В итоговом варианте мы имеем следующее: 

Pattern pattern = Pattern.compile(“\\w+([\\.-]?\\w+)*@\\w+([\\.-]?\\w+)*\\.\\w”);

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

public class RegularExpression < public static void main(String [] args) < Pattern pattern = Pattern.compile(“\\w+([\\.-]?\\w+)*@\\w+([\\.-]?\\w+)*\\.\\w”); Matcher matcher = pattern.matcher(“”); boolean matches = matcher.matches(); > >

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

Источник

Оцените статью
© 2024 Программирование