How should I validate an e-mail address?

问题:

What\'s a good technique for validating an e-mail address (e.g. from a user input field) in Android? org.apache.commons.validator.routines.EmailValidator doesn\'t seem to be available. Are there any other libraries doing this which are included in Android already or would I have to use RegExp?

回答1:

Don\'t use a reg-ex.

Apparently the following is a reg-ex that correctly validates most e-mails addresses that conform to RFC 2822, (and will still fail on things like \"[e-mail]\", as will 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])+)\\])

Possibly the easiest way to validate an e-mail to just send a confirmation e-mail to the address provided and it it bounces then it\'s not valid.

If you want to perform some basic checks you could just check that it\'s in the form *@*

If you have some business logic specific validation then you could perform that using a regex, e.g. must be a gmail.com account or something.

回答2:

Another option is the built in Patterns starting with API Level 8:

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

OR

One line solution from @AdamvandenHoven:

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

回答3:

Next pattern is used in 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}\" +
          \")+\"
      );

You can use function

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

回答4:

Since API 8 (android 2.2) there is a pattern: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

So you can use it to validate yourEmailString:

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

returns true if the email is valid

UPD: This pattern source code is:

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

refer to: http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/util/Patterns.java

So you can build it yourself for compatibility with API < 8.

回答5:

We have simple Email pattern matcher now

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

回答6:

This is Android Studio suggestions:

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

回答7:

use android:inputType=\"textEmailAddress\" as below:

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

and:

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

回答8:

You can use regular expression to do so. Something like the following.

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

String email = \"[e-mail]\";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Note: Check the regular expression given above, don\'t use it as it is.

回答9:

Use simple one line code for email Validation

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

use like...

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

回答10:

There is a Patterns class in package android.util which is beneficial here. Below is the method I always use for validating email and many other stuffs

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

回答11:

Call This Method where you want to validate email 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;
   }
}

回答12:

For an Email validation android provide some InBuilt Pattern.But it only support API level 8 and above.

Here is code for use that pattern to check email validation.

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

Make sure that after execute this method you should check that if this method return true then you allow to save email and if this method return false then display message that email is \"Invalid\".

Hope you get your answer, Thanks you.

回答13:

Validate your email address format. [e-mail]

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

回答14:

You could write a Kotlin extension like this:

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

And then call it like this:

email.isValidEmail()

回答15:

Can I STRONGLY recommend you don\'t try to \'validate\' email addresses, you\'ll just get yourself into a lot of work for no good reason.

Just make sure what is entered won\'t break your own code - e.g. no spaces or illegal characters which might cause an Exception.

Anything else will just cause you a lot of work for minimal return...

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

回答17:

I know that It\'s very too late, still I will give my answer.

I used this line of code to check the inputted Email format:

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

The problem is, it will only check for the FORMAT not the SPELLING.

When I entered @gmal.com missing i ,and @yaho.com missing another o . It return true. Since it satisfies the condition for Email Format.

What I did is, I used the code above. Since it will give / return true if the if the user inputted @gmail.com ONLY, no text at the start.

FORMAT CHECKER

If I enter this email it will give me: true but the spelling is wrong. In my textInputLayout error

EMAIL ADDRESS @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

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\"/>

Note: I tried to get the value from EditText and used split on it and even StringTokenizer. Both return false to me.

回答18:

Try this simple method which can not accept the email address beginning with digits:

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

回答19:

Try this code.. Its really works..

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

回答20:

If you are using API 8 or above, you can use the readily available Patterns class to validate email. Sample code:

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

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

By chance if you are even supporting API level less than 8, then you can simply copy the Patterns.java file into your project and reference it. You can get the source code for Patterns.java from this link

回答21:

Here is 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 will match it if

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

Example some special match email

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

You may modify this pattern for your case then validate by

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

回答22:

The key here is that you want to fully validate the email address. You don’t just want to check it for syntactic correctness, you want to check whether the email address is real.

Two obvious reasons: real users often mis-type their email addresses, and some users may put in fake email addresses. Therefore, you want to do a syntactic check and an existence check.

The best way to do this that I have found on Android is to use the free Cloudmersive Validation API for this.

The code looks like this:

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. \\\"[e-mail]\\\". 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();
}

I’m using this in all my apps and it is great because I can validate the email addresses in the UX at the point of entry.

回答23:

Note that most of the regular expressions are not valid for international domain names (IDN) and new top level domains like .mobi or .info (if you check for country codes or .org, .com, .gov and so on).

A valid check should separate the local part (before the at-sign) and the domain part. You should also consider the max length of the local part and domain (in sum 255 chars including the at-sign).

The best approach is to transform the address in an IDN compatible format (if required), validate the local part (RFC), check the length of the address and the check the availability of the domain (DNS MX lookup) or simply send an email.

回答24:

The Linkify class has some pretty useful helper methods that might be relevant, including regular expressions designed to pick up phone numbers and email addresses and such:

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

回答25:

I have used follwing code.This works grate.I hope this will help you.

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

and use follwing method.This returns true if email is valid.

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

回答26:

email is your email-is.

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

    }

回答27:

For regex lovers, the very best (e.g. consistant with RFC 822) email\'s pattern I ever found since now is the following (before PHP supplied filters). I guess it\'s easy to translate this into Java - for those playing with 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 ;
}

回答28:

You can do any type of validation in android very easily by the oval.jar file. OVal is a pragmatic and extensible general purpose validation framework for any kind of Java objects.

follow this link: http://oval.sourceforge.net/userguide.html

You can downlaod this from here: http://oval.sourceforge.net/userguide.html#download

You can use validation by setting tags in variables

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

回答29:

You could also use

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

If the email is not valid it will throw an AddressException.

Unfortunately Android doesn\'t support jndi-dns, but just to give you an idea of a more powerful email validation, you could use it to validate the email domain. Maybe an Android guru could help and show if there are similar alternatives... An example implementation with \"regular\" java is available here.

EDIT

I just realized that javax.mail isn\'t support neither... But this post shows a workaround.

回答30:

Following was used by me. However it contains extra characters than normal emails but this was a requirement for me.

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

Answer of this question:- Requirement to validate an e-mail address with given points

Explanation-

1. (?!.*?..) \"Negative Lookhead\" to negate 2 consecutive dots.
2. [A-Za-z0-9.!#\\$\\%\\&\\\'*+-/\\=\\?\\^_`{\\|}\\~]+ Atleast one characters defined. (\"\\\" is used for escaping).
3. @ There might be one \"@\".
4. [A-Za-z0-9]+ then atleast one character defined.
5. [A-Za-z0-9-.]* Zero or any repetition of character defined.
6. [A-Za-z0-9]+ Atleast one char after dot.