Wie muss ich eine E-Mail-Adresse bestätigen?

Eine weitere Option ist das eingebaute Patterns , das mit API Level 8 beginnt:

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

Patterns 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 der 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

So können Sie es verwenden, um Ihren EmailString zu überprüfen:

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

siehe: 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-Mustervergleicher

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

Dies sind Android Studio-Vorschläge:

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

verwenden Sie 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önnen dazu reguläre Ausdrücke verwenden. Etwas wie das Folgende.

Pattern pattern = Pattern.compile("[email protected]+\\.[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.

Im Paket Android.util gibt es eine Patterns-Klasse, was hier von Vorteil ist. Im Folgenden finden Sie die Methode, die ich immer zum Überprüfen von E-Mails und vielen anderen Dingen verwende

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

Verwenden Sie einen einfachen einzeiligen Code für die E-Mail-Bestätigung

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

verwenden Sie wie ...

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

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

Hier ist der Code, mit dem Sie dieses Muster zur Überprüfung der E-Mail-Gültigkeit verwenden können.

  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 müssen, ob diese E-Mail gespeichert werden soll, wenn diese Methode true zurückgibt. Wenn diese Methode false zurückgibt, wird die Nachricht "Ungültig" angezeigt.

Ich hoffe, Sie erhalten Ihre Antwort... Vielen Dank.

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

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

Und dann nennen wir es so:

email.isValidEmail()

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\\.-][email protected]([\\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;
   }
}

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

    public boolean isValidEmail(String email)
{
    boolean isValidEmail = false;

    String emailExpression = "^[\\w\\.-][email protected]([\\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;
}

Kann ich DRINGEND empfehlen, dass Sie nicht versuchen, E-Mail-Adressen zu "validieren"? Sie werden sich einfach ohne großen Grund mit einer Menge Arbeit beschäftigen.

Stellen Sie nur sicher, dass das Eingegebene Ihren eigenen Code nicht verletzt - z. Keine Leerzeichen oder unzulässigen Zeichen, die eine Ausnahme verursachen könnten.

Alles andere wird nur eine Menge Arbeit für minimale Erträge verursachen ...

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 dem entsprechen, 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

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

Sie können dieses Muster für Ihren Fall ändern und dann mit bestätigen

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

Versuchen Sie diese einfache Methode, die die mit Ziffern beginnende E-Mail-Adresse nicht akzeptieren kann:

boolean checkEmailCorrect(String Email) {
    if(signupEmail.length() == 0) {
        return false;
    }

    String pttn = "^\\[email protected]+\\.[a-z]+";
    Pattern p = Pattern.compile(pttn);
    Matcher m = p.matcher(Email);

    if(m.matches()) {
        return true;
    }

    return false;
}

Wenn Sie API 8 oder höher verwenden, können Sie die sofort verfügbare Klasse Patterns verwenden, um E-Mails zu überprüfen. 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.Java-Datei einfach in Ihr Projekt kopieren und darauf verweisen. Den Quellcode für Patterns.Java erhalten Sie von diesem Link

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

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

Die beste Methode, die ich auf Android gefunden habe, ist die Verwendung der kostenlosen Cloudmersive Validation API für diesen Vorgang.

Der Code sieht so 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, da ich die E-Mail-Adressen in UX zum Zeitpunkt der Eingabe überprüfen kann.

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

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

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

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

Eine gültige Prüfung sollte den lokalen Teil (vor dem Vorzeichen) und den Domänenteil trennen. Sie sollten auch die maximale Länge des lokalen Teils und der Domäne berücksichtigen (in Summe 255 Zeichen einschließlich des at-Zeichens).

Die beste Methode ist, 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 .

e-Mail ist Ihre E-Mail-Adresse.

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

    }

Ich weiß, dass es sehr spät ist, aber ich werde meine Antwort geben.

Ich habe diese Codezeile verwendet, um das eingegebene Email-Format zu überprüfen:

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

Das Problem ist, es wird nur nach der FORMAT und nicht nach der SPELLING gesucht.

Wenn ich @gmal.com fehlt, i und @yaho.com eine andere o ., Wird true zurückgegeben. Da er die Bedingung für Email Format erfüllt.

Was ich getan habe ist, ich habe den Code oben verwendet. Da gibt/true zurückgeben, wenn Wenn der Benutzer @gmail.comNUR eingibt, am Anfang kein Text.

FORMAT CHECKER

Wenn ich diese E-Mail eingebe, bekomme ich: true, aber die Schreibweise ist falsch. Inmy textInputLayout error 

E-MAIL-ADRESSE @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);
}

RÜCKKEHR: 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"/>

Hinweis: Ich habe versucht, die value von EditText abzurufen und habe split und sogar StringTokenizer verwendet. Beide geben false an mich zurück. 

Sie können jede Art von Validierung in Android sehr einfach über die Datei oval.jar durchführen. OVal ist ein pragmatisches und erweiterbares Validierungs-Framework für allgemeine Zwecke für jegliche Art von Java-Objekten.

folge diesem Link: http://oval.sourceforge.net/userguide.html

Sie können dies von hier 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 unterstützt Android nichtjndi-dns , aber um Ihnen eine Vorstellung von einer leistungsfähigeren E-Mail-Validierung zu vermitteln, können Sie damit die E-Mail-Domäne überprüfen. Vielleicht könnte ein Android-Guru helfen und zeigen, ob es ähnliche Alternativen gibt ... Eine Beispielimplementierung mit "regulärem" Java finden Sie hier .

BEARBEITEN

Ich habe gerade erkannt, dass javax.mail auch keine Unterstützung bietet ... Aber dieser Beitrag zeigt eine Workaround .

Ich habe folgenden Code verwendet. Dies funktioniert dankend. Ich hoffe, das wird Ihnen helfen.

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

und verwende folgende Methode. Gibt true zurück, wenn die E-Mail gültig ist.

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

Für Regex-Liebhaber ist das beste E-Mail-Muster (z. B. mit RFC 822 beständig), das ich je gefunden habe, das folgende (vor PHP gelieferte Filter). Ich denke, es ist leicht, 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 ;
}

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

public boolean isValidEmail(String inputString) {
    String  s ="^((?!.*?\.\.)[A-Za-z0-9\.\!\#\$\%\&\'*\+\-\/\=\?\^_`\{\|\}\~][email protected][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 zur Überprüfung einer E-Mail-Adresse mit angegebenen Punkten

Erläuterung-

1. (?!. *? ..) "Negativer Lookhead", um 2 aufeinander folgende Punkte zu negieren.
2. [A-Za-z0-9.! #\$ \%\&\'* + -/\ = \?\^ _ {{| |}\~] + Mindestens ein Zeichen definiert. ("\" wird für das Escaping verwendet).
3. @ Möglicherweise gibt es ein "@".
4. [A-Za-z0-9] + dann mindestens ein definiertes Zeichen.
5. [A-Za-z0-9 -.] * Null oder beliebige Wiederholung des Zeichens.
6. [A-Za-z0-9] + Mindestens ein Zeichen nach dem anderen.