Wie soll ich eine E-Mail-Adresse validieren?

320

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?

znq
quelle
Bitte verweist auf dieses, möge es Ihnen helfen: stackoverflow.com/questions/12947620/…
Hiren Patel
1
@ user2757064 Nun, diese Frage sollte der anderen Frage helfen, die Sie verlinkt haben. Diese Frage wurde 3 Jahre später gestellt. :)
Sufian

Antworten:

48

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

Tal
quelle
5
Ich weiß, dass diese Antwort ungefähr zwei Jahre alt ist, aber wenn ich diesen Regex mit regexr.com versuche, wird er validiert [email protected]und noch länger als .museum. Vermisse ich etwas Ich möchte keinen meiner Benutzer blockieren, indem ich seine gültige E-Mail-Adresse nicht überprüfe, aber dies scheint für alles zu funktionieren, was mir einfällt.
Bob Vork
@ Bob validieren E-Mail-Adresse auf dem Server .. überprüfen Sie foursquare App es tut das gleiche
Harsha MV
107
Ich bin etwas verwirrt, warum Sie diese Antwort mit "Verwenden Sie kein Reg-Ex" beginnen und dann fortfahren, ein Reg-Ex bereitzustellen.
Howettl
7
Bitte lesen Sie weiter. Eine bessere Lösung ist unten, bei der kein regulärer Ausdruck verwendet wird.
Loeschg
1
@Glen. Würde dies für das Android- Muster gelten? EMAIL_ADDRESS ? developer.android.com/reference/android/util/…
zulkarnain shah
1036

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();
}
Mindriot
quelle
30
1, aber ich ziehe es ersetzen die (target == null)mit TextUtils.isEmpty(target):)
Houcine
35
Antworten wie diese sind der Grund, warum ich es nicht mag, wenn akzeptierte Antworten oben angezeigt werden, anstatt Antworten mit den meisten Stimmen.
Jeshurun
11
Wäre es auch nicht sinnvoller (in Bezug auf die Lesbarkeit), dies einfach in einer Zeile zu kombinieren: return! TextUtils.isEmpty (Ziel) && android.util.Patterns.EMAIL_ADDRESS.matcher (Ziel) .matches ();
Adam van den Hoven
1
@Houcine, true, aber die obige Methode gibt boolean zurück, sodass wir diese Informationen nicht haben, wenn sie false sind. Auf jeden Fall kann man die Benutzeroberfläche innerhalb der Funktion anstoßen oder aktualisieren (muss im UI-Thread ausgeführt werden). Für diejenigen wie mich, die eine programmgesteuert und ohne Benutzerinteraktion erhaltene E-Mail validieren, können wir einfach bei '== null' bleiben und in den meisten Fällen möglicherweise ein paar Taktzyklen speichern.
AJ
2
Achtung. Dieser Matcher akzeptiert [email protected]als gültige E-Mail
Joaquin Iurchuk
101

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();
}
Andrei Buneyeu
quelle
74
Warum nicht verwenden android.util.Patterns.EMAIL_ADDRESS?
Sergey Metlov
9
weil es nur seit API Level 8 existiert
Andrei Buneyeu
Dies hat mir sehr geholfen, danke und +1 für die einfache Antwort .. :)
Deepthi
Zu Ihrer Information: Innerhalb von Zeichenklassen sind die Metazeichen viel weniger und der Bindestrich wird automatisch maskiert, wenn er an einen Rand gesetzt wird. Sie können die erste Klasse vereinfachen [a-zA-Z0-9+._%-]und die anderen zu[a-zA-Z0-9-]
Robin
Dies ist nur true zurück , wenn die E - Mail - Syntax ist die gleiche wie E - Mail funktioniert, habe ich versucht zu entfernen iaus @gmail.comes wird true zurück. Gleiches gilt für `@yaho.com.
RoCk RoCk
70

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.

Lauten
quelle
45

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();
    }
Salman Nazir
quelle
19

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();
}
Pankaj Talaviya
quelle
15

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();
}
Matteo
quelle
1
null check email == nullist redandunt als TextUtils es innen prüft
Volodymyr
@VolodymyrKhodonovych Sie haben Recht, aber die Nullprüfung wird in einem ODER-Status durchgeführt. Andernfalls kann es zu einer NPE kommen, wenn E-Mails an die matcher () -Methode übergeben werden.
Matteo
11

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

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

String email = "[email protected]";

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.

Mudassir
quelle
3
Dies schlägt bei der folgenden gültigen E-Mail-Adresse fehl : "Example Guy" <[email protected]>. Sie können E-Mails zwar technisch mit einem regulären Ausdruck validieren , dies ist jedoch etwas absurd.
Cory Petosky
1
Das ist aber nicht nur eine E-Mail-Adresse.
Brill Pappin
11

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();
      }
Victor Odiah
quelle
11

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()
Danilo Lemes
quelle
Wer ist "Patterns"?
Jemshit Iskenderov
android.util.Patterns
Danilo Lemes
9

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();
}
Jimit Patel
quelle
5

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;
   }
}
Sumit Sharma
quelle
5

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.

AMI CHARADAVA
quelle
4

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


quelle
3
Bei der Arbeit mit Abonnements und Zahlungen ist dies kaum ein nützlicher Rat. Wenn jemand sein Passwort vergisst, müssen wir eine Möglichkeit haben, sein Passwort sicher zurückzusetzen, damit er den von ihm bezahlten Dienst weiterhin nutzen kann. Daher ist es manchmal am besten, dass wir sicherstellen, dass sie eine gültige E-Mail-Adresse für sich selbst eingeben.
Dean Wild
1
Nur um klar zu sein, was ich gesagt habe - wenn jemand die Absicht hat, eine falsche / falsche Adresse einzugeben - wird ihn keine Validierung aufhalten. Das Überprüfen auf dumme Fehler wie Leerzeichen und kein '@' usw. ist in Ordnung - alles andere zu überprüfen ist in Ordnung gut in 'abnehmende Renditen' ...
3
Die einzige Möglichkeit, eine gefälschte E-Mail zu identifizieren, besteht darin, eine E-Mail an diese E-Mail-ID zu senden und zu überprüfen, ob Sie einen nicht zugestellten Bericht erhalten ...
Sreekanth Karumanaghat
John, viele Benutzer haben nicht die Absicht , eine falsche / falsche Adresse einzugeben, können diese aber versehentlich falsch eingeben. Eine einfache Überprüfung durchzuführen kann daher sehr nützlich sein und ist, wie in der Antwort von mindriot gezeigt, nicht viel Arbeit. Nach meiner Erfahrung geben die meisten Leute ihre E-Mail-Adressen korrekt ein, und die wenigen ungültigen E-Mails scheinen meistens auf unschuldige Tippfehler zurückzuführen zu sein.
Ban-Geoengineering
Wenn es wichtig ist, dass die E-Mail des Benutzers funktioniert, senden Sie eine Bestätigungs-E-Mail. Alles andere ist Unsinn.
Der unglaubliche
4

Überprüfen Sie Ihr E-Mail-Adressformat. [email protected]

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();
}
Virag Brahme
quelle
3
    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;
}
Atif Mahmood
quelle
2

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

Mahendra Liya
quelle
2

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()
}
Phan Van Linh
quelle
1

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;
}
Arman
quelle
1

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;
            }
Jenifer
quelle
1

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.
Vipin Sharma
quelle
1

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

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.

5377037
quelle
1

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:

"[email protected]".isEmailValid()
Gulzar Bhat
quelle
0

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 .

Thorsten
quelle
0

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

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

    }
Kyogs
quelle
0

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 ;
}
hornetbzz
quelle
0

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));
                }
            }
        }
}
Muhammad Aamir Ali
quelle
0

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 .

Bob Rivers
quelle