¿Cómo debo validar una dirección de correo electrónico?

¿Cuál es una buena técnica para validar una dirección de correo electrónico (por ejemplo, desde un campo de entrada del usuario) en Android? org.apache.commons.validator.routines.EmailValidator no parece estar disponible. ¿Hay alguna otra biblioteca haciendo esto que ya esté incluida en Android o tendría que usar RegExp?

No uses un reg-ex.

Aparentemente, el siguiente es un registro que valida correctamente la mayoría de las direcciones de correo electrónico que cumplen con RFC 2822 , (y aún fallará en cosas como "user@gmail.com.nospam", como lo hará org.apache.commons.validator. rutinas.Validator de correo electrónico)

(?:[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])+)\])

Posiblemente, la forma más fácil de validar un correo electrónico es simplemente enviar un correo electrónico de confirmación a la dirección proporcionada y que rebote y luego no sea válido.

Si desea realizar algunas comprobaciones básicas, puede comprobar que está en el formulario *@*

Si tiene alguna validación específica de lógica empresarial, puede realizarla utilizando una expresión regular, por ejemplo, debe ser una cuenta de gmail.com o algo así.

Otra opción son los patrones integrados que comienzan con el nivel 8 de API:

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

Fuente visible de patrones

O

Solución de una línea de @AdamvandenHoven:

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

El siguiente patrón se usa en el correo K-9:

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

Puedes usar la función

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

Desde API 8 (android 2.2) hay un patrón: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

Para que pueda usarlo para validar suEmailString:

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

devuelve verdadero si el correo electrónico es válido

UPD: este código fuente de patrón es:

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

consulte: http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/util/Patterns.java

Para que pueda compilarlo usted mismo para compatibilidad con API <8.

Tenemos un simple patrón de correspondencia de correo electrónico ahora

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

Use un código simple de una línea para la validación de correo electrónico

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

usar como ...

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

Estas son sugerencias de Android Studio:

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

Puede usar expresiones regulares para hacerlo. Algo como lo siguiente.

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

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Nota: Verifique la expresión regular dada anteriormente, no la use como está.

use android: inputType = "textEmailAddress" como se muestra a continuación:

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

y:

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

Podrías escribir una extensión de Kotlin como esta:

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

Y luego llámalo así:

email.isValidEmail()

Hay una Patternsclase en el paquete android.utilque es beneficiosa aquí. A continuación se muestra el método que siempre uso para validar el correo electrónico y muchas otras cosas.

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

Llame a este método donde desee validar la identificación de correo electrónico.

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

Para una validación de correo electrónico, Android proporciona un patrón InBuilt. Pero solo es compatible con el nivel de API 8 y superior .

Aquí hay un código para usar ese patrón para verificar la validación del correo electrónico.

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

Asegúrese de que después de ejecutar este método, debe verificar que si este método devuelve verdadero, entonces permite guardar el correo electrónico y si este método devuelve falso , muestre el mensaje de que el correo electrónico es "No válido".

Espero que obtengas tu respuesta, gracias.

¿Puedo recomendar ENCARECIDAMENTE que no intentes 'validar' las direcciones de correo electrónico, solo te meterás en un montón de trabajo sin una buena razón?

Solo asegúrese de que lo que ingrese no rompa su propio código, por ejemplo, sin espacios o caracteres ilegales que puedan causar una excepción.

Cualquier otra cosa solo le causará mucho trabajo por un retorno mínimo ...

Valide su formato de dirección de correo electrónico. 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;
}

Si está utilizando API 8 o superior, puede usar la Patternsclase fácilmente disponible para validar el correo electrónico. Código de muestra:

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

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

Por casualidad, si incluso admite un nivel de API inferior a 8, simplemente puede copiar el Patterns.javaarchivo en su proyecto y hacer referencia a él. Puede obtener el código fuente Patterns.javade este enlace

Aquí está 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 lo igualará 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, -)

Ejemplo de correo electrónico de un partido especial

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

Puede modificar este patrón para su caso y luego validarlo

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

Pruebe este método simple que no puede aceptar la dirección de correo electrónico que comienza con dígitos:

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

Prueba este código ... Realmente funciona ...

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

Lo siguiente fue usado por mí. Sin embargo, contiene caracteres adicionales que los correos electrónicos normales, pero esto fue un requisito para mí.

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

Respuesta a esta pregunta: - Requisito para validar una dirección de correo electrónico con puntos dados

Explicación-

1. (?!. *? ..) "Negative Lookhead" para negar 2 puntos consecutivos.
2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + Al menos un carácter definido. ("\" se usa para escapar).
3. @ Puede haber una "@".
4. [A-Za-z0-9] + luego al menos un carácter definido.
5. [A-Za-z0-9 -.] * Cero o cualquier repetición de carácter definido.
6. [A-Za-z0-9] + Al menos un personaje después del punto.

La clave aquí es que desea validar completamente la dirección de correo electrónico. No solo desea verificar si la corrección sintáctica es correcta, sino verificar si la dirección de correo electrónico es real.

Dos razones obvias: los usuarios reales a menudo escriben mal sus direcciones de correo electrónico y algunos usuarios pueden ingresar direcciones de correo electrónico falsas. Por lo tanto, desea hacer una verificación sintáctica y una verificación de existencia.

La mejor manera de hacer esto que he encontrado en Android es usar la API gratuita de validación de Cloudmersive para esto.

El código se ve así:

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

Estoy usando esto en todas mis aplicaciones y es genial porque puedo validar las direcciones de correo electrónico en la UX en el punto de entrada.

La solución más simple de Kotlin usando funciones de extensión:

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

y luego puedes validar así:

"testemail6589@gmail.com".isEmailValid()

Tenga en cuenta que la mayoría de las expresiones regulares no son válidas para nombres de dominio internacionales (IDN) y nuevos dominios de nivel superior como .mobi o .info (si verifica los códigos de país o .org, .com, .gov, etc.).

Una verificación válida debe separar la parte local (antes del signo de at) y la parte del dominio. También debe considerar la longitud máxima de la parte local y el dominio (en suma 255 caracteres, incluido el signo de at).

El mejor enfoque es transformar la dirección en un formato compatible con IDN (si es necesario), validar la parte local (RFC), verificar la longitud de la dirección y verificar la disponibilidad del dominio (búsqueda DNS MX) o simplemente enviar un correo electrónico .

La clase Linkify tiene algunos métodos auxiliares bastante útiles que pueden ser relevantes, incluidas las expresiones regulares diseñadas para recoger números de teléfono y direcciones de correo electrónico, entre otras:

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

He usado el siguiente código. Esto funciona bien. Espero que esto te ayude.

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

y utilice el siguiente método. Esto devuelve verdadero si el correo electrónico es válido.

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

El correo electrónico es su correo electrónico.

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

    }

Para los amantes de las expresiones regulares, el mejor patrón de correo electrónico (por ejemplo, compatible con RFC 822) que he encontrado desde ahora es el siguiente (antes de los filtros suministrados por PHP). Supongo que es fácil traducir esto a Java, para aquellos que juegan con 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 ;
}

Puede hacer cualquier tipo de validación en Android muy fácilmente mediante el archivo oval.jar. OVal es un marco de validación de propósito general pragmático y extensible para cualquier tipo de objetos Java.

siga este enlace: http://oval.sourceforge.net/userguide.html

Puede descargar esto desde aquí: http://oval.sourceforge.net/userguide.html#download

Puede usar la validación configurando etiquetas en 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));
                }
            }
        }
}

También podrías usar

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

Si el correo electrónico no es válido, arrojará una excepción de dirección .

Desafortunadamente, Android no admite jndi-dns , pero solo para darle una idea de una validación de correo electrónico más potente, puede usarla para validar el dominio de correo electrónico. Tal vez un gurú de Android podría ayudar y mostrar si hay alternativas similares ... Un ejemplo de implementación con Java "regular" está disponible aquí .

EDITAR

Me acabo de dar cuenta de que javax.mail tampoco es compatible ... Pero esta publicación muestra una solución alternativa .