Как мне проверить адрес электронной почты?

Каков хороший метод проверки адреса электронной почты (например, из поля ввода пользователя) в Android? org.apache.commons.validator.routines.EmailValidator , по-видимому, недоступен. Существуют ли другие библиотеки, которые делают это, которые уже включены в Android, или мне нужно использовать RegExp?

Не используйте рег-экс.

По-видимому, следующее - это reg-ex, который правильно проверяет большинство адресов электронной почты, которые соответствуют RFC 2822 (и все равно не будет работать с такими вещами, как «user@gmail.com.nospam», как и org.apache.commons.validator. routines.EmailValidator)

(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])

Возможно, самый простой способ проверить электронную почту - просто отправить электронное письмо с подтверждением по указанному адресу, и если оно будет возвращено, оно не будет действительным.

Если вы хотите выполнить некоторые базовые проверки, вы можете просто проверить, что это в форме *@*

Если у вас есть некоторая валидация, специфичная для бизнес-логики, вы можете выполнить ее с помощью регулярного выражения, например, это должна быть учетная запись gmail.com или что-то в этом роде.

Другой вариант - встроенные шаблоны, начиная с уровня API 8:

public final static boolean isValidEmail(CharSequence target) {
  if (TextUtils.isEmpty(target)) {
    return false;
  } else {
    return android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
  }
}

Шаблоны видимого источника

ИЛИ

Однолинейное решение от @AdamvandenHoven:

public final static boolean isValidEmail(CharSequence target) {
  return !TextUtils.isEmpty(target) && android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}

Следующий шаблон используется в почте K-9:

public static final Pattern EMAIL_ADDRESS_PATTERN = Pattern.compile(
          "[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +
          "\\@" +
          "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}" +
          "(" +
          "\\." +
          "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25}" +
          ")+"
      );

Вы можете использовать функцию

private boolean checkEmail(String email) {
        return EMAIL_ADDRESS_PATTERN.matcher(email).matches();
}

Начиная с API 8 (Android 2.2) существует шаблон: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

Таким образом, вы можете использовать его для проверки yourEmailString:

private boolean isValidEmail(String email) {
    Pattern pattern = Patterns.EMAIL_ADDRESS;
    return pattern.matcher(email).matches();
}

возвращает true, если адрес электронной почты действителен

UPD: этот исходный код шаблона:

public static final Pattern EMAIL_ADDRESS
    = Pattern.compile(
        "[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +
        "\\@" +
        "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}" +
        "(" +
            "\\." +
            "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25}" +
        ")+"
    );

обратитесь к: http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/util/Patterns.java

Таким образом, вы можете создать его самостоятельно для совместимости с API <8.

Теперь у нас есть простое средство сравнения шаблонов электронной почты

 private static boolean isValidEmail(String email) {
        return !TextUtils.isEmpty(email) && android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
    }

Используйте простой однострочный код для проверки электронной почты

public static boolean isValidEmail(CharSequence target) {
    return !TextUtils.isEmpty(target) && android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}

использовать как ...

if (!isValidEmail(yourEdittext.getText().toString()) {
    Toast.makeText(context, "your email is not valid", 2000).show();
}

Это предложения Android Studio:

public static boolean isEmailValid(String email) {
    return !(email == null || TextUtils.isEmpty(email)) && android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
}

Вы можете использовать регулярное выражение для этого. Что-то вроде следующего.

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

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

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

используйте android: inputType = "textEmailAddress", как показано ниже:

       <EditText
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="email"
        android:inputType="textEmailAddress"
        android:id="@+id/email"
        />

и:

       boolean isEmailValid(CharSequence email) {
        return android.util.Patterns.EMAIL_ADDRESS.matcher(email)
                .matches();
      }

Вы могли бы написать расширение Kotlin как это:

fun String.isValidEmail() =
        this.isNotEmpty() && android.util.Patterns.EMAIL_ADDRESS.matcher(this).matches()

А потом назовите это так:

email.isValidEmail()

В Patternsпакете есть класс, android.utilкоторый здесь полезен. Ниже приведен метод, который я всегда использую для проверки электронной почты и многих других вещей.

private boolean isEmailValid(String email) {
    return !TextUtils.isEmpty(email) && Patterns.EMAIL_ADDRESS.matcher(email).matches();
}

Вызовите этот метод, где вы хотите проверить идентификатор электронной почты.

public static boolean isValid(String email)
{
   String expression = "^[\\w\\.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";
   CharSequence inputStr = email;
   Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
   Matcher matcher = pattern.matcher(inputStr);
   if (matcher.matches()) 
   {
      return true;
   }
   else{
   return false;
   }
}

Для проверки электронной почты андроид предоставляет несколько шаблонов InBuilt. Но он поддерживает только API уровня 8 и выше .

Вот код для использования этого шаблона для проверки правильности электронной почты.

  private boolean Email_Validate(String email) 
  {
    return android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
  }

Убедитесь, что после выполнения этого метода вы должны убедиться, что если этот метод возвращает true, вы разрешаете сохранять электронную почту, а если этот метод возвращает false, отображать сообщение о том, что электронная почта «Неверная».

Надеюсь, вы получите ответ, спасибо.

Могу я НАСТОЯТЕЛЬНО рекомендовать вам не пытаться «проверять» адреса электронной почты, вы просто начнете много работать без веской причины.

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

Все остальное просто заставит вас много работать за минимальную отдачу ...

Подтвердите формат вашего адреса электронной почты. Ex-virag@gmail.com

public boolean emailValidator(String email) 
{
    Pattern pattern;
    Matcher matcher;
    final String EMAIL_PATTERN = "^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";
    pattern = Pattern.compile(EMAIL_PATTERN);
    matcher = pattern.matcher(email);
    return matcher.matches();
}

    public boolean isValidEmail(String email)
{
    boolean isValidEmail = false;

    String emailExpression = "^[\\w\\.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";
    CharSequence inputStr = email;

    Pattern pattern = Pattern.compile(emailExpression, Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher(inputStr);
    if (matcher.matches())
    {
        isValidEmail = true;
    }
    return isValidEmail;
}

Если вы используете API 8 или выше, вы можете использовать легкодоступный Patternsкласс для проверки электронной почты. Образец кода:

public final static boolean isValidEmail(CharSequence target) {
    if (target == null) 
        return false;

    return android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}

Случайно, если вы даже поддерживаете уровень API ниже 8, вы можете просто скопировать Patterns.javaфайл в свой проект и сослаться на него. Вы можете получить исходный код Patterns.javaиз этой ссылки

Вот android.util.Patterns.EMAIL_ADDRESS

[A-Za-Z0-9 + ._ \% - +] {} тысяча двести пятьдесят-шесть \ @ [A-Za-Z0-9] [A-Za-Z0-9 -]. {0,64} ([& alpha; Za-z0-9] [A-Za-Z0-9 -] {0,25}) +

String будет соответствовать, если

Start by 1->256 character in (a-z, A-Z, 0-9, +, ., _, %, - , +)  
then 1 '@' character  
then 1 character in (a-z, A-Z, 0-9)  
then 0->64 character in (a-z, A-Z, 0-9, -)  
then **ONE OR MORE** 
         1 '.' character   
    then 1 character in (a-z, A-Z, 0-9)   
    then 0->25 character in (a-z, A-Z, 0-9, -)

Пример специального письма

a@b.c
a+@b-.c
a@b.c.d.e.f.g.h

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

fun isValidEmail(email: String): Boolean {
    return Patterns.EMAIL_ADDRESS.matcher(email).matches()
}

Попробуйте этот простой метод, который не может принять адрес электронной почты, начинающийся с цифр:

boolean checkEmailCorrect(String Email) {
    if(signupEmail.length() == 0) {
        return false;
    }

    String pttn = "^\\D.+@.+\\.[a-z]+";
    Pattern p = Pattern.compile(pttn);
    Matcher m = p.matcher(Email);

    if(m.matches()) {
        return true;
    }

    return false;
}

Попробуйте этот код .. Это действительно работает ..

            if (!email
                    .matches("^[\\w-_\\.+]*[\\w-_\\.]\\@([\\w]+\\.)+[\\w]+[\\w]$"))
            {
                Toast.makeText(getApplicationContext(), "Email is invalid",
                        Toast.LENGTH_LONG).show();
                return;
            }

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

public boolean isValidEmail(String inputString) {
    String  s ="^((?!.*?\.\.)[A-Za-z0-9\.\!\#\$\%\&\'*\+\-\/\=\?\^_`\{\|\}\~]+@[A-Za-z0-9]+[A-Za-z0-9\-\.]+\.[A-Za-z0-9\-\.]+[A-Za-z0-9]+)$";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(inputString);
    return matcher.matches();
}

Ответ на этот вопрос: - Требование подтвердить адрес электронной почты с заданными баллами

Explanation-

1. (?!. *? ..) «Отрицательный Lookhead» для отрицания 2 последовательных точек.
2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + Определено по крайней мере один символ. («\» используется для побега).
3. @ Там может быть один "@".
4. [A-Za-z0-9] + затем определен хотя бы один символ.
5. [A-Za-z0-9 -.] * Ноль или любое повторение определенного символа.
6. [A-Za-z0-9] + По крайней мере один символ после точки.

Ключевым моментом здесь является то, что вы хотите полностью подтвердить адрес электронной почты. Вы не просто хотите проверить правильность синтаксиса, вы хотите проверить, является ли адрес электронной почты реальным.

Две очевидные причины: реальные пользователи часто неправильно вводят свои адреса электронной почты, а некоторые пользователи могут вводить поддельные адреса электронной почты. Следовательно, вы хотите выполнить синтаксическую проверку и проверку существования.

Лучший способ сделать это, как я обнаружил на Android, - использовать для этого бесплатный API Cloudmersive Validation .

Код выглядит так:

ApiClient defaultClient = Configuration.getDefaultApiClient();

// Configure API key authorization: Apikey
ApiKeyAuth Apikey = (ApiKeyAuth) defaultClient.getAuthentication("Apikey");
Apikey.setApiKey("YOUR API KEY");

EmailApi apiInstance = new EmailApi();
String email = "email_example"; // String | Email address to validate, e.g. \"support@cloudmersive.com\". The input is a string so be sure to enclose it in double-quotes.
try {
    FullEmailValidationResponse result = apiInstance.emailFullValidation(email);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling EmailApi#emailFullValidation");
    e.printStackTrace();
}

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

Простейшее решение Kotlin с использованием функций расширения:

fun String.isEmailValid() =
            Pattern.compile(
                    "[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +
                            "\\@" +
                            "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}" +
                            "(" +
                            "\\." +
                            "[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25}" +
                            ")+"
            ).matcher(this).matches()

и тогда вы можете проверить, как это:

"testemail6589@gmail.com".isEmailValid()

Обратите внимание, что большинство регулярных выражений недопустимы для международных доменных имен (IDN) и новых доменов верхнего уровня, таких как .mobi или .info (если вы проверяете коды стран или .org, .com, .gov и т. Д.).

Действительная проверка должна отделять локальную часть (перед знаком) и часть домена. Также следует учитывать максимальную длину локальной части и домена (в сумме 255 символов, включая знак at).

Наилучший подход - преобразовать адрес в совместимый с IDN формат (если требуется), проверить локальную часть (RFC), проверить длину адреса и проверить доступность домена (поиск DNS MX) или просто отправить электронное письмо. ,

Класс Linkify имеет несколько довольно полезных вспомогательных методов, которые могут быть полезны, в том числе регулярные выражения, предназначенные для сбора телефонных номеров и адресов электронной почты, и тому подобное:

http://developer.android.com/reference/android/text/util/Linkify.html

Я использовал следующий код. Это работает. Надеюсь, это поможет вам.

if (validMail(yourEmailString)){
   //do your stuf
 }else{
 //email is not valid.
}

и используйте следующий метод. Это возвращает true, если электронная почта действительна.

    private boolean validMail(String yourEmailString) {
    Pattern emailPattern = Pattern.compile(".+@.+\\.[a-z]+");
    Matcher emailMatcher = emailPattern.matcher(emailstring);
    return emailMatcher.matches();
}

электронная почта - это ваша электронная почта.

public boolean validateEmail(String email) {

    Pattern pattern;
    Matcher matcher;
    String EMAIL_PATTERN = "^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";
    pattern = Pattern.compile(EMAIL_PATTERN);
    matcher = pattern.matcher(email);
    return matcher.matches();

    }

Для любителей регулярных выражений самый лучший (например, совместимый с RFC 822) шаблон электронной почты, который я когда-либо обнаруживал с тех пор, - следующий (до того, как PHP предоставил фильтры). Я думаю, это легко перевести на Java - для тех, кто играет с API <8:

private static function email_regex_pattern() {
// Source:  http://www.iamcal.com/publish/articles/php/parsing_email
$qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]';
$dtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]';
$atom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c'.
    '\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+';
$quoted_pair = '\\x5c[\\x00-\\x7f]';
$domain_literal = "\\x5b($dtext|$quoted_pair)*\\x5d";
$quoted_string = "\\x22($qtext|$quoted_pair)*\\x22";
$domain_ref = $atom;
$sub_domain = "($domain_ref|$domain_literal)";
$word = "($atom|$quoted_string)";
$domain = "$sub_domain(\\x2e$sub_domain)*";
$local_part = "$word(\\x2e$word)*";
$pattern = "!^$local_part\\x40$domain$!";
return $pattern ;
}

Вы можете очень легко выполнить любой тип проверки в Android с помощью файла oval.jar. OVal - это прагматичная и расширяемая платформа валидации общего назначения для любых объектов Java.

перейдите по этой ссылке: http://oval.sourceforge.net/userguide.html

Вы можете скачать это здесь: http://oval.sourceforge.net/userguide.html#download

Вы можете использовать проверку, устанавливая теги в переменных

public class Something{

    @NotEmpty  //not empty validation
    @Email     //email validation
    @SerializedName("emailAddress")
    private String emailAddress;
}

   private void checkValidation() {
        Something forgotpass.setEmailAddress(LoginActivity.this.dialog_email.getText().toString());
        Validator validator = new Validator();
        //collect the constraint violations
        List<ConstraintViolation> violations = validator.validate(forgotpass);
        if(violations.size()>0){
            for (ConstraintViolation cv : violations){
                if(cv.getMessage().contains("emailAddress")){
                    dialog_email.setError(ValidationMessage.formattedError(cv.getMessage(), forgotpass));
                }
            }
        }
}

Вы также можете использовать

InternetAddress emailAddr = new InternetAddress(email);
emailAddr.validate();

Если адрес электронной почты недействителен, он выдаст исключение AddressException .

К сожалению, Android не поддерживает jndi-dns , но просто чтобы дать вам представление о более мощной проверке электронной почты, вы можете использовать ее для проверки почтового домена. Может быть, гуру Android мог бы помочь и показать, есть ли подобные альтернативы ... Пример реализации с «обычной» java доступен здесь .

РЕДАКТИРОВАТЬ

Я только что понял, что javax.mail не поддерживает ни один ... Но этот пост показывает обходной путь .