проверьте, действительно ли письмо действительное. android [duplicate]

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

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

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

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

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

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

http://developer.android. ком / ссылки / Android / текст / Util / Linkify.html

Самый простой способ проверки электронной почты.

EditText TF;
public Button checkButton;

public 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}" +
          ")+"
      );
 @Override
 public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWindowFeature(Window.FEATURE_NO_TITLE);
    setContentView(R.layout.main);

   TF=(EditText) findViewById(R.id.TF);
   checkButton=(Button) findViewById(R.id.checkButton);

    checkButton.setOnClickListener(new OnClickListener() {
    public void onClick(View v) {
           String email=TF.getText().toString();
           if(checkEmail(email))
              Toast.makeText(getApplicationContext(),"Valid Email Addresss", Toast.LENGTH_SHORT).show();
           else
              Toast.makeText(getApplicationContext(),"Invalid Email Addresss", Toast.LENGTH_SHORT).show();
    }
    });
}
private boolean checkEmail(String email) {
    return EMAIL_ADDRESS_PATTERN.matcher(email).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;
}

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

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

Если сообщение недействительно, оно будет вызывать исключение AddressException.

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

EDIT

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

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

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

И затем называть его следующим образом:

email.isValidEmail()

Для любителей регулярных выражений самый лучший (например, консистенция с RFC 822) шаблон электронной почты, который я когда-либо находил, является следующим (перед фильтрами, поставляемыми PHP). Я думаю, что это легко перевести на Java - для тех, кто играет с API & lt; 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 ;
}

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

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

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

private boolean isEmailValid(String email) {
    return !TextUtils.isEmpty(email) && 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;
}

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

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

    }

Поскольку 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 & lt; 8.

Если вы используете 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 Studio:

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

Еще одна опция - встроенные шаблоны , начиная с уровня 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();
  }
}

Доступные для просмотра шаблоны источники

OR

Однострочное решение от @AdamvandenHoven:

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

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

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

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

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

Вы можете сделать любой тип проверки в 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));
                }
            }
        }
}

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

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

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

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

!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 ТОЛЬКО, текст не начинался.

FORMAT CHECKER

Если я напишу это письмо, он даст мне: 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);
}

RETURN: false

ВОЗВРАТ: 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.

Следующий шаблон используется в письме 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();
}

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

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

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

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

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

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

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

Могу ли я настоятельно рекомендовать вам не пытаться «проверять» адреса электронной почты, вы просто получите много работы без уважительной причины.

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

Все остальное просто вызовет много работы для минимального возврата ...

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

Следующее использовалось мной.

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. [A-Za- z0-9.! # \ $ \% \ & amp; \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + По крайней мере один символ определен. («\» используется для экранирования).
3. @ Может быть один «@».
4. [A-Za-z0-9] +, тогда по крайней мере один символ определен.
5. [A-Za-z0-9 -.] * Нуль или любое повторение определенного символа.
6. [A-Za-z0-9] + По крайней мере один символ после точки.

Подтвердите свой формат адреса электронной почты. 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();
}

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

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