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

еще один вариант-встроенный Шаблоны начиная с уровня 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 mail:

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.утиль.Узоры.АДРЕС ЭЛЕКТРОННОЙ ПОЧТЫ 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

теперь у нас есть простой шаблон электронной почты matcher

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

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

public static boolean isEmailValid(String email) {
    return !(email == null || TextUtils.isEmpty(email)) && android.util.Patterns.EMAIL_ADDRESS.matcher(email).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();
      }

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

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

String email = "[email protected]";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

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

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

public final 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();
}

есть 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;
   }
}

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

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

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

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

надеюсь, вы получите свой ответ, Спасибо вам.

Проверьте формат адреса электронной почты. [email protected]

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

я знаю, что уже очень поздно, все же я дам свой ответ.

я использовал эту строку кода для проверки введенного :

!TextUtils.isEmpty(getEmail) && android.util.Patterns.EMAIL_ADDRESS.matcher(getEmail).matches();

проблема в том, что он будет проверять только FORMAT не SPELLING.

когда я вошел @gmal.com отсутствует i и @yaho.com отсутствует еще один o . Это возвращение true. Так как он удовлетворяет условию Email Format.

что я сделал, я использовал код выше. Так как это будет отдай / верни true если если пользователь ввел @gmail.comтолько, без текста в начале.

ПРОВЕРКА ФОРМАТА

если я введу это письмо, оно даст мне:true но написание неверно. В мой textInputLayout error

АДРЕС ЭЛЕКТРОННОЙ ПОЧТЫ @yahoo.com,@gmail.com,@outlook.com CHECKER

 //CHECK EMAIL
public boolean checkEmailValidity(AppCompatEditText emailFormat){

    String getEmail = emailFormat.getText().toString();
    boolean getEnd;

    //CHECK STARTING STRING IF THE USER
    //entered @gmail.com / @yahoo.com / @outlook.com only
    boolean getResult = !TextUtils.isEmpty(getEmail) && android.util.Patterns.EMAIL_ADDRESS.matcher(getEmail).matches();

    //CHECK THE EMAIL EXTENSION IF IT ENDS CORRECTLY
    if (getEmail.endsWith("@gmail.com") || getEmail.endsWith("@yahoo.com") || getEmail.endsWith("@outlook.com")){
        getEnd = true;
    }else {
        getEnd = false;
    }

    //TEST THE START AND END
    return (getResult && getEnd);
}

вернуться: false

RETURN:true

XML:

<android.support.v7.widget.AppCompatEditText
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:id="@+id/editTextEmailAddress"
            android:inputType="textEmailAddress|textWebEmailAddress"
            android:cursorVisible="true"
            android:focusable="true"
            android:focusableInTouchMode="true"
            android:singleLine="true"
            android:maxLength="50"
            android:theme="@style/EditTextCustom"/>

Примечание: я пытался получить value из EditText и использовать split и StringTokenizer. Оба возвращаются false для меня.

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

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

вы можете написать расширение Kotlin следующим образом:

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

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

email.isValidEmail()

здесь android.util.Patterns.EMAIL_ADDRESS

[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})+

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, -)

пример некоторых специальных матч электронной почты

[email protected]
[email protected]
[email protected]

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

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

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

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

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

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

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. \"[email protected]\". 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 в точке входа.

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

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

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

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

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

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

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

и использовать метод follwing.Это возвращает 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

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 очень легко, овальные.файл jar. OVal-это прагматичная и расширяемая платформа проверки общего назначения для любых объектов Java.

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

вы можете downlaod это отсюда: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-ДНС, но просто чтобы дать вам представление о более мощной проверки электронной почты, вы можете использовать его для проверки домена электронной почты. Возможно, гуру Android может помочь и показать, есть ли подобные альтернативы... Пример реализации с "обычной" java доступно здесь.

EDIT

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

если вы используете 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 С этой ссылке

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

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

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

объяснение

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