378

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?

Improve this question
3
  • please refers this one, may it will help you: stackoverflow.com/questions/12947620/… Commented Apr 15, 2013 at 4:48
  • 1
    @user2757064 well this question should help the other question you linked. That question was asked 3 years after this. :) Commented Aug 15, 2014 at 7:44
  • for simple check: if(!Patterns.EMAIL_ADDRESS.matcher(editTextEmail.getText().toString()).matches()){ //show toast:enter valid email } Commented Dec 2, 2022 at 19:08

35 Answers 35

Reset to default
1
2
1145

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(); }
Improve this answer
Sign up to request clarification or add additional context in comments.

23 Comments

+1 , but i prefer replace the (target == null) with TextUtils.isEmpty(target) :)
Answers like these are why I dislike accepted answers being shown on top, instead of answers with most votes.
Would it also not make more sense (readability wise) to simply combine this into one line: return !TextUtils.isEmpty(target) && android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
@Houcine, true but the method above returns boolean so we don't have that information when it is false. Anyway, one can toast or update ui from inside the function(must be run in UI thread). For those like me, who are validating an email obtained programmatically and with no user interaction whatsoever, we can just stick with '== null' and maybe save a couple of clock cycles in most cases.
Be careful. This matcher accepts [email protected] as a valid email
|
108

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

7 Comments

Why not use android.util.Patterns.EMAIL_ADDRESS ?
cause it exists since API Level 8 only
this helped me a lot thanks and +1 for the simple answer.. :)
FYI: inside character classes the metacharacters much fewer and the hyphen is automatically escaped when put at a border, you can simplify the first class to [a-zA-Z0-9+._%-] and the others to [a-zA-Z0-9-]
This only return true if the email syntax is the same as email does, I tried to remove i from @gmail.com it will return true. Same in `@yaho.com .
|
76

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.

Improve this answer

1 Comment

"[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]" Why did they repeat '+' twice?
70

We have a simple Email pattern matcher now.

Java:

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

Kotlin Function:

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

Kotlin Extension:

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

Comments

55

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 "[email protected]", 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.

Improve this answer

7 Comments

I know this answer is about two years old, but when I try this regex using regexr.com, it validates [email protected], and even longer tlds like .museum. Am I missing something? I don't want to block any of my users by failing to validate their valid e-mail address, but this seems to be working for anything I can think of.
@Bob validate Email Address on the server.. check foursquare app it does the same
I'm a bit confused why you start this answer with "Don't use a reg-ex" and then proceed to provide a reg-ex.
Please keep reading. A better solution is below which does not use regex.
@Glen . Would this hold true for Android's Pattern. EMAIL_ADDRESS ? developer.android.com/reference/android/util/…
|
25

Use simple one line code for email Validation

public 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(); }
Improve this answer

Comments

21

You could write a Kotlin extension like this:

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

And then call it like this:

email.isValidEmail()
Improve this answer

3 Comments

who is "Patterns"?
android.util.Patterns
that Util pattern accepts "[email protected]"
15

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

2 Comments

null check email == null is redandunt as TextUtils checks it inside
@VolodymyrKhodonovych you're right, but the null check is done in a OR state, not doing this could lead to a NPE when passing email to the matcher() method.
12

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

Comments

11

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

Pattern pattern = Pattern.compile(".+@.+\\.[a-z]+"); String email = "[email protected]"; Matcher matcher = pattern.matcher(email); boolean matchFound = matcher.matches();

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

Improve this answer

3 Comments

This fails on the following valid email address: "Example Guy" <[email protected]>. While you technically can validate email with a regex, it's a little absurd to do so.
Thats not just an email address though.
This also matches "guy@@example. com" (not unexpected for users to press the same key twice and some keyboards add a space after a period). This also doesn't support unicode characters. Here are examples of unusual yet valid addresses: en.wikipedia.org/wiki/International_email
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(); }
Improve this answer

Comments

9

Simplest Kotlin solution using extension functions:

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

and then you can validate like this:

"[email protected]".isEmailValid()

If you are in kotlin-multiplatform without access to Pattern, this is the equivalent:

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

1 Comment

You just ripped off android.util.Patterns.EMAIL_ADDRESS and claimed it your own?
8

this is the best way in kotlin Useing Extension Function

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

1 Comment

No need for TextUtils.isEmpty(this). this.isNotEmpty() is the standard way of testing for non empty strings.
6

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; } }
Improve this answer

Comments

6

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.

Improve this answer

Comments

5

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...

Improve this answer

5 Comments

When working with subscriptions and payments this is hardly useful advice. If someone forgets their password we must have a way of securely resetting their password to allow them to continue using the service they have paid for. So sometimes it is best that we ensure they are entering a valid e-mail address for their own sake.
Just to be clear about what I said - if someone is intent on entering a fake/wrong address - no amount of validation will stop them.. Checking for silly mistakes like spaces and no '@' etc. is fine - checking anything else is well into 'diminishing returns'...
The only way to identify a fake email is via sending an email to that email id and check whether u receive an undelivered report...
John, many users will not be intent on entering a fake/wrong address, but may enter it incorrectly by accident. So performing a simple check can be very useful and, as shown in mindriot's answer, is not a lot of work. From my experience, most people enter their email addresses correctly, and the few invalid emails most often seem to be down to innocent typo's.
If it is important that the user's email works you send a confirmation email. Everything else is nonsense.
4 
 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; }
Improve this answer

Comments

4

Email Validation in Kotlin:

val email = etEmail.text.toString().trim() // get email from user if(isValidEmail(email)){ // call isValidEmail function and pass email in parameter // Your email ID is Valid }else{ // Enter your valid email ID }

This method is used for checking valid email id formats.

 fun isValidEmail(email: CharSequence): Boolean { var isValid = true val expression = "^[\\w.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$" val pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE) val matcher = pattern.matcher(email) if (!matcher.matches()) { isValid = false } return isValid }
Improve this answer

4 Comments

matcher.matches() return a boolean thus you can return it directly without storing it in isValid
Yeah, we can do like that. Thanks for suggestions
Regex is a bad choice to validate e-mail addresses.
Then how to validate email @tiktak
3

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

Improve this answer

Comments

3

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.
Improve this answer

Comments

3

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

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

You may modify this pattern for your case then validate by

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

Comments

2

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; }
Improve this answer

Comments

2

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; }
Improve this answer

Comments

2

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

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.

Improve this answer

Comments

2

According to Patterns.EMAIL_ADDRESS, this email is correct "[email protected]". So I modified the regex in Patterns.EMAIL_ADDRESS and increased the minimum length for domain. Here is the function for Kotlin:

fun isEmailValid(email: String): Boolean = email.isNotEmpty() && 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\\-]{1,25}" + ")+" ).matcher(email).matches()

I just changed domain part from {0,25} to {1,25}.

Improve this answer

2 Comments

Technically a 1 letter top level domain could be introduced. It is legal per RFC-952.
I think you would need to change it to {2,25} if you really wanted to ensure the minimum domain length is 2
1

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.

Improve this answer

Comments

1

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

Improve this answer

Comments

1

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

Comments

1

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

Comments

1

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 ; }
Improve this answer

Comments

1
2

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.