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

Question

在Android中验证电子邮件地址（例如来自用户输入字段）的好方法是什么？ org.apache.commons.validator.routines.EmailValidator似乎不可用。是否还有其他库已经包含在Android中，或者我必须使用RegExp吗？

Answer 1

另一个选项是从API级别8开始的内置Patterns：

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

Patterns viewable source

或

来自@AdamvandenHoven的一线解决方案：

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

Answer 2

下一个模式用于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();
}

Answer 3

从API 8（android 2.2）开始，有一个模式：android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

所以你可以用它来验证你的电子邮件串：

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。

Answer 4

不要使用注册表。

显然，以下是一个注册表，可以正确验证符合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帐户或其他东西。

Answer 5

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

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

Answer 6

这是Android Studio建议：

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

Answer 7

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

Answer 8

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

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

Answer 9

您可以使用正则表达式来执行此操作。如下所示。

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

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

注意：检查上面给出的正则表达式，不要按原样使用它。

Answer 10

包Patterns中有一个android.util类，这在这里很有用。以下是我经常用于验证电子邮件和许多其他内容的方法

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

Answer 11

您可以像这样写一个Kotlin扩展名：

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

然后像这样称呼它：

email.isValidEmail()

Answer 12

在您要验证电子邮件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;
   }
}

Answer 13

对于电子邮件验证，android会提供一些InBuilt Pattern。但它只支持 API级别8及以上。

以下是用于检查电子邮件验证的模式的代码。

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

确保在执行此方法后，您应检查此方法是否返回 true ，然后您允许保存电子邮件，如果此方法返回 false ，则会显示该电子邮件的消息是＆＃34;无效＆＃34;。

希望你得到答案， 谢谢你。

Answer 14

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

Answer 15

这是 kotlin 中使用扩展函数的最佳方式

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

Answer 16

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

Answer 17

我是否可以强烈建议您不要尝试“验证”电子邮件地址，您将无缘无故地完成大量工作。

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

其他任何事情只会让你做出很多努力以获得最低回报......

Answer 18

这里是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, -)

以一些特殊的匹配电子邮件为例

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

Answer 19

试试这段代码..它真的有用..

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

Answer 20

如果您使用的是API 8或更高版本，则可以使用随时可用的 function replace() { var fixedPiece = "sentence"; var firstPart = "I replaced the "; var secondPart = " using javascript"; var wholeSentence = document.getElementById("testdiv").innerHTML; var index = wholeSentence.indexOf('sentence'); var newSentence = wholeSentence.replace(wholeSentence.substr(0, index - 1), firstPart).substr(0, index + fixedPiece.length); var newSentence = newSentence.concat(secondPart); document.getElementById("testdiv").innerHTML = newSentence; } 类来验证电子邮件。示例代码：

Patterns

如果您甚至支持少于8的API级别，那么您只需将public final static boolean isValidEmail(CharSequence target) { if (target == null) return false; return android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches(); } 文件复制到项目中并引用它即可。您可以从this link

获取Patterns.java的源代码

Answer 21

此处的关键是您要完全验证电子邮件地址。您不仅要检查语法是否正确，还想检查电子邮件地址是否真实。

两个明显的原因：真实用户经常误输入其电子邮件地址， 一些用户可能会输入伪造的电子邮件地址。因此，您要进行语法检查和存在检查。

我在Android上发现的最好方法是为此使用免费的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. \"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 中的电子邮件地址。

Answer 22

使用扩展功能的最简单的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()

Answer 23

尝试这种简单的方法，不能接受以数字开头的电子邮件地址：

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

Answer 24

我知道现在已经太晚了，我仍然会给出答案。

我使用这行代码检查输入的Email格式：

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

问题是，它只会检查FORMAT而不是SPELLING。

当我输入@gmal.com时遗失i，@yaho.com遗漏了另一个o。 它返回true。因为它满足Email Format的条件。

我做的是，我使用了上面的代码。因为它会给/返回true if 如果用户输入@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);
}

返回：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"/>

注意：我尝试从EditText获取value并在其上使用split甚至StringTokenizer。两者都返回false给我。

Answer 25

您也可以使用

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

如果电子邮件无效，则会抛出 AddressException 。

不幸的是Android doesn't support jndi-dns，但为了让您了解更强大的电子邮件验证，您可以使用它来验证电子邮件域。也许Android专家可以帮助并显示是否有类似的替代方案......使用“常规”java is available here的示例实现。

修改

我刚才意识到javax.mail既不支持......但是这篇文章显示了workaround。

Answer 26

您可以通过oval.jar文件轻松地在android中进行任何类型的验证。 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));
                }
            }
        }
}

Answer 27

对于正则表达式爱好者来说，从现在开始我发现的最好的（例如与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 ;
}

Answer 28

电子邮件是您的电子邮件。

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

    }

Answer 29

以下是我使用的。但是它包含的字符多于普通电子邮件，但这对我来说是必需的。

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

回答这个问题： - Requirement to validate an e-mail address with given points

解释 -

1. （？！。*？..）＆＃34;负面观察＆＃34;否定连续两个点。
2. [A-Za-z0-9。！＃\ $ \％\＆amp; \＆＃39; * + - / \ = \？\ ^ _` {\ |} \〜] + Atleast one 字符定义。 （＆＃34; \＆＃34;用于转义）。
3. @可能有一个＆＃34; @＆＃34;。
4. [A-Za-z0-9] +然后至少定义一个字符。
5. [A-Za-z0-9 - 。] *零或任何重复的字符定义。
6. [A-Za-z0-9] +点后面的一个字符。

Answer 30

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

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

Answer 31

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

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

Answer 32

根据 Patterns.EMAIL_ADDRESS，这封电子邮件是正确的“abc@abc.c”。所以我修改了 Patterns.EMAIL_ADDRESS 中的正则表达式并增加了域的最小长度。 这是 Kotlin 的函数：

for x in range()

我刚刚将域部分从 {0,25} 更改为 {1,25}。

Answer 33

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

有效检查应将本地部分（在at符号之前）与域部分分开。您还应该考虑本地部分和域的最大长度（总共255个字符，包括at符号）。

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

Answer 34

最简单的电子邮件验证方式。

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

Answer 35

Kotlin 扩展函数

fun EditText.isValidEmail() : Boolean{
    return if(Pattern
            .compile("^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$")
            .matcher(text.toString()).matches()){
        true
    }else {
        hint = context.getString(R.string.invalid_email_adress)
        false
    }
}

使用

if(!emailEt.isValidEmail()){
    return
}