Comment valider une adresse e-mail?

une autre option est intégrée dans Patterns à partir du niveau 8 de L'API:

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

Patterns view source

ou

Une solution en ligne de @AdamvandenHoven:

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

motif suivant est utilisé dans 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}" +
          ")+"
      );

vous pouvez utiliser la fonction

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

depuis API 8 (android 2.2) il y a un pattern: android.util.Modèle.ADRESSE http://developer.android.com/reference/android/util/Patterns.html

pour que vous puissiez l'utiliser pour valider votre chaîne de messagerie:

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

retourne true si l'email est valide

UPD: Ce code source est:

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

se référer à: http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/util/Patterns.java

de sorte que vous pouvez le construire vous-même pour la compatibilité avec API < 8.

nous avons simple email pattern matcher maintenant

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

ce sont les suggestions de studio Android:

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

utiliser android:inputType= "textEmailAddress" comme ci-dessous:

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

et:

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

vous pouvez utiliser l'expression régulière pour le faire. Quelque chose comme ce qui suit.

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

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Note: cochez l'expression régulière donnée ci-dessus, ne l'utilisez pas telle quelle.

utilisez un code d'une ligne simple pour la Validation de courriel

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

utiliser comme...

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

il y a une classe Patterns dans l'emballage android.util qui est bénéfique ici. Ci-dessous est la méthode que j'utilise toujours pour valider l'e-mail et beaucoup d'autres choses

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

appelez cette méthode où vous voulez valider votre adresse email.

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

pour un email de validation android fournir quelques modèle intégré .Mais il ne supporte que le niveau 8 de L'API et plus .

voici le code d'utilisation de ce pattern pour vérifier la validation du courriel.

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

assurez-vous qu'après avoir exécuté cette méthode, vous devriez vérifier que si cette méthode retourne true alors vous permettez de sauvegarder le courriel et si cette méthode retourne false alors afficher le message que le courriel est"invalide".

J'espère que vous aurez votre réponse, Remercier.

validez votre format d'adresse courriel. 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();
}

puis-je vous recommander fortement de ne pas essayer de "valider" les adresses e-mail, vous allez juste vous mettre dans beaucoup de travail sans bonne raison.

assurez - vous juste que ce qui est entré ne casse pas votre propre code-par exemple pas d'espaces ou de caractères illégaux qui pourraient causer une Exception.

N'importe quoi d'autre vous causera beaucoup de travail pour un retour minimal...

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

je sais qu'Il est trop tard, je vais donner ma réponse.

j'ai utilisé cette ligne de code pour vérifier la saisie Email format:

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

le problème est, il ne vérifiera pour le FORMAT pas le SPELLING .

quand j'ai entré @gmal.com manquant i ,et @yaho.com manquant un autre o . Il retourne true . Comme il satisfait à la condition de Email Format .

ce que j'ai fait est, j'ai utilisé le code ci-dessus. Puisqu'il donnera / retournera true si le si l'Utilisateur a entré @gmail.com seulement , pas de texte au début.

FORMAT CHECKER

si j'entre cet email il me donnera: true mais l'orthographe est fausse. Dans mon textInputLayout error

EMAIL ADDRESS @yahoo.com , @gmail.com , @outlook.com VÉRIFICATEUR

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

Retour: 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: j'ai essayé d'obtenir le value de EditText et utilisé split sur elle et même StringTokenizer . Les deux me renvoient false .

essayez cette méthode simple qui ne peut pas accepter l'adresse email commençant par les chiffres:

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

essayez ce code.. Sa fonctionne vraiment..

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

vous pouvez écrire une extension Kotlin comme ceci:

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

et appelez ça comme ça:

email.isValidEmail()

Voici 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 correspond-il si

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

exemple de correspondance spéciale

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

, Vous pouvez modifier ce modèle pour votre cas, puis valider par

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

La clé ici est que vous voulez valider l'adresse e-mail. Vous ne voulez pas seulement à vérifier l'exactitude syntaxique, vous voulez vérifier si l'adresse e-mail est réel.

deux raisons évidentes: les utilisateurs réels tapent souvent mal leurs adresses e-mail, et certains utilisateurs peuvent mettre de fausses adresses e-mail. Par conséquent, vous voulez faire un contrôle syntaxique et un contrôle d'existence.

La meilleure façon pour ce faire que j'ai trouvé sur Android est d'utiliser le Cloudmersive validation API gratuit pour cela.

le code ressemble à ceci:

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

Je l'utilise dans toutes mes applications et c'est génial parce que je peux valider les adresses e-mail dans le UX au point d'entrée.

notez que la plupart des expressions régulières ne sont pas valables pour les noms de domaine internationaux (IDN) et les nouveaux domaines de premier niveau comme .mobi or .info (Si vous vérifiez les codes de pays ou .org,.com,.gouv et ainsi de suite).

Une vérification valide doit séparer la partie locale (avant le signe -) et le nom de domaine. Vous devez également prendre en compte la longueur maximale de la partie locale et du domaine (en somme 255 caractères incluant le signe at).

La meilleure approche est de transformer l'adresse dans un format compatible IDN (si nécessaire), valider la partie locale (RFC), vérifier la longueur de l'adresse et la disponibilité du domaine (recherche DNS MX) ou simplement envoyer un e-mail.

la classe Linkify a quelques méthodes d'aide assez utiles qui pourraient être pertinentes, y compris des expressions régulières conçues pour prendre des numéros de téléphone et des adresses e-mail et tels:

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

j'ai utilisé le code suivant.Cette grille fonctionne.J'espère que cela va vous aider.

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

et utiliser la méthode follwing.Ceci retourne true si le courriel est valide.

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

email est votre 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();

    }

pour les amateurs de regex, le meilleur (par exemple compatible avec la RFC 822) modèle de courrier électronique que j'ai jamais trouvé depuis maintenant est le suivant (avant Filtres PHP fournis). Je suppose qu'il est facile de traduire ceci en Java - pour ceux qui jouent avec 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 ;
}

vous pouvez faire n'importe quel type de validation dans android très facilement par l'ovale.fichier jar. OVal est un cadre de validation pragmatique et extensible pour tout type d'objet Java.

suivez ce lien: http://oval.sourceforge.net/userguide.html

vous pouvez descendre d'ici: http://oval.sourceforge.net/userguide.html#download

vous pouvez utiliser la validation en définissant des balises dans les 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));
                }
            }
        }
}

vous pouvez également utiliser

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

si l'email n'est pas valide il lancera un AddressException .

malheureusement Android ne supporte pas jndi-dns , mais juste pour vous donner une idée d'une validation email plus puissante, vous pouvez l'utiliser pour valider le domaine email. Peut-être Qu'un gourou Android pourrait aider et montrer s'il existe des alternatives similaires... Exemple implémentation avec "Java est disponible ici .

EDIT

je viens de réaliser que javax.le courrier ne supporte pas non plus... Mais ce post montre un autour de .

si vous utilisez API 8 ou plus, vous pouvez utiliser la classe Patterns pour valider le courriel. Code échantillon:

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

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

par hasard si vous supportez même un niveau D'API inférieur à 8, Vous pouvez simplement copier le fichier Patterns.java dans votre projet et le référencer. Vous pouvez obtenir le code source de Patterns.java de ce lien

Suivant a été utilisé par moi. Cependant, il contient des caractères supplémentaires que les e-mails normaux, mais c'était une exigence pour moi.

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

réponse à cette question:- exigence de valider une adresse e-mail avec les points donnés

explication -

1. (?!.*?..) "Négatif Lookhead" pour réduire à néant 2 points consécutifs.
2. [A-Za-z0-9.!#\$\%\&\'*+-/\=\?\^_`{\|}\~]+ Atleast un des caractères définis. ("\" est utilisé pour s'échapper).
3. @ Il pourrait y avoir un "@".
4. [A-Za-z0-9]+ puis au moins un caractère défini.
5. [A-Za-z0-9-.] * Zéro ou toute répétition de caractère définie.
6. [A-Za-z0-9]+ Atleast un char après le point.