Android 我应该如何验证电子邮件地址？

在Android中，验证电子邮件地址（例如来自用户输入字段）的好方法是什么？似乎没有。是否有其他库已经包含在Android中，或者我必须使用RegExp？不要使用reg-ex

显然，以下是一个reg-ex，它可以正确验证大多数符合的电子邮件地址（但在以下情况下仍然会失败）：user@gmail.com.nospam“，以及org.apache.commons.validator.routines.EmailValidator）

验证电子邮件的最简单方法可能是只向提供的地址发送一封确认电子邮件，如果该电子邮件被退回，则该电子邮件无效

如果您想执行一些基本检查，只需检查其格式是否为

*@*

---

如果您有一些特定于业务逻辑的验证，那么您可以使用正则表达式执行该验证，例如必须是gmail.com帐户或其他内容。

请注意，大多数正则表达式对于国际域名（IDN）和新的顶级域（如.mobi或.info）无效（如果您查看国家代码或.org、.com、.gov等）

一个有效的检查应该将局部部分（在AT符号之前）和域部分分开。还应该考虑局部部分和域的最大长度（包括255个字符，包括AT符号）。

---

最好的方法是将地址转换为与IDN兼容的格式（如果需要）、验证本地部分（RFC）、检查地址的长度和域的可用性（DNS MX查找）或只发送电子邮件。

您可以使用正则表达式执行此操作。类似于以下内容

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

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.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();
}

---

尝试此简单方法，该方法无法接受以数字开头的电子邮件地址：

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

---

Linkify类有一些非常有用的助手方法，这些方法可能是相关的，包括用于提取电话号码和电子邮件地址的正则表达式，等等：

---

另一个选项是内置的，从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();
}

---

我强烈建议你不要试图“验证”电子邮件地址，你会无缘无故地投入大量工作

只需确保输入的内容不会破坏您自己的代码-例如，没有空格或可能导致异常的非法字符

---

其他任何东西都会给你带来大量的工作以获得最低回报…

我使用了以下代码。这很有效。我希望这会对你有所帮助

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

---

自从API 8（android 2.2）以来，就有一种模式：android.util.Patterns.EMAIL\u ADDRESS

因此，您可以使用它来验证电子邮件字符串：

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}" +
        ")+"
    );

参考：

---

因此，您可以自己构建它，以便与API<8兼容。

电子邮件就是您的电子邮件

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

---

在要验证电子邮件ID的位置调用此方法

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

---

通过oval.jar文件，您可以很容易地在android中进行任何类型的验证。oval是一个实用且可扩展的通用验证框架，适用于任何类型的Java对象

请点击此链接：

你可以从这里下载：

可以通过在变量中设置标记来使用验证

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

公共类{
@NotEmpty//NotEmpty验证
@电子邮件//电子邮件验证
@SerializedName（“电子邮件地址”）
私有字符串电子邮件地址；
}
私有void checkValidation（）{
放弃pass.setEmailAddress（LoginActivity.this.dialog_email.getText（）.toString（））的内容；
Validator Validator=新验证器（）；
//收集约束冲突
列表冲突=validator.validate（forgotpass）；
如果（冲突.size（）>0）{
对于（约束约束cv：违规）{
如果（cv.getMessage（）包含（“电子邮件地址”））{
对话框_email.setError（ValidationMessage.formattedError（cv.getMessage（），forgotpass））；
}
}
}
}

验证您的电子邮件地址格式。-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();
}

---

试试这个代码。它真的很有效

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

使用android:inputType=“textEmailAddress”，如下所示：

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

---

我们现在有一个简单的电子邮件模式匹配器

Java:

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

 private fun isValidEmail(email: String): Boolean {
        return !TextUtils.isEmpty(email) && Patterns.EMAIL_ADDRESS.matcher(email).matches()
    }

fun String.isValidEmail() =
    !TextUtils.isEmpty(this) && Patterns.EMAIL_ADDRESS.matcher(this).matches()

Kotlin函数：

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

 private fun isValidEmail(email: String): Boolean {
        return !TextUtils.isEmpty(email) && Patterns.EMAIL_ADDRESS.matcher(email).matches()
    }

fun String.isValidEmail() =
    !TextUtils.isEmpty(this) && Patterns.EMAIL_ADDRESS.matcher(this).matches()

Kotlin扩展名：

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

 private fun isValidEmail(email: String): Boolean {
        return !TextUtils.isEmpty(email) && Patterns.EMAIL_ADDRESS.matcher(email).matches()
    }

fun String.isValidEmail() =
    !TextUtils.isEmpty(this) && Patterns.EMAIL_ADDRESS.matcher(this).matches()

---

这是Android Studio的建议：

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

---

对于电子邮件验证，android提供了一些。但它只支持API级别8及更高级别

下面是使用该模式检查电子邮件验证的代码

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

确保在执行此方法后，您应该检查如果此方法返回true，则您允许保存电子邮件，如果此方法返回false，则显示电子邮件“无效”的消息

希望你得到你的答案，

---

谢谢。

使用简单的单行代码进行电子邮件验证

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

---

如果您使用的是API 8或更高版本，则可以使用现成的

模式
类来验证电子邮件。示例代码：

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
类，这在这里很有用。下面是met我总是使用hod来验证电子邮件和许多其他东西

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

下面是我使用的。但是它是有限的
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()
}

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

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

fun String.isValidEmail() = Regex(emailRegexStr).matches(this)

fun String.isEmailValid(): Boolean {
        return !TextUtils.isEmpty(this) && android.util.Patterns.EMAIL_ADDRESS.matcher(this).matches()
    }