Wie soll ich eine E-Mail-Adresse validieren?

Was ist eine gute Technik zum Überprüfen einer E-Mail-Adresse (z. B. aus einem Benutzereingabefeld) in Android? org.apache.commons.validator.routines.EmailValidator scheint nicht verfügbar zu sein. Gibt es andere Bibliotheken, die dies tun und bereits in Android enthalten sind, oder müsste ich RegExp verwenden?

Verwenden Sie kein Reg-Ex.

Anscheinend ist das Folgende ein reg-ex, das die meisten E-Mail-Adressen, die RFC 2822 entsprechen, korrekt validiert (und bei Dingen wie "user@gmail.com.nospam" ebenso fehlschlägt wie 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])+)\])

Möglicherweise der einfachste Weg, eine E-Mail zu validieren, um einfach eine Bestätigungs-E-Mail an die angegebene Adresse zu senden, und sie springt, dann ist sie nicht gültig.

Wenn Sie einige grundlegende Überprüfungen durchführen möchten, können Sie einfach überprüfen, ob das Formular vorhanden ist *@*

Wenn Sie eine geschäftslogikspezifische Validierung haben, können Sie diese mithilfe eines regulären Ausdrucks durchführen, z. B. muss es sich um ein gmail.com-Konto oder etwas anderes handeln.

Eine weitere Option sind die integrierten Muster, die mit API Level 8 beginnen:

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

Muster sichtbare Quelle

ODER

Einzeilige Lösung von @AdamvandenHoven:

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

Das nächste Muster wird in K-9-Mail verwendet:

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

Sie können die Funktion verwenden

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

Seit API 8 (android 2.2) gibt es ein Muster: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

Sie können es also verwenden, um Ihren E-Mail-String zu validieren:

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

Gibt true zurück, wenn die E-Mail gültig ist

UPD: Dieser Musterquellcode lautet:

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

Weitere Informationen finden Sie unter : http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/util/Patterns.java

Sie können es also selbst erstellen, um die Kompatibilität mit API <8 zu gewährleisten.

Wir haben jetzt einen einfachen E-Mail-Mustervergleich

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

Verwenden Sie einen einfachen einzeiligen Code für die E-Mail-Validierung

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

benutze wie ...

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

Dies sind Vorschläge für Android Studio:

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

Sie können dazu reguläre Ausdrücke verwenden. So etwas wie das Folgende.

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

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Hinweis: Überprüfen Sie den oben angegebenen regulären Ausdruck und verwenden Sie ihn nicht so, wie er ist.

benutze android: inputType = "textEmailAddress" wie folgt:

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

und:

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

Sie könnten eine Kotlin-Erweiterung wie folgt schreiben:

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

Und dann nenne es so:

email.isValidEmail()

Es gibt eine PatternsKlasse im Paket, android.utildie hier von Vorteil ist. Unten ist die Methode, die ich immer zum Validieren von E-Mails und vielen anderen Dingen verwende

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

Rufen Sie diese Methode auf, bei der Sie die E-Mail-ID überprüfen möchten.

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

Für eine E-Mail-Validierung bietet Android ein InBuilt-Muster an. Es unterstützt jedoch nur API-Level 8 und höher .

Hier ist der Code zur Verwendung dieses Musters zur Überprüfung der E-Mail-Validierung.

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

Stellen Sie sicher, dass Sie nach dem Ausführen dieser Methode überprüfen sollten, ob Sie das Speichern von E-Mails zulassen , wenn diese Methode true zurückgibt. Wenn diese Methode false zurückgibt, wird die Meldung angezeigt, dass die E-Mail "ungültig" ist.

Hoffe du bekommst deine Antwort, Danke.

Kann ich DRINGEND empfehlen, dass Sie nicht versuchen, E-Mail-Adressen zu "validieren"? Sie werden sich einfach ohne guten Grund in eine Menge Arbeit stürzen.

Stellen Sie nur sicher, dass die eingegebene Datei Ihren eigenen Code nicht beschädigt - z. B. keine Leerzeichen oder unzulässigen Zeichen, die eine Ausnahme verursachen könnten.

Alles andere wird Ihnen nur viel Arbeit für minimale Rendite verursachen ...

Überprüfen Sie Ihr E-Mail-Adressformat. 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();
}

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

Wenn Sie API 8 oder höher verwenden, können Sie die sofort verfügbare PatternsKlasse zum Überprüfen von E-Mails verwenden. Beispielcode:

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

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

Wenn Sie sogar API-Level unter 8 unterstützen, können Sie die Patterns.javaDatei zufällig einfach in Ihr Projekt kopieren und darauf verweisen. Den Quellcode für können Sie Patterns.javaüber diesen Link erhalten

Hier ist 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 wird es passen, wenn

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

Beispiel eine spezielle Match-E-Mail

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

Sie können dieses Muster für Ihren Fall ändern und dann durch validieren

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

Versuchen Sie diese einfache Methode, bei der die mit Ziffern beginnende E-Mail-Adresse nicht akzeptiert werden kann:

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

Versuchen Sie diesen Code .. Es funktioniert wirklich ..

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

Folgendes wurde von mir verwendet. Es enthält jedoch zusätzliche Zeichen als normale E-Mails, aber dies war eine Voraussetzung für mich.

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

Antwort auf diese Frage: - Anforderung, eine E-Mail-Adresse mit bestimmten Punkten zu validieren

Erläuterung-

1. (?!. *? ..) "Negative Lookhead", um 2 aufeinanderfolgende Punkte zu negieren.
2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + Mindestens ein Zeichen definiert. ("\" wird zum Entkommen verwendet).
3. @ Möglicherweise gibt es ein "@".
4. [A-Za-z0-9] + dann mindestens ein Zeichen definiert.
5. [A-Za-z0-9 -.] * Null oder eine beliebige Wiederholung des definierten Zeichens.
6. [A-Za-z0-9] + Mindestens ein Zeichen nach Punkt.

Der Schlüssel hier ist, dass Sie die E-Mail-Adresse vollständig validieren möchten. Sie möchten nicht nur die syntaktische Korrektheit überprüfen, sondern auch überprüfen, ob die E-Mail-Adresse echt ist.

Zwei offensichtliche Gründe: Echte Benutzer geben ihre E-Mail-Adressen häufig falsch ein, und einige Benutzer geben möglicherweise falsche E-Mail-Adressen ein. Daher möchten Sie eine syntaktische Prüfung und eine Existenzprüfung durchführen.

Der beste Weg, dies zu tun, den ich auf Android gefunden habe, ist die Verwendung der kostenlosen Cloudmersive Validation API .

Der Code sieht folgendermaßen aus:

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

Ich verwende dies in allen meinen Apps und es ist großartig, weil ich die E-Mail-Adressen in der UX zum Zeitpunkt der Eingabe überprüfen kann.

Einfachste Kotlin-Lösung mit Erweiterungsfunktionen:

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

und dann können Sie wie folgt validieren:

"testemail6589@gmail.com".isEmailValid()

Beachten Sie, dass die meisten regulären Ausdrücke nicht für internationale Domainnamen (IDN) und neue Top-Level-Domains wie .mobi oder .info gültig sind (wenn Sie nach Ländercodes oder .org, .com, .gov usw. suchen).

Eine gültige Prüfung sollte den lokalen Teil (vor dem At-Sign) und den Domain-Teil trennen. Sie sollten auch die maximale Länge des lokalen Teils und der Domäne berücksichtigen (insgesamt 255 Zeichen einschließlich des At-Signs).

Der beste Ansatz besteht darin, die Adresse in ein IDN-kompatibles Format umzuwandeln (falls erforderlich), den lokalen Teil (RFC) zu validieren, die Länge der Adresse und die Verfügbarkeit der Domäne zu überprüfen (DNS MX-Suche) oder einfach eine E-Mail zu senden .

Die Linkify-Klasse verfügt über einige nützliche Hilfsmethoden, die möglicherweise relevant sind, einschließlich regulärer Ausdrücke zum Abrufen von Telefonnummern und E-Mail-Adressen und dergleichen:

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

Ich habe folgenden Code verwendet. Dies funktioniert Gitter. Ich hoffe, dies wird Ihnen helfen.

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

und verwenden Sie die folgende Methode. Dies gibt true zurück, wenn die E-Mail gültig ist.

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

E-Mail ist Ihre E-Mail-ist.

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

    }

Für Regex-Liebhaber ist das beste (z. B. im Einklang mit RFC 822) E-Mail-Muster, das ich seitdem gefunden habe, das folgende (bevor PHP Filter bereitstellte). Ich denke, es ist einfach, dies in Java zu übersetzen - für diejenigen, die mit API <8 spielen:

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

Sie können jede Art von Validierung in Android sehr einfach mit der Datei oval.jar durchführen. OVal ist ein pragmatisches und erweiterbares Allzweck-Validierungsframework für jede Art von Java-Objekten.

Folgen Sie diesem Link: http://oval.sourceforge.net/userguide.html

Sie können dies von hier aus herunterladen: http://oval.sourceforge.net/userguide.html#download

Sie können die Validierung verwenden, indem Sie Tags in Variablen setzen

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

Sie könnten auch verwenden

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

Wenn die E-Mail nicht gültig ist, wird eine AddressException ausgelöst .

Leider Android unterstützt keine jndi-dns , aber nur Sie von einem leistungsstärkeren E - Mail - Validierung eine Idee zu geben, können Sie es verwenden , um die E - Mail - Domäne zu validieren. Vielleicht könnte ein Android-Guru helfen und zeigen, ob es ähnliche Alternativen gibt ... Eine Beispielimplementierung mit "normalem" Java finden Sie hier .

BEARBEITEN

Ich habe gerade festgestellt, dass javax.mail auch nicht unterstützt wird ... Aber dieser Beitrag zeigt eine Problemumgehung .