Como devo validar um endereço de email?

320

Qual é uma boa técnica para validar um endereço de e-mail (por exemplo, de um campo de entrada do usuário) no Android? org.apache.commons.validator.routines.EmailValidator não parece estar disponível. Existem outras bibliotecas que já estão incluídas no Android ou eu precisaria usar o RegExp?

znq
fonte
por favor se refere este, pode ele vai ajudar você: stackoverflow.com/questions/12947620/...
Hiren Patel
1
@ user2757064 bem, esta pergunta deve ajudar a outra pergunta que você vinculou. Essa pergunta foi feita 3 anos depois disso. :)
Sufian

Respostas:

48

Não use um reg-ex.

Aparentemente, o seguinte é um reg-ex que valida corretamente a maioria dos endereços de e-mail em conformidade com a RFC 2822 (e ainda falhará em coisas como "[email protected]", assim como 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])+)\])

Possivelmente, a maneira mais fácil de validar um e-mail, basta enviar um e-mail de confirmação para o endereço fornecido e ele salta e, em seguida, não é válido.

Se você deseja realizar algumas verificações básicas, basta verificar se está no formato *@*

Se você tiver alguma validação específica da lógica de negócios, poderá executar isso usando uma regex, por exemplo, deve ser uma conta gmail.com ou algo assim.

Glen
fonte
5
Eu sei que essa resposta tem cerca de dois anos, mas quando tento esse regex usando o regexr.com, ele valida [email protected]e ainda mais arquivos como o .museum. Estou esquecendo de algo? Não quero bloquear nenhum dos meus usuários por não validar seu endereço de email válido, mas isso parece estar funcionando para tudo o que posso pensar.
Bob Vork
@Bob validar o endereço de e-mail no servidor .. verificar aplicativo Foursquare ele faz o mesmo
Harsha MV
107
Estou um pouco confuso por que você inicia esta resposta com "Não use um reg-ex" e depois prossegue para fornecer um reg-ex.
howettl
7
Por favor, continue lendo. Abaixo está uma solução melhor, que não usa regex.
loeschg
1
@Glen. Isso seria válido para o padrão do Android . EMAIL_ADDRESS ? developer.android.com/reference/android/util/…
zulkarnain shah
1036

Outra opção é a criação de padrões, começando com o nível 8 da API:

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

Origem visível dos padrões

OU

Solução de uma linha de @AdamvandenHoven:

public final static boolean isValidEmail(CharSequence target) {
  return !TextUtils.isEmpty(target) && android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}
mindriot
fonte
30
+1, mas eu prefiro substituir o (target == null)com TextUtils.isEmpty(target):) #
Houcine
36
Respostas como estas são por que não gosto de respostas aceitas sendo mostradas na parte superior, em vez de respostas com a maioria dos votos.
precisa saber é o seguinte
11
Também não faria mais sentido (em termos de legibilidade) simplesmente combinar isso em uma linha: return! TextUtils.isEmpty (target) && android.util.Patterns.EMAIL_ADDRESS.matcher (target) .matches ();
Adam van den Hoven
1
@Houcine, true, mas o método acima retorna booleano, para que não tenhamos essas informações quando forem falsas. De qualquer forma, é possível brindar ou atualizar a interface do usuário de dentro da função (deve ser executado no thread da interface do usuário). Para pessoas como eu, que estão validando um e-mail obtido de forma programática e sem nenhuma interação do usuário, podemos simplesmente usar '== null' e talvez salvar alguns ciclos de clock na maioria dos casos.
AJ
2
Seja cuidadoso. Este jogador aceita [email protected]como um email válido
Joaquin Iurchuk 09/02
101

O próximo padrão é usado no correio 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}" +
          ")+"
      );

Você pode usar a função

private boolean checkEmail(String email) {
        return EMAIL_ADDRESS_PATTERN.matcher(email).matches();
}
Andrei Buneyeu
fonte
74
Por que não usar android.util.Patterns.EMAIL_ADDRESS?
Sergey Metlov 18/03/2012
9
fazer com que ele existe desde API Nível 8 apenas
Andrei Buneyeu
Isso me ajudou muito obrigado e um para a resposta simples .. :)
Deepthi
FYI: classes de personagens dentro dos metacaracteres muito menos e o hífen é automaticamente escapou quando colocado numa fronteira, você pode simplificar a primeira classe a [a-zA-Z0-9+._%-]e os outros[a-zA-Z0-9-]
Robin
Isso só retornar true se a sintaxe de e-mail é o mesmo que e-mail faz, eu tentei remover ia partir de @gmail.comele retornará verdadeiro. O mesmo em `@yaho.com.
RoCk RoCk
70

Desde a API 8 (Android 2.2), existe um padrão: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

Então você pode usá-lo para validar sua E-mailString:

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

retorna true se o email é válido

UPD: Este código-fonte padrão é:

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

Assim, você pode criar você mesmo para compatibilidade com a API <8.

Luten
fonte
45

Agora temos um simples comparador de padrões de e-mail

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

Use o código de uma linha simples para validação de email

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

use como ...

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

Estas são as sugestões do Android Studio:

public static boolean isEmailValid(String email) {
    return !(email == null || TextUtils.isEmpty(email)) && android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
}
Matteo
fonte
1
A verificação nula email == nullé redandunt conforme o TextUtils a verifica por dentro
Volodymyr
@VolodymyrKhodonovych você está certo, mas a verificação nula é feita no estado OR, caso contrário, isso pode levar a um NPE ao passar o email para o método matcher ().
Matteo
11

Você pode usar expressão regular para fazer isso. Algo como o seguinte.

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

String email = "[email protected]";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Nota: Verifique a expressão regular dada acima, não a use como ela é.

Mudassir
fonte
3
Esta falha no seguinte endereço de email válido: "Example Guy" <[email protected]>. Embora você possa validar tecnicamente o email com uma regex , é um pouco absurdo fazê-lo.
Cory Petosky
1
Isso não é apenas um endereço de e-mail.
Brill Pappin
11

use android: inputType = "textEmailAddress" como abaixo:

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

e:

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

Você pode escrever uma extensão Kotlin assim:

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

E então chame assim:

email.isValidEmail()
Danilo Lemes
fonte
quem é "padrões"?
Jemshit Iskenderov
android.util.Patterns
Danilo Lemes
9

Há uma Patternsclasse no pacote android.utilque é benéfica aqui. Abaixo está o método que eu sempre uso para validar e-mails e muitos outros itens

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

Ligue para este método onde você deseja validar o ID do email.

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
fonte
5

Para uma validação Email android fornecer algum padrão embutido .Mas ele só apoiar nível API 8 e acima .

Aqui está o código para usar esse padrão para verificar a validação de email.

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

Certifique-se de que, após executar este método, verifique se, se esse método retornar true , você poderá salvar o email e se esse método retornará false , exibindo a mensagem de que o email é "Inválido".

Espero que você obtenha sua resposta, obrigado.

AMI CHARADAVA
fonte
4

Posso enfaticamente recomendar que você não tente 'validar' os endereços de e-mail; você se envolverá em muito trabalho sem uma boa razão.

Apenas verifique se o que foi digitado não quebrará seu próprio código - por exemplo, não há espaços ou caracteres ilegais que possam causar uma exceção.

Qualquer outra coisa apenas causará muito trabalho para o retorno mínimo ...


fonte
3
Ao trabalhar com assinaturas e pagamentos, esse não é um conselho útil. Se alguém esquecer sua senha, é necessário redefinir sua senha com segurança para continuar usando o serviço pelo qual pagou. Portanto, às vezes é melhor garantir que eles estejam inserindo um endereço de email válido por eles mesmos.
Dean selvagem
1
Só para esclarecer o que eu disse - se alguém pretende digitar um endereço falso / errado - nenhuma validação irá impedi-los. Verificar erros bobos como espaços e nenhum '@' etc. é bom - verificar qualquer outra coisa é Bem-
3
A única maneira de identificar um falso e-mail é através do envio de um e-mail para que id e-mail e verifique se u receber um relatório de não entregue ...
Sreekanth Karumanaghat
John, muitos usuários não pretendem inserir um endereço falso / errado, mas podem inseri-lo incorretamente por acidente. Portanto, executar uma verificação simples pode ser muito útil e, como mostra a resposta da mindriot, não é muito trabalhoso. De acordo com minha experiência, a maioria das pessoas insere seus endereços de e-mail corretamente, e os poucos e-mails inválidos geralmente parecem estar relacionados a erros de digitação inocentes.
ban-geoengineering
Se for importante que o email do usuário funcione, você envia um email de confirmação. Tudo o resto é um absurdo.
O incrível Jan
4

Valide seu formato de endereço de email. [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
fonte
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
fonte
2

Se você estiver usando a API 8 ou superior, poderá usar a Patternsclasse prontamente disponível para validar o email. Código de amostra:

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

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

Por acaso, se você estiver suportando um nível de API menor que 8, poderá simplesmente copiar o Patterns.javaarquivo no seu projeto e referenciá-lo. Você pode obter o código fonte Patterns.javade este link

Mahendra Liya
fonte
2

Aqui 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 combinará se

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

Exemplo de algum email de correspondência especial

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

Você pode modificar esse padrão para o seu caso e validar

fun isValidEmail(email: String): Boolean {
    return Patterns.EMAIL_ADDRESS.matcher(email).matches()
}
Phan Van Linh
fonte
1

Experimente este método simples que não pode aceitar o endereço de e-mail começando com 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;
}
Arman
fonte
1

Experimente este código .. Realmente funciona ..

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

A seguir foi usado por mim. No entanto, ele contém caracteres extras que os e-mails normais, mas isso era um requisito para mim.

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

Resposta a esta pergunta: - Requisito para validar um endereço de e-mail com determinados pontos

Explicação-

  1. (?!. *? ..) "Cabeça negativa" para negar 2 pontos consecutivos.
  2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + Pelo menos um caractere definido. ("\" é usado para escapar).
  3. @ Pode haver um "@".
  4. [A-Za-z0-9] + então, pelo menos, um caractere definido.
  5. [A-Za-z0-9 -.] * Zero ou qualquer repetição de caractere definida.
  6. [A-Za-z0-9] + Pelo menos um caractere após ponto.
Vipin Sharma
fonte
1

A chave aqui é que você deseja validar completamente o endereço de email. Você não deseja apenas verificar a exatidão sintática, mas também se o endereço de email é real.

Duas razões óbvias: usuários reais geralmente digitam incorretamente seus endereços de e-mail e alguns usuários podem inserir endereços de email falsos. Portanto, você deseja fazer uma verificação sintática e uma verificação de existência.

A melhor maneira de fazer isso que encontrei no Android é usar a API de validação Cloudmersive gratuita para isso.

O código fica assim:

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

Estou usando isso em todos os meus aplicativos e é ótimo porque posso validar os endereços de email no UX no ponto de entrada.

5377037
fonte
1

Solução Kotlin mais simples usando funções de extensão:

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

e então você pode validar assim:

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

Observe que a maioria das expressões regulares não é válida para nomes de domínio internacionais (IDN) e novos domínios de nível superior, como .mobi ou .info (se você procurar códigos de países ou .org, .com, .gov e assim por diante).

Uma verificação válida deve separar a parte local (antes da arroba) e a parte do domínio. Você também deve considerar o comprimento máximo da parte e do domínio local (na soma 255 caracteres, incluindo o sinal de arroba).

A melhor abordagem é transformar o endereço em um formato compatível com IDN (se necessário), validar a parte local (RFC), verificar o tamanho do endereço e verificar a disponibilidade do domínio (pesquisa DNS MX) ou simplesmente enviar um email .

Thorsten
fonte
0

Eu usei o código follwing. Isso funciona grate.I espero que isso irá ajudá-lo.

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

e use o método follwing. Isso retornará true se o email for válido.

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

email é o seu email-is.

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
fonte
0

Para os amantes de regex, o melhor padrão de email (por exemplo, consistente com o RFC 822) que eu já encontrei desde agora é o seguinte (antes dos filtros fornecidos pelo PHP). Eu acho que é fácil traduzir isso para Java - para quem joga com a 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 ;
}
hornetbzz
fonte
0

Você pode fazer qualquer tipo de validação no Android com muita facilidade pelo arquivo oval.jar. OVal é uma estrutura de validação de uso geral pragmática e extensível para qualquer tipo de objeto Java.

Siga este link: http://oval.sourceforge.net/userguide.html

Você pode fazer o downlaod aqui: http://oval.sourceforge.net/userguide.html#download

Você pode usar a validação definindo tags nas variáveis

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
fonte
0

Você também pode usar

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

Se o email não for válido, ele lançará uma AddressException .

Infelizmente, o Android não suporta jndi-dns , mas apenas para lhe dar uma idéia de uma validação de email mais poderosa, você pode usá-lo para validar o domínio do email. Talvez um guru do Android possa ajudar e mostrar se existem alternativas semelhantes ... Um exemplo de implementação com java "regular" está disponível aqui .

EDITAR

Acabei de perceber que o javax.mail também não é suportado ... Mas este post mostra uma solução alternativa .

Bob Rivers
fonte