मुझे ई-मेल पते को कैसे मान्य करना चाहिए?

Question

एंड्रॉइड में एक ई-मेल पता (जैसे उपयोगकर्ता इनपुट फ़ील्ड से) सत्यापित करने के लिए एक अच्छी तकनीक क्या है? org.apache.commons.validator.routines.EmailValidator उपलब्ध नहीं लगता है। क्या कोई अन्य पुस्तकालय ऐसा कर रहे हैं जो पहले से ही एंड्रॉइड में शामिल हैं या मुझे RegExp का उपयोग करना होगा?

Comments

कृपया इसे देखें, यह आपकी मदद कर सकता है: stackoverflow.com/questions/12947620/…

— हिरेन पटेल

@ user2757064 अच्छी तरह से इस प्रश्न को आपके द्वारा जुड़े अन्य प्रश्न की मदद करनी चाहिए। यह सवाल इसके 3 साल बाद पूछा गया था। :)

— सूफियान

Answer 1

रेग-पूर्व का उपयोग न करें।

जाहिरा तौर पर निम्नलिखित एक रेग-पूर्व है जो आरएफसी 2822 के अनुरूप अधिकांश ई-मेल पते को सही ढंग से मान्य करता है , और जो कि अभी भी "[e-mail]" जैसी चीजों पर विफल रहेगा, जैसा कि 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])+)\])

संभवतः ई-मेल को मान्य करने का सबसे आसान तरीका प्रदान किए गए पते पर एक पुष्टिकरण ई-मेल भेजना है और यह बाउंस हो जाता है तो यह मान्य नहीं है।

यदि आप कुछ बुनियादी जाँच करना चाहते हैं तो आप जाँच सकते हैं कि यह फॉर्म में है *@*

यदि आपके पास कुछ व्यावसायिक तर्क विशिष्ट सत्यापन हैं, तो आप प्रदर्शन कर सकते हैं कि एक regex का उपयोग करके, उदाहरण के लिए gmail.com खाता या कुछ होना चाहिए।

Comments

मुझे पता है कि यह उत्तर लगभग दो साल पुराना है, लेकिन जब मैं regexr.com का उपयोग करके इस regex को आज़माता हूं, तो यह मान्य होता है [e-mail], और इससे अधिक लंबे समय तक जैसे मौज़ूद। क्या मैं कुछ भूल रहा हूँ? मैं अपने किसी भी उपयोगकर्ता को उनके वैध ई-मेल पते को मान्य करने में विफल नहीं होना चाहता, लेकिन ऐसा लगता है कि मैं जो भी सोच सकता हूं, उसके लिए काम कर रहा हूं।

— बॉब वॉर्क

@ याकूब सर्वर पर ईमेल पते को मान्य करता है .. फोरस्क्वेयर ऐप की जांच करें यह वही करता है

— हर्ष एमवी

मैं थोड़ा उलझन में हूं कि आप इस जवाब को "डोंट यूज ए रेज-एक्स" से शुरू करते हैं और फिर एक रेग-एक्स उपलब्ध कराने के लिए आगे बढ़ते हैं।

— हॉवेटल

कृपया पढ़ते रहें। एक बेहतर समाधान नीचे है जो रेगेक्स का उपयोग नहीं करता है।

— लोशेग

@ गलेन। क्या यह Android के पैटर्न के लिए सही रहेगा। EMAIL_ADDRESS ? डेवलपर.

— android.com/reference/android/util/…

Answer 2

एक और विकल्प एपीआई स्तर 8 के साथ शुरू होने वाले पैटर्न में बनाया गया है :

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

पैटर्न देखने योग्य स्रोत

या

@AdamvandenHoven से एक पंक्ति समाधान:

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

Comments

+1, लेकिन मैं इसके (target == null)साथ प्रतिस्थापित करना पसंद करता TextUtils.isEmpty(target)

— हूं

इस तरह के उत्तर इसलिए हैं क्योंकि मैं अधिकांश मतों के उत्तरों के बजाय शीर्ष पर दिखाए जाने वाले स्वीकृत उत्तरों को नापसंद करता हूं।

— जशूरुन १२'१४ को १

क्या यह भी अधिक समझ में नहीं आता (पठनीयता बुद्धिमान) बस इसे एक पंक्ति में संयोजित करने के लिए: रिटर्न! TextUtils.isEmpty (लक्ष्य) और& android.util.Patterns.EMAIL_ADDRESS.matcher (लक्ष्य) .matches ()।

— एडम वैन ने हॉनॉन

@ सच, ​​लेकिन उपरोक्त विधि बूलियन है इसलिए हमारे पास यह जानकारी नहीं है कि यह कब गलत है। वैसे भी, कोई टोस्ट या फ़ंक्शन के अंदर से ui को अपडेट कर सकता है (UI थ्रेड में चलाया जाना चाहिए)। मेरे जैसे लोगों के लिए, जो प्रोग्राम प्राप्त किए गए ईमेल को वैध रूप से मान्य कर रहे हैं और कोई उपयोगकर्ता सहभागिता नहीं है, हम सिर्फ '== null' से चिपके रह सकते हैं और संभवत: अधिकांश मामलों में एक-दो घड़ी के चक्र को बचा सकते हैं।

— एजे

सावधान रहे। यह मिलान email@111.222.333.44444एक मान्य ईमेल के रूप में स्वीकार करता है

— जोक्विन इराचुक

Answer 3

अगला पैटर्न 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}" +
          ")+"
      );

आप फ़ंक्शन का उपयोग कर सकते हैं

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

Comments

उपयोग क्यों नहीं android.util.Patterns.EMAIL_ADDRESS?

— सेर्गेई मेटलोव

क्योंकि यह एपीआई स्तर 8 के बाद से ही मौजूद है

— आंद्रेई बनेयू

इसने मुझे सरल उत्तर के लिए बहुत धन्यवाद और +1 करने में मदद की .. :)

— दीप्ति

FYI करें: चरित्र वर्ग के अंदर मेटाचैकर्स बहुत कम होते हैं और एक सीमा पर डालने पर हाइफ़न अपने आप बच जाता है, आप पहली कक्षा को [a-zA-Z0-9+._%-]और अन्य को सरल बना सकते हैं[a-zA-Z0-9-]

— रॉबिन

यह केवल सच वापसी करता है, तो ईमेल वाक्य रचना में ही है ईमेल करता है के रूप में, मैं दूर करने के लिए करने की कोशिश की iसे @gmail.comयह सच वापस आ जाएगी। वही @@yaho.com में।

— RoCk RoCk

Answer 4

चूंकि API 8 (Android 2.2) एक पैटर्न है: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

तो आप इसका उपयोग अपने ई-मेल को सत्यापित करने के लिए कर सकते हैं:

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

यदि ईमेल वैध है तो सही है

UPD: यह पैटर्न सोर्स कोड है:

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

इसका संदर्भ लें: http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/util/Patterns.java

तो आप इसे एपीआई <8 के साथ संगतता के लिए खुद बना सकते हैं।

Answer 5

अब हमारे पास सरल ईमेल पैटर्न मिलानकर्ता है

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

Answer 6

ईमेल सत्यापन के लिए सरल एक लाइन कोड का उपयोग करें

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

उपयोग की तरह ...

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

Answer 7

यह एंड्रॉइड स्टूडियो सुझाव है:

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

Comments

null check email == nullredandunt है क्योंकि TextUtils इसे अंदर चेक करता है

— Volodymyr

@VolodymyrKhodonovych आप सही हैं, लेकिन अशक्त जांच एक OR राज्य में की जाती है, ऐसा न करने से मैचर्स () विधि को ईमेल पास करते समय NPE हो सकता है।

— मैट्टो

Answer 8

आप ऐसा करने के लिए नियमित अभिव्यक्ति का उपयोग कर सकते हैं। निम्नलिखित में से कुछ।

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

String email = "[e-mail]";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

नोट: ऊपर दी गई नियमित अभिव्यक्ति की जाँच करें, जैसा है वैसा उसका उपयोग न करें।

Comments

यह निम्न मान्य ईमेल पते पर विफल रहता है "Example Guy" <[e-mail]>:। जब आप तकनीकी रूप से ईमेल को एक रेगेक्स के साथ मान्य कर सकते हैं , तो ऐसा करना थोड़ा बेतुका है।

— कोरी पेटोस्की

हालांकि यह सिर्फ एक ईमेल पता नहीं है।

— ब्रिल पप्पिन

Answer 9

Android का उपयोग करें: inputType = "textEmailAddress" नीचे के रूप में:

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

तथा:

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

Answer 10

आप इस तरह एक कोटलिन एक्सटेंशन लिख सकते हैं:

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

और फिर इसे इस तरह से कॉल करें:

email.isValidEmail()

Comments

"पैटर्न" कौन है?

— जेमशीट इस्केंडरोव

android.util.Patterns

— Danilo Lemes

Answer 11

Patternsपैकेज में एक वर्ग है android.utilजो यहां फायदेमंद है। नीचे वह विधि है जो मैं हमेशा ईमेल और कई अन्य सामानों को मान्य करने के लिए उपयोग करता हूं

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

Answer 12

इस पद्धति को कॉल करें जहां आप ईमेल आईडी को मान्य करना चाहते हैं।

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

Answer 13

एक ईमेल सत्यापन के लिए Android कुछ इनबिल्ट पैटर्न प्रदान करता है । लेकिन केवल एपीआई स्तर 8 और इसके बाद के संस्करण का समर्थन करते हैं ।

ईमेल सत्यापन की जाँच करने के लिए उस पैटर्न का उपयोग करने के लिए यहाँ कोड है।

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

सुनिश्चित करें कि इस पद्धति को निष्पादित करने के बाद आपको यह जांचना चाहिए कि यदि यह विधि सही है, तो आप ईमेल को सहेजने की अनुमति देते हैं और यदि यह विधि गलत है तो संदेश को प्रदर्शित करें जो कि ईमेल "अमान्य" है।

आशा है आपको अपना उत्तर मिलेगा, धन्यवाद।

Answer 14

क्या मैं आपके ईमेल पते को 'मान्य' करने की कोशिश नहीं कर सकता, आप बिना किसी अच्छे कारण के खुद को बहुत काम में लाएँगे।

बस यह सुनिश्चित करें कि जो दर्ज किया गया है वह आपके स्वयं के कोड को नहीं तोड़ेगा - जैसे कोई स्थान या अवैध वर्ण जो अपवाद का कारण हो सकता है।

और कुछ भी बस आपको कम से कम वापसी के लिए बहुत काम करेगा ...

Comments

सदस्यता और भुगतान के साथ काम करते समय यह शायद ही उपयोगी सलाह है। यदि कोई अपना पासवर्ड भूल जाता है, तो हमारे पास सुरक्षित रूप से अपना पासवर्ड रीसेट करने का एक तरीका होना चाहिए ताकि वे उस सेवा का उपयोग करना जारी रख सकें जिसके लिए उन्होंने भुगतान किया है। इसलिए कभी-कभी यह सबसे अच्छा है कि हम यह सुनिश्चित करें कि वे अपने स्वयं के लिए एक वैध ई-मेल पता दर्ज कर रहे हैं।

— डीन वाइल्ड

बस मैंने जो कहा, उसके बारे में स्पष्ट होना - अगर कोई नकली / गलत पते पर प्रवेश करने का इरादा रखता है - तो सत्यापन की कोई भी राशि उन्हें नहीं रोकेगी .. रिक्त स्थान जैसे मूर्खतापूर्ण गलतियों की जांच करना और कोई '@' आदि ठीक नहीं है - और कुछ भी जांचना अच्छी तरह से 'कम रिटर्न' में ...

एक नकली ईमेल की पहचान करने का एकमात्र तरीका उस ईमेल आईडी पर एक ईमेल भेजना है और यह देखना है कि क्या आपको एक

— अवांछित

जॉन, कई उपयोगकर्ता नकली / गलत पते पर प्रवेश करने के इरादे से नहीं होंगे , लेकिन दुर्घटना में गलत तरीके से दर्ज कर सकते हैं। इसलिए एक साधारण जांच करना बहुत उपयोगी हो सकता है और, जैसा कि मन की बात के जवाब में दिखाया गया है, बहुत काम नहीं है। मेरे अनुभव से, अधिकांश लोग अपने ईमेल पते सही ढंग से दर्ज करते हैं, और कुछ अवैध ईमेल सबसे अधिक बार निर्दोष टाइपो के लिए नीचे लगते हैं।

— प्रतिबंध-जियोइंजीनियरिंग

यदि यह महत्वपूर्ण है कि उपयोगकर्ता का ईमेल काम करता है तो आप एक पुष्टिकरण ईमेल भेजते हैं। बाकी सब बकवास है।

— अविश्वसनीय

Answer 15

अपना ईमेल पता प्रारूप सत्यापित करें। [e-mail]

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

Answer 16

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

Answer 17

यदि आप एपीआई 8 या उससे ऊपर का उपयोग कर रहे हैं, तो आप Patternsईमेल को मान्य करने के लिए आसानी से उपलब्ध वर्ग का उपयोग कर सकते हैं । नमूना कोड:

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

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

संयोग से अगर आप भी 8 से कम एपीआई स्तर का समर्थन कर रहे हैं, तो आप बस Patterns.javaफ़ाइल को अपनी परियोजना में कॉपी कर सकते हैं और इसे संदर्भित कर सकते हैं। आप इस लिंकPatterns.java से स्रोत कोड प्राप्त कर सकते हैं

Answer 18

यहाँ है android.util.Patterns.EMAIL_ADDRESS

[एक-zA-Z0-9 + ._ \% - +] {1,256} \ @ [एक-zA-Z0-9] [एक-zA-Z0-9 -]। {0,64} ([एक करने के लिए zA-Z0-9] [एक-zA-Z0-9 -] {0,25}) +

String अगर यह मैच होगा

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

कुछ विशेष मैच ईमेल का उदाहरण दें

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

आप अपने मामले के लिए इस पैटर्न को फिर से संशोधित कर सकते हैं

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

Answer 19

इस सरल तरीके को आज़माएं जो अंकों के साथ शुरू होने वाले ईमेल पते को स्वीकार नहीं कर सकता है:

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

Answer 20

इस कोड की कोशिश करो .. इसकी वास्तव में काम करता है ..

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

Answer 21

मेरे द्वारा उपयोग किया गया था। हालाँकि इसमें सामान्य ईमेल की तुलना में अतिरिक्त वर्ण हैं लेकिन यह मेरे लिए एक आवश्यकता थी।

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

इस प्रश्न का उत्तर: - दिए गए बिंदुओं के साथ एक ई-मेल पते को मान्य करने की आवश्यकता

Explanation-

1. (?? *।? ..) "नकारात्मक लुकहेड" लगातार 2 डॉट्स को नकारने के लिए।
2. [A-Za-z0-9।! # \ _ \ _ \ _ \ _ \ _ \ _ * \ _ \ _ \ _ _ \ _ {\ _} \ _] + कम से कम एक वर्ण परिभाषित। ("\" भागने के लिए प्रयोग किया जाता है)।
3. @ एक "@" हो सकता है।
4. [A-Za-z0-9] + फिर कम से कम एक वर्ण परिभाषित।
5. [A-Za-z0-9 -।] * शून्य या परिभाषित चरित्र के किसी भी पुनरावृत्ति।
6. [A-Za-z0-9] + कम से कम एक चार बिंदु डॉट के बाद।

Answer 22

यहां कुंजी यह है कि आप ईमेल पते को पूरी तरह से सत्यापित करना चाहते हैं। आप इसे केवल वाक्यात्मक शुद्धता के लिए जाँचना नहीं चाहते हैं, आप यह जाँचना चाहते हैं कि ईमेल पता असली है या नहीं।

दो स्पष्ट कारण: वास्तविक उपयोगकर्ता अक्सर अपने ईमेल पते गलत लिखते हैं, और कुछ उपयोगकर्ता नकली ईमेल पते में डाल सकते हैं। इसलिए, आप एक सिंटैक्टिक चेक और एक अस्तित्व जांच करना चाहते हैं।

ऐसा करने का सबसे अच्छा तरीका जो मुझे एंड्रॉइड पर मिला है, वह है इसके लिए फ्री क्लाउडसेरिव वैलिडेशन एपीआई का उपयोग करना ।

कोड इस तरह दिखता है:

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

मैं अपने सभी ऐप्स में इसका उपयोग कर रहा हूं और यह बहुत अच्छा है क्योंकि मैं प्रवेश के बिंदु पर UX में ईमेल पते को मान्य कर सकता हूं ।

Answer 23

एक्सटेंशन कार्यों का उपयोग करते हुए सरलतम कोटलिन समाधान:

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-mail]".isEmailValid()

Answer 24

ध्यान दें कि अधिकांश नियमित अभिव्यक्तियाँ अंतर्राष्ट्रीय डोमेन नाम (IDN) और .mobi या .info जैसे नए शीर्ष स्तरीय डोमेन के लिए मान्य नहीं हैं (यदि आप देश कोड या .org, .com, .gov और इतने पर के लिए जाँच करते हैं)।

एक मान्य चेक को स्थानीय भाग (एट-साइन से पहले) और डोमेन भाग को अलग करना चाहिए। आपको स्थानीय भाग और डोमेन की अधिकतम लंबाई (एट-साइन सहित 255 वर्ण) पर भी विचार करना चाहिए।

आईडीएन संगत प्रारूप में पते को बदलने के लिए सबसे अच्छा तरीका है (यदि आवश्यक हो), स्थानीय भाग (आरएफसी) को मान्य करें, पते की लंबाई और डोमेन (DNS एमएक्स लुकअप) की उपलब्धता की जांच करें या बस एक ईमेल भेजें ।

Answer 25

Linkify क्लास में कुछ बहुत उपयोगी सहायक विधियां हैं जो प्रासंगिक हो सकती हैं, जिसमें फ़ोन नंबर और ईमेल पते लेने के लिए डिज़ाइन किए गए नियमित भाव शामिल हैं और जैसे:

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

Answer 26

मैंने follwing कोड का उपयोग किया है। यह काम करता है। मुझे आशा है कि यह आपकी मदद करेगा।

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

और ईमेल विधि मान्य है, तो यह follwing विधि का उपयोग करें।

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

Answer 27

ईमेल आपका ईमेल है।

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

    }

Answer 28

रेगेक्स प्रेमियों के लिए, बहुत ही बेहतरीन (उदाहरण के लिए RFC 822 के साथ संगत) ईमेल का पैटर्न जो मैंने अब तक पाया है वह निम्नलिखित है (PHP आपूर्ति किए गए फ़िल्टर से पहले)। मुझे लगता है कि एपीआई <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 ;
}

Answer 29

आप oval.jar फ़ाइल द्वारा Android में किसी भी प्रकार का सत्यापन बहुत आसानी से कर सकते हैं। OVal किसी भी तरह की Java ऑब्जेक्ट के लिए एक व्यावहारिक और एक्स्टेंसिबल सामान्य प्रयोजन सत्यापन ढांचा है।

इस लिंक का पालन करें: http://oval.sourceforge.net/userguide.html

आप इसे यहां से नीचे हटा सकते हैं: http://oval.sourceforge.net/userguide.html#download

आप चर में टैग सेट करके सत्यापन का उपयोग कर सकते हैं

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

Answer 30

आप भी इस्तेमाल कर सकते हैं

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

यदि ईमेल मान्य नहीं है, तो यह एक AddressException फेंक देगा ।

दुर्भाग्य से एंड्रॉइड jndi-dns का समर्थन नहीं करता है , लेकिन सिर्फ आपको अधिक शक्तिशाली ईमेल सत्यापन का विचार देने के लिए, आप इसका उपयोग ईमेल डोमेन को मान्य करने के लिए कर सकते हैं। शायद एक एंड्रॉइड गुरु मदद कर सकता है और दिखा सकता है कि क्या समान विकल्प हैं ... "नियमित" जावा के साथ एक उदाहरण कार्यान्वयन यहां उपलब्ध है ।

संपादित करें

मुझे बस एहसास हुआ कि javax.mail न तो समर्थन कर रहा है ... लेकिन यह पोस्ट एक वर्कअराउंड दिखाता है ।