¿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 de usuario) en Android? org.apache.commons.validator.routines.EmailValidator no parece estar disponible. ¿Hay otras bibliotecas haciendo esto que ya están incluidas en Android o tendré que usar RegExp?

    No use 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án en cosas como “usuario@gmail.com.nospam”, como lo hará org.apache.commons.validator. rutinas.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])+)\]) 

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

    Si desea realizar algunos controles básicos, puede verificar que estén en la forma *@*

    Si tiene alguna validación específica de lógica de negocios, entonces puede realizar eso usando 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 API Nivel 8:

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

    Patrones de fuente visible

    O

    Una solución de 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

    Entonces puede usarlo para validar yourEmailString:

     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

    Entonces puede comstackrlo usted mismo para la compatibilidad con API <8.

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

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

    Estas son las sugerencias de Android Studio:

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

    use android: inputType = “textEmailAddress” como a continuación:

       

    y:

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

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

     Pattern pattern = Pattern.compile(".+@.+\\.[az]+"); String email = "xyz@xyzdomain.com"; Matcher matcher = pattern.matcher(email); boolean matchFound = matcher.matches(); 

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

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

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

    Hay una clase de Patterns en el paquete android.util que 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 desea validar la identificación del correo electrónico.

     public static boolean isValid(String email) { String expression = "^[\\w\\.-]+@([\\w\\-]+\\.)+[AZ]{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 admite API nivel 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, compruebe que si este método devuelve verdadero , permite guardar el correo electrónico y si este método devuelve falso , muestre el mensaje de que el correo electrónico es “Inválido”.

    Espero que tengas tu respuesta, gracias.

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

    Recomiendo encarecidamente que no intente “validar” las direcciones de correo electrónico, sino que obtendrá mucho trabajo sin una buena razón.

    Solo asegúrate de que lo que ingresas no rompa tu propio código, por ejemplo, no hay espacios o caracteres ilegales que puedan causar una excepción.

    Cualquier otra cosa te causará mucho trabajo por un rendimiento mínimo …

      public boolean isValidEmail(String email) { boolean isValidEmail = false; String emailExpression = "^[\\w\\.-]+@([\\w\\-]+\\.)+[AZ]{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; } 

    Sé que es muy tarde, aún daré mi respuesta.

    Utilicé esta línea de código para verificar el formato de Email ingresado:

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

    El problema es que solo comprobará el FORMAT no el SPELLING .

    Cuando entré a @gmal.com i faltaba, y @yaho.com faltaba otra o . Devuelve true . Dado que cumple la condición para el Email Format .

    Lo que hice fue, utilicé el código anterior. Dado que dará / devolverá true si el usuario ingresó @gmail.com SOLAMENTE , sin texto al comienzo.

    FORMATO CHECKER

    comprobar

    Si ingreso este correo electrónico, me dará: true pero la ortografía es incorrecta. En mi textInputLayout error

    Pronunciación incorrecta

    DIRECCIÓN DE CORREO ELECTRÓNICO @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); } 

    REGRESAR: false

    falso

    no especial

    REGRESO: true

    cierto

    XML:

      

    Nota: Intenté obtener el value de EditText y utilicé el split en él e incluso StringTokenizer . Ambos me devuelven false .

    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.+@.+\\.[az]+"; 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; } 

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

    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 alto nivel como .mobi o .info (si busca códigos de país o .org, .com, .gov, etc.).

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

    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 de ayuda 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 y cosas por el estilo:

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

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

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

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

      private boolean validMail(String yourEmailString) { Pattern emailPattern = Pattern.compile(".+@.+\\.[az]+"); 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 la expresión regular, el mejor patrón de correo electrónico (por ejemplo, consistente 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 extensible y pragmático 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 estableciendo tags 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 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 AddressException .

    Lamentablemente, Android no es compatible con jndi-dns , pero solo para darle una idea de una validación de correo electrónico más potente, puede usarlo para validar el dominio de correo electrónico. Tal vez un gurú de Android podría ayudar y mostrar si hay alternativas similares … Una implementación de ejemplo con java “regular” está disponible aquí .

    EDITAR

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

    Si está utilizando API 8 o superior, puede usar la clase Patterns 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 niveles de API inferiores a 8, puede simplemente copiar el archivo Patterns.java en su proyecto y consultarlo. Puede obtener el código fuente de Patterns.java desde este enlace

    Siguiendo fue utilizado por mí. Sin embargo, contiene caracteres adicionales a los correos electrónicos normales, pero este era 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 de esta pregunta: – Requisito para validar una dirección de correo electrónico con puntos determinados

    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] + 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 char después del punto.

    La forma más simple de validación de correo electrónico.

     EditText TF; public Button checkButton; public 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}" + ")+" ); @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); requestWindowFeature(Window.FEATURE_NO_TITLE); setContentView(R.layout.main); TF=(EditText) findViewById(R.id.TF); checkButton=(Button) findViewById(R.id.checkButton); checkButton.setOnClickListener(new OnClickListener() { public void onClick(View v) { String email=TF.getText().toString(); if(checkEmail(email)) Toast.makeText(getApplicationContext(),"Valid Email Addresss", Toast.LENGTH_SHORT).show(); else Toast.makeText(getApplicationContext(),"Invalid Email Addresss", Toast.LENGTH_SHORT).show(); } }); } private boolean checkEmail(String email) { return EMAIL_ADDRESS_PATTERN.matcher(email).matches(); }}