What is the best Java email address validation method?

By | December 18, 2017
Questions:

What are the good email address validation libraries for Java? Are there any alternatives to commons validator?

Answers:

Apache Commons is generally known as a solid project. Keep in mind, though, you’ll still have to send a verification email to the address if you want to ensure it’s a real email, and that the owner wants it used on your site.

EDIT: There was a bug where it was too restrictive on domain, causing it to not accept valid emails from new TLDs.

This bug was resolved on 03/Jan/15 02:48 in commons-validator version 1.4.1

Questions:
Answers:

Using the official java email package is the easiest:

public static boolean isValidEmailAddress(String email) {
   boolean result = true;
   try {
      InternetAddress emailAddr = new InternetAddress(email);
      emailAddr.validate();
   } catch (AddressException ex) {
      result = false;
   }
   return result;
}

Questions:
Answers:

Apache Commons validator can be used as mentioned in the other answers.

pom.xml:

<dependency>
    <groupId>commons-validator</groupId>
    <artifactId>commons-validator</artifactId>
    <version>1.4.1</version>
</dependency>

build.gradle:

compile 'commons-validator:commons-validator:1.4.1'

The import:

import org.apache.commons.validator.routines.EmailValidator;

The code:

String email = "myName@example.com";
boolean valid = EmailValidator.getInstance().isValid(email);

and to allow local addresses

boolean allowLocal = true;
boolean valid = EmailValidator.getInstance(allowLocal).isValid(email);

Questions:
Answers:

Late answer, but I think it is simple and worthy:

    public boolean isValidEmailAddress(String email) {
           String ePattern = "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$";
           java.util.regex.Pattern p = java.util.regex.Pattern.compile(ePattern);
           java.util.regex.Matcher m = p.matcher(email);
           return m.matches();
    }

Test Cases:

enter image description here

For production purpose, Domain Name validations should be performed network-wise.

Questions:
Answers:

If you are trying to do a form validation received from the client, or just a bean validation – keep it simple.
It’s better to do a loose email validation rather than to do a strict one and reject some people, (e.g. when they are trying to register for your web service).
With almost anything allowed in the username part of the email and so many new domains being added literally every month (e.g. .company, .entreprise, .estate), it’s safer not to be restrictive:

Pattern pattern = Pattern.compile("^.+@.+\\..+$");
Matcher matcher = pattern.matcher(email);

Questions:
Answers:

I’m just wondering why nobody came up with @Email from Hibernate Validator’s additional constraints. The validator itself is EmailValidator.

Questions:
Answers:

Les Hazlewood has written a very thorough RFC 2822 compliant email validator class using Java regular expressions. You can find it at http://www.leshazlewood.com/?p=23. However, its thoroughness (or the Java RE implementation) leads to inefficiency – read the comments about parsing times for long addresses.

Questions:
Answers:

Late to the question, here, but: I maintain a class at this address: http://lacinato.com/cm/software/emailrelated/emailaddress

It is based on Les Hazlewood’s class, but has numerous improvements and fixes a few bugs. Apache license.

I believe it is the most capable email parser in Java, and I have yet to see one more capable in any language, though there may be one out there. It’s not a lexer-style parser, but uses some complicated java regex, and thus is not as efficient as it could be, but my company has parsed well over 10 billion real-world addresses with it: it’s certainly usable in a high-performance situation. Maybe once a year it’ll hit an address that causes a regex stack overflow (appropriately), but these are spam addresses which are hundreds or thousands of characters long with many many quotes and parenthesis and the like.

RFC 2822 and the related specs are really quite permissive in terms of email addresses, so a class like this is overkill for most uses. For example, the following is a legitimate address, according to spec, spaces and all:

"<bob \" (here) " < (hi there) "bob(the man)smith" (hi) @ (there) example.com (hello) > (again)

No mail server would allow that, but this class can parse it (and rewrite it to a usable form).

We found the existing Java email parser options to be insufficiently durable (meaning, all of them could not parse some valid addresses), so we created this class.

The code is well-documented and has a lot of easy-to-change options to allow or disallow certain email forms. It also provides a lot of methods to access certain parts of the address (left-hand side, right-hand side, personal names, comments, etc), to parse/validate mailbox-list headers, to parse/validate the return-path (which is unique among the headers), and so forth.

The code as written has a javamail dependency, but it’s easy to remove if you don’t want the minor functionality it provides.

Questions:
Answers:

I ported some of the code in Zend_Validator_Email:

@FacesValidator("emailValidator")
public class EmailAddressValidator implements Validator {

    private String localPart;
    private String hostName;
    private boolean domain = true;

    Locale locale;
    ResourceBundle bundle;

    private List<FacesMessage> messages = new ArrayList<FacesMessage>();

    private HostnameValidator hostnameValidator;

    @Override
    public void validate(FacesContext context, UIComponent component, Object value) throws ValidatorException {
        setOptions(component);
        String email    = (String) value;
        boolean result  = true;
        Pattern pattern = Pattern.compile("^(.+)@([^@]+[^.])$");
        Matcher matcher = pattern.matcher(email);

        locale = context.getViewRoot().getLocale();
        bundle = ResourceBundle.getBundle("com.myapp.resources.validationMessages", locale);

        boolean length = true;
        boolean local  = true;

        if (matcher.find()) {
            localPart   = matcher.group(1);
            hostName    = matcher.group(2);

            if (localPart.length() > 64 || hostName.length() > 255) {
                length          = false;
                addMessage("enterValidEmail", "email.AddressLengthExceeded");
            } 

            if (domain == true) {
                hostnameValidator = new HostnameValidator();
                hostnameValidator.validate(context, component, hostName);
            }

            local = validateLocalPart();

            if (local && length) {
                result = true;
            } else {
                result = false;
            }

        } else {
            result          = false;
            addMessage("enterValidEmail", "invalidEmailAddress");
        }

        if (result == false) {
            throw new ValidatorException(messages);
        }

    }

    private boolean validateLocalPart() {
        // First try to match the local part on the common dot-atom format
        boolean result = false;

        // Dot-atom characters are: 1*atext *("." 1*atext)
        // atext: ALPHA / DIGIT / and "!", "#", "$", "%", "&", "'", "*",
        //        "+", "-", "/", "=", "?", "^", "_", "`", "{", "|", "}", "~"
        String atext = "a-zA-Z0-9\\u0021\\u0023\\u0024\\u0025\\u0026\\u0027\\u002a"
                + "\\u002b\\u002d\\u002f\\u003d\\u003f\\u005e\\u005f\\u0060\\u007b"
                + "\\u007c\\u007d\\u007e";
        Pattern regex = Pattern.compile("^["+atext+"]+(\\u002e+["+atext+"]+)*$");
        Matcher matcher = regex.matcher(localPart);
        if (matcher.find()) {
            result = true;
        } else {
            // Try quoted string format

            // Quoted-string characters are: DQUOTE *([FWS] qtext/quoted-pair) [FWS] DQUOTE
            // qtext: Non white space controls, and the rest of the US-ASCII characters not
            //   including "\" or the quote character
            String noWsCtl = "\\u0001-\\u0008\\u000b\\u000c\\u000e-\\u001f\\u007f";
            String qText = noWsCtl + "\\u0021\\u0023-\\u005b\\u005d-\\u007e";
            String ws = "\\u0020\\u0009";

            regex = Pattern.compile("^\\u0022(["+ws+qText+"])*["+ws+"]?\\u0022$");
            matcher = regex.matcher(localPart);
            if (matcher.find()) {
                result = true;
            } else {
                addMessage("enterValidEmail", "email.AddressDotAtom");
                addMessage("enterValidEmail", "email.AddressQuotedString");
                addMessage("enterValidEmail", "email.AddressInvalidLocalPart");
            }
        }

        return result;
    }

    private void addMessage(String detail, String summary) {
        String detailMsg = bundle.getString(detail);
        String summaryMsg = bundle.getString(summary);
        messages.add(new FacesMessage(FacesMessage.SEVERITY_ERROR, summaryMsg, detailMsg));
    }

    private void setOptions(UIComponent component) {
        Boolean domainOption = Boolean.valueOf((String) component.getAttributes().get("domain"));
        //domain = (domainOption == null) ? true : domainOption.booleanValue();
    }
}

With a hostname validator as follows:

@FacesValidator("hostNameValidator")
public class HostnameValidator implements Validator {

    private Locale locale;
    private ResourceBundle bundle;
    private List<FacesMessage> messages;
    private boolean checkTld = true;
    private boolean allowLocal = false;
    private boolean allowDNS = true;
    private String tld;
    private String[] validTlds = {"ac", "ad", "ae", "aero", "af", "ag", "ai",
        "al", "am", "an", "ao", "aq", "ar", "arpa", "as", "asia", "at", "au",
        "aw", "ax", "az", "ba", "bb", "bd", "be", "bf", "bg", "bh", "bi", "biz",
        "bj", "bm", "bn", "bo", "br", "bs", "bt", "bv", "bw", "by", "bz", "ca",
        "cat", "cc", "cd", "cf", "cg", "ch", "ci", "ck", "cl", "cm", "cn", "co",
        "com", "coop", "cr", "cu", "cv", "cx", "cy", "cz", "de", "dj", "dk",
        "dm", "do", "dz", "ec", "edu", "ee", "eg", "er", "es", "et", "eu", "fi",
        "fj", "fk", "fm", "fo", "fr", "ga", "gb", "gd", "ge", "gf", "gg", "gh",
        "gi", "gl", "gm", "gn", "gov", "gp", "gq", "gr", "gs", "gt", "gu", "gw",
        "gy", "hk", "hm", "hn", "hr", "ht", "hu", "id", "ie", "il", "im", "in",
        "info", "int", "io", "iq", "ir", "is", "it", "je", "jm", "jo", "jobs",
        "jp", "ke", "kg", "kh", "ki", "km", "kn", "kp", "kr", "kw", "ky", "kz",
        "la", "lb", "lc", "li", "lk", "lr", "ls", "lt", "lu", "lv", "ly", "ma",
        "mc", "md", "me", "mg", "mh", "mil", "mk", "ml", "mm", "mn", "mo",
        "mobi", "mp", "mq", "mr", "ms", "mt", "mu", "museum", "mv", "mw", "mx",
        "my", "mz", "na", "name", "nc", "ne", "net", "nf", "ng", "ni", "nl",
        "no", "np", "nr", "nu", "nz", "om", "org", "pa", "pe", "pf", "pg", "ph",
        "pk", "pl", "pm", "pn", "pr", "pro", "ps", "pt", "pw", "py", "qa", "re",
        "ro", "rs", "ru", "rw", "sa", "sb", "sc", "sd", "se", "sg", "sh", "si",
        "sj", "sk", "sl", "sm", "sn", "so", "sr", "st", "su", "sv", "sy", "sz",
        "tc", "td", "tel", "tf", "tg", "th", "tj", "tk", "tl", "tm", "tn", "to",
        "tp", "tr", "travel", "tt", "tv", "tw", "tz", "ua", "ug", "uk", "um",
        "us", "uy", "uz", "va", "vc", "ve", "vg", "vi", "vn", "vu", "wf", "ws",
        "ye", "yt", "yu", "za", "zm", "zw"};
    private Map<String, Map<Integer, Integer>> idnLength;

    private void init() {
        Map<Integer, Integer> biz = new HashMap<Integer, Integer>();
        biz.put(5, 17);
        biz.put(11, 15);
        biz.put(12, 20);

        Map<Integer, Integer> cn = new HashMap<Integer, Integer>();
        cn.put(1, 20);

        Map<Integer, Integer> com = new HashMap<Integer, Integer>();
        com.put(3, 17);
        com.put(5, 20);

        Map<Integer, Integer> hk = new HashMap<Integer, Integer>();
        hk.put(1, 15);

        Map<Integer, Integer> info = new HashMap<Integer, Integer>();
        info.put(4, 17);

        Map<Integer, Integer> kr = new HashMap<Integer, Integer>();
        kr.put(1, 17);

        Map<Integer, Integer> net = new HashMap<Integer, Integer>();
        net.put(3, 17);
        net.put(5, 20);

        Map<Integer, Integer> org = new HashMap<Integer, Integer>();
        org.put(6, 17);

        Map<Integer, Integer> tw = new HashMap<Integer, Integer>();
        tw.put(1, 20);

        Map<Integer, Integer> idn1 = new HashMap<Integer, Integer>();
        idn1.put(1, 20);

        Map<Integer, Integer> idn2 = new HashMap<Integer, Integer>();
        idn2.put(1, 20);

        Map<Integer, Integer> idn3 = new HashMap<Integer, Integer>();
        idn3.put(1, 20);

        Map<Integer, Integer> idn4 = new HashMap<Integer, Integer>();
        idn4.put(1, 20);

        idnLength = new HashMap<String, Map<Integer, Integer>>();

        idnLength.put("BIZ", biz);
        idnLength.put("CN", cn);
        idnLength.put("COM", com);
        idnLength.put("HK", hk);
        idnLength.put("INFO", info);
        idnLength.put("KR", kr);
        idnLength.put("NET", net);
        idnLength.put("ORG", org);
        idnLength.put("TW", tw);
        idnLength.put("ایران", idn1);
        idnLength.put("中国", idn2);
        idnLength.put("公司", idn3);
        idnLength.put("网络", idn4);

        messages = new ArrayList<FacesMessage>();
    }

    public HostnameValidator() {
        init();
    }

    @Override
    public void validate(FacesContext context, UIComponent component, Object value) throws ValidatorException {
        String hostName = (String) value;

        locale = context.getViewRoot().getLocale();
        bundle = ResourceBundle.getBundle("com.myapp.resources.validationMessages", locale);

        Pattern ipPattern = Pattern.compile("^[0-9a-f:\\.]*$", Pattern.CASE_INSENSITIVE);
        Matcher ipMatcher = ipPattern.matcher(hostName);
        if (ipMatcher.find()) {
            addMessage("hostname.IpAddressNotAllowed");
            throw new ValidatorException(messages);
        }

        boolean result = false;

        // removes last dot (.) from hostname 
        hostName = hostName.replaceAll("(\\.)+$", "");
        String[] domainParts = hostName.split("\\.");

        boolean status = false;

        // Check input against DNS hostname schema
        if ((domainParts.length > 1) && (hostName.length() > 4) && (hostName.length() < 255)) {
            status = false;

            dowhile:
            do {
                // First check TLD
                int lastIndex = domainParts.length - 1;
                String domainEnding = domainParts[lastIndex];
                Pattern tldRegex = Pattern.compile("([^.]{2,10})", Pattern.CASE_INSENSITIVE);
                Matcher tldMatcher = tldRegex.matcher(domainEnding);
                if (tldMatcher.find() || domainEnding.equals("ایران")
                        || domainEnding.equals("中国")
                        || domainEnding.equals("公司")
                        || domainEnding.equals("网络")) {



                    // Hostname characters are: *(label dot)(label dot label); max 254 chars
                    // label: id-prefix [*ldh{61} id-prefix]; max 63 chars
                    // id-prefix: alpha / digit
                    // ldh: alpha / digit / dash

                    // Match TLD against known list
                    tld = (String) tldMatcher.group(1).toLowerCase().trim();
                    if (checkTld == true) {
                        boolean foundTld = false;
                        for (int i = 0; i < validTlds.length; i++) {
                            if (tld.equals(validTlds[i])) {
                                foundTld = true;
                            }
                        }

                        if (foundTld == false) {
                            status = false;
                            addMessage("hostname.UnknownTld");
                            break dowhile;
                        }
                    }

                    /**
                     * Match against IDN hostnames
                     * Note: Keep label regex short to avoid issues with long patterns when matching IDN hostnames
                     */
                    List<String> regexChars = getIdnRegexChars();

                    // Check each hostname part
                    int check = 0;
                    for (String domainPart : domainParts) {
                        // Decode Punycode domainnames to IDN
                        if (domainPart.indexOf("xn--") == 0) {
                            domainPart = decodePunycode(domainPart.substring(4));
                        }

                        // Check dash (-) does not start, end or appear in 3rd and 4th positions
                        if (domainPart.indexOf("-") == 0
                                || (domainPart.length() > 2 && domainPart.indexOf("-", 2) == 2 && domainPart.indexOf("-", 3) == 3)
                                || (domainPart.indexOf("-") == (domainPart.length() - 1))) {
                            status = false;
                            addMessage("hostname.DashCharacter");
                            break dowhile;
                        }

                        // Check each domain part
                        boolean checked = false;

                        for (int key = 0; key < regexChars.size(); key++) {
                            String regexChar = regexChars.get(key);
                            Pattern regex = Pattern.compile(regexChar);
                            Matcher regexMatcher = regex.matcher(domainPart);
                            status = regexMatcher.find();
                            if (status) {
                                int length = 63;

                                if (idnLength.containsKey(tld.toUpperCase())
                                        && idnLength.get(tld.toUpperCase()).containsKey(key)) {
                                    length = idnLength.get(tld.toUpperCase()).get(key);
                                }

                                int utf8Length;
                                try {
                                    utf8Length = domainPart.getBytes("UTF8").length;
                                    if (utf8Length > length) {
                                        addMessage("hostname.InvalidHostname");
                                    } else {
                                        checked = true;
                                        break;
                                    }
                                } catch (UnsupportedEncodingException ex) {
                                    Logger.getLogger(HostnameValidator.class.getName()).log(Level.SEVERE, null, ex);
                                }


                            }
                        }


                        if (checked) {
                            ++check;
                        }
                    }

                    // If one of the labels doesn't match, the hostname is invalid
                    if (check != domainParts.length) {
                        status = false;
                        addMessage("hostname.InvalidHostnameSchema");

                    }
                } else {
                    // Hostname not long enough
                    status = false;
                    addMessage("hostname.UndecipherableTld");
                }

            } while (false);

            if (status == true && allowDNS) {
                result = true;
            }

        } else if (allowDNS == true) {
            addMessage("hostname.InvalidHostname");
            throw new ValidatorException(messages);
        }

        // Check input against local network name schema;
        Pattern regexLocal = Pattern.compile("^(([a-zA-Z0-9\\x2d]{1,63}\\x2e)*[a-zA-Z0-9\\x2d]{1,63}){1,254}$", Pattern.CASE_INSENSITIVE);
        boolean checkLocal = regexLocal.matcher(hostName).find();
        if (allowLocal && !status) {
            if (checkLocal) {
                result = true;
            } else {
                // If the input does not pass as a local network name, add a message
                result = false;
                addMessage("hostname.InvalidLocalName");
            }
        }


        // If local network names are not allowed, add a message
        if (checkLocal && !allowLocal && !status) {
            result = false;
            addMessage("hostname.LocalNameNotAllowed");
        }

        if (result == false) {
            throw new ValidatorException(messages);
        }

    }

    private void addMessage(String msg) {
        String bundlMsg = bundle.getString(msg);
        messages.add(new FacesMessage(FacesMessage.SEVERITY_ERROR, bundlMsg, bundlMsg));
    }

    /**
     * Returns a list of regex patterns for the matched TLD
     * @param tld
     * @return 
     */
    private List<String> getIdnRegexChars() {
        List<String> regexChars = new ArrayList<String>();
        regexChars.add("^[a-z0-9\\x2d]{1,63}$");
        Document doc = null;
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);

        try {
            InputStream validIdns = getClass().getClassLoader().getResourceAsStream("com/myapp/resources/validIDNs_1.xml");
            DocumentBuilder builder = factory.newDocumentBuilder();
            doc = builder.parse(validIdns);
            doc.getDocumentElement().normalize();
        } catch (SAXException ex) {
            Logger.getLogger(HostnameValidator.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(HostnameValidator.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ParserConfigurationException ex) {
            Logger.getLogger(HostnameValidator.class.getName()).log(Level.SEVERE, null, ex);
        }

        // prepare XPath
        XPath xpath = XPathFactory.newInstance().newXPath();

        NodeList nodes = null;
        String xpathRoute = "//idn[tld=\'" + tld.toUpperCase() + "\']/pattern/text()";

        try {
            XPathExpression expr;
            expr = xpath.compile(xpathRoute);
            Object res = expr.evaluate(doc, XPathConstants.NODESET);
            nodes = (NodeList) res;
        } catch (XPathExpressionException ex) {
            Logger.getLogger(HostnameValidator.class.getName()).log(Level.SEVERE, null, ex);
        }


        for (int i = 0; i < nodes.getLength(); i++) {
            regexChars.add(nodes.item(i).getNodeValue());
        }

        return regexChars;
    }

    /**
     * Decode Punycode string
     * @param encoded
     * @return 
         */
    private String decodePunycode(String encoded) {
        Pattern regex = Pattern.compile("([^a-z0-9\\x2d]{1,10})", Pattern.CASE_INSENSITIVE);
        Matcher matcher = regex.matcher(encoded);
        boolean found = matcher.find();

        if (encoded.isEmpty() || found) {
            // no punycode encoded string, return as is
            addMessage("hostname.CannotDecodePunycode");
            throw new ValidatorException(messages);
        }

        int separator = encoded.lastIndexOf("-");
            List<Integer> decoded = new ArrayList<Integer>();
        if (separator > 0) {
            for (int x = 0; x < separator; ++x) {
                decoded.add((int) encoded.charAt(x));
            }
        } else {
            addMessage("hostname.CannotDecodePunycode");
            throw new ValidatorException(messages);
        }

        int lengthd = decoded.size();
        int lengthe = encoded.length();

        // decoding
        boolean init = true;
        int base = 72;
        int index = 0;
        int ch = 0x80;

        int indexeStart = (separator == 1) ? (separator + 1) : 0;
        for (int indexe = indexeStart; indexe < lengthe; ++lengthd) {
            int oldIndex = index;
            int pos = 1;
            for (int key = 36; true; key += 36) {
                int hex = (int) encoded.charAt(indexe++);
                int digit = (hex - 48 < 10) ? hex - 22
                        : ((hex - 65 < 26) ? hex - 65
                        : ((hex - 97 < 26) ? hex - 97
                        : 36));

                index += digit * pos;
                int tag = (key <= base) ? 1 : ((key >= base + 26) ? 26 : (key - base));
                if (digit < tag) {
                    break;
                }
                pos = (int) (pos * (36 - tag));
            }
            int delta = (int) (init ? ((index - oldIndex) / 700) : ((index - oldIndex) / 2));
            delta += (int) (delta / (lengthd + 1));
            int key;
            for (key = 0; delta > 910; key += 36) {
                delta = (int) (delta / 35);
            }
            base = (int) (key + 36 * delta / (delta + 38));
            init = false;
            ch += (int) (index / (lengthd + 1));
            index %= (lengthd + 1);
            if (lengthd > 0) {
                for (int i = lengthd; i > index; i--) {
                    decoded.set(i, decoded.get(i - 1));
                }
            }

            decoded.set(index++, ch);
        }

        // convert decoded ucs4 to utf8 string
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < decoded.size(); i++) {
            int value = decoded.get(i);
            if (value < 128) {
                sb.append((char) value);
            } else if (value < (1 << 11)) {
                sb.append((char) (192 + (value >> 6)));
                sb.append((char) (128 + (value & 63)));
            } else if (value < (1 << 16)) {
                sb.append((char) (224 + (value >> 12)));
                sb.append((char) (128 + ((value >> 6) & 63)));
                sb.append((char) (128 + (value & 63)));
            } else if (value < (1 << 21)) {
                sb.append((char) (240 + (value >> 18)));
                sb.append((char) (128 + ((value >> 12) & 63)));
                sb.append((char) (128 + ((value >> 6) & 63)));
                sb.append((char) (128 + (value & 63)));
            } else {
                addMessage("hostname.CannotDecodePunycode");
                throw new ValidatorException(messages);
            }
        }

        return sb.toString();

    }

    /**
     * Eliminates empty values from input array
     * @param data
     * @return 
     */
    private String[] verifyArray(String[] data) {
        List<String> result = new ArrayList<String>();
        for (String s : data) {
            if (!s.equals("")) {
                result.add(s);
            }
        }

        return result.toArray(new String[result.size()]);
    }
}

And a validIDNs.xml with regex patterns for the different tlds (too big to include:)

<idnlist>
    <idn>
        <tld>AC</tld>
        <pattern>^[\u002d0-9a-zà-öø-ÿāăąćĉċčďđēėęěĝġģĥħīįĵķĺļľŀłńņňŋőœŕŗřśŝşšţťŧūŭůűųŵŷźżž]{1,63}$</pattern>
    </idn>
    <idn>
        <tld>AR</tld>
        <pattern>^[\u002d0-9a-zà-ãç-êìíñ-õü]{1,63}$</pattern>
    </idn>
    <idn>
        <tld>AS</tld>
        <pattern>/^[\u002d0-9a-zà-öø-ÿāăąćĉċčďđēĕėęěĝğġģĥħĩīĭįıĵķĸĺļľłńņňŋōŏőœŕŗřśŝşšţťŧũūŭůűųŵŷźż]{1,63}$</pattern>
    </idn>
    <idn>
        <tld>AT</tld>
        <pattern>/^[\u002d0-9a-zà-öø-ÿœšž]{1,63}$</pattern>
    </idn>
    <idn>
        <tld>BIZ</tld>
        <pattern>^[\u002d0-9a-zäåæéöøü]{1,63}$</pattern>
        <pattern>^[\u002d0-9a-záéíñóúü]{1,63}$</pattern>
        <pattern>^[\u002d0-9a-záéíóöúüőű]{1,63}$</pattern>
    </id>
</idlist>

Questions:
Answers:
public class Validations {

    private Pattern regexPattern;
    private Matcher regMatcher;

    public String validateEmailAddress(String emailAddress) {

        regexPattern = Pattern.compile("^[(a-zA-Z-0-9-\\_\\+\\.)]+@[(a-z-A-z)]+\\.[(a-zA-z)]{2,3}$");
        regMatcher   = regexPattern.matcher(emailAddress);
        if(regMatcher.matches()) {
            return "Valid Email Address";
        } else {
            return "Invalid Email Address";
        }
    }

    public String validateMobileNumber(String mobileNumber) {
        regexPattern = Pattern.compile("^\\+[0-9]{2,3}+-[0-9]{10}$");
        regMatcher   = regexPattern.matcher(mobileNumber);
        if(regMatcher.matches()) {
            return "Valid Mobile Number";
        } else {
            return "Invalid Mobile Number";
        }
    }

    public static void main(String[] args) {

        String emailAddress = "suryaprakash.pisay@gmail.com";
        String mobileNumber = "+91-9986571622";
        Validations validations = new Validations();
        System.out.println(validations.validateEmailAddress(emailAddress));
        System.out.println(validations.validateMobileNumber(mobileNumber));
    }
}

Questions:
Answers:

What do you want to validate? The email address?

The email address can only be checked for its format conformance. See the standard: RFC2822. Best way to do that is a regular expression. You will never know if really exists without sending an email.

I checked the commons validator. It contains an org.apache.commons.validator.EmailValidator class. Seems to be a good starting point.

Questions:
Answers:

Current Apache Commons Validator version is 1.3.1.

Class that validates is org.apache.commons.validator.EmailValidator. It has an import for org.apache.oro.text.perl.Perl5Util which is from a retired Jakarta ORO project.

BTW, I found that there is a 1.4 version, here are the API docs. On the site it says: “Last Published: 05 March 2008 | Version: 1.4-SNAPSHOT”, but that’s not final. Only way to build yourself (but this is a snapshot, not RELEASE) and use, or download from here. This means 1.4 has not been made final for three years (2008-2011). This is not in Apache’s style.
I’m looking for a better option, but didn’t find one that is very adopted. I want to use something that is well tested, don’t want to hit any bugs.

Questions:
Answers:

If you’re looking to verify whether an email address is valid, then VRFY will get you some of the way. I’ve found it’s useful for validating intranet addresses (that is, email addresses for internal sites). However it’s less useful for internet mail servers (see the caveats at the top of this page)

Questions:
Answers:

You may also want to check for the length – emails are a maximum of 254 chars long. I use the apache commons validator and it doesn’t check for this.

Questions:
Answers:

This is the best method:

public static boolean isValidEmail(String enteredEmail){
        String EMAIL_REGIX = "^[\\\\w!#$%&’*+/=?`{|}~^-]+(?:\\\\.[\\\\w!#$%&’*+/=?`{|}~^-]+)*@(?:[a-zA-Z0-9-]+\\\\.)+[a-zA-Z]{2,6}$";
        Pattern pattern = Pattern.compile(EMAIL_REGIX);
        Matcher matcher = pattern.matcher(enteredEmail);
        return ((!enteredEmail.isEmpty()) && (enteredEmail!=null) && (matcher.matches()));
    }

Sources:-
http://howtodoinjava.com/2014/11/11/java-regex-validate-email-address/

http://www.rfc-editor.org/rfc/rfc5322.txt

Questions:
Answers:

There don’t seem to be any perfect libraries or ways to do this yourself, unless you have to time to send an email to the email address and wait for a response (this might not be an option though). I ended up using a suggestion from here http://blog.logichigh.com/2010/09/02/validating-an-e-mail-address/ and adjusting the code so it would work in Java.

public static boolean isValidEmailAddress(String email) {
    boolean stricterFilter = true; 
    String stricterFilterString = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,4}";
    String laxString = ".+@.+\\.[A-Za-z]{2}[A-Za-z]*";
    String emailRegex = stricterFilter ? stricterFilterString : laxString;
    java.util.regex.Pattern p = java.util.regex.Pattern.compile(emailRegex);
    java.util.regex.Matcher m = p.matcher(email);
    return m.matches();
}

Questions:
Answers:

Heres my pragmatic approach, where I just want reasonable distinct blah@domain addresses using the allowable characters from the RFC. Addresses must be converted to lowercase beforehand.

public class EmailAddressValidator {

    private static final String domainChars = "a-z0-9\\-";
    private static final String atomChars = "a-z0-9\\Q!#$%&'*+-/=?^_`{|}~\\E";
    private static final String emailRegex = "^" + dot(atomChars) + "@" + dot(domainChars) + "$";
    private static final Pattern emailPattern = Pattern.compile(emailRegex);

    private static String dot(String chars) {
        return "[" + chars + "]+(?:\\.[" + chars + "]+)*";
    }

    public static boolean isValidEmailAddress(String address) {
        return address != null && emailPattern.matcher(address).matches();
    }

}

Questions:
Answers:

|*| Simple Check if email is valid :

static boolean isValidEmailAddress(String emailVar)
{
    String mylRegExpVar = "[A-Za-z0-9._%+-]{2,}+@[A-Za-z-]{2,}+\\.[A-Za-z]{2,}";

    Pattern pVar = Pattern.compile(mylRegExpVar);
    Matcher mVar = pVar.matcher(emailVar);
    return mVar.matches();
}

Questions:
Answers:

I use regex for this:

 /**
   * Check if an E-Mail Adress is valid, the rules are:
   * <p><ul>
   * <li>1: 1-64 digit: the localpart myemail(@web.de) contains only the chars
   * 'A-Za-z0-9.!#$%&'*+-/=?^_`{|}~'.
   * <li>2: 1-255 digit: It contains a '@' followed by the sub domain name wich
   * contains only the chars '0-9a-zA-Z'.
   * <li>3: 1-10 digit: Then follows a '.' followed by the main domain wich
   * contains only the chars '0-9a-zA-Z'.
   * <li>4: The full lengh of the E-Mail is under 321 chars.
   * <li>The rules are
   * mainly defined by the 'Internet Message Format' (RFC 5332).
   * </ul><p>
   *
   * @param mail - The E-Mail adress.
   * @return True if the E-Mail is valid, otherwise false.
   */
  public static boolean isValidEmail(String mail) {
    return (mail.matches("^[0-9a-zA-Z!#$%&;'*+\\-/\\=\\?\\^_`\\.{|}~]{1,64}@[0-9a-zA-Z]{1,255}\\.[a-zA-Z]{1,10}") && mail.length() <= 320);
  }

Questions:
Answers:

Absolute Validator

I named it like that cause I think nothing can break it and it accepts any domain if valid

public boolean isEmail(String email) {
    //Checks of all possible gaps
    if (email.matches("(?:[a-zA-Z0-9]+(?:\\.[a-zA-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])+)\\])")) {
        //Then checks if email address contains at least 1 alphabet in each separation
        if (email.matches(".*([a-zA-Z]).*@.*.([a-z])")) {
            // If you would do, Put here your fake-emails-checker 
            return true;
        } else {
            return false;
        }
    }
    return false;
}

Won’t be accepted

test test@gmail.com
test-test@gmail.com
test@test@gmail.com
test%test@gmail.com
test_test@gmail.com
test-test@gmail.com
test+test@gmail.com
test@gmail
test@gmail.
test@gmail..com
test@Gmail.com
test@gmail.Com
test@GMAIL.COM
1234@gmail.com
test@sub-domain.000.0 //No alphabet at the end, It sounds like IP

It won’t accept any symbolic characters such as ($,*,π,!,etc..)

ACCEPTED

test.test@gmail.com
Test.Test@gmail.com
TEST.TEST@gmail.com
test@gmail.com
TEST@gmail.com
test0@gmail.com
0test@gmail.com
test@subdomain.gmail.com
test@sub-domain.gmail.com
test@anothersub.sub-domain.gmail.com
test@sub-domain.000.com
test@sub-domain.000.0rg
test@sub-domain.000.co-om

This validator accepts both lower and uppercase characters that’s before @

If you want to accept only lowercase
then just remove A-Z from both regex expressions

Vice versa, However Email addresses are not affected by the case

This is just validating the E-mail formatting so if you’re managing an accounts system
You have to send an E-mail Verification after checking it
Also try to prevent fake emails through an for-loop with list of Domains you don’t want

String[] email_domain = email.split("@");

and start checking/looping with email_domain[1] String
with your list Array-Of-Strings DOMAINS

Android Test

if(!isEmail(emailField.getText().toString())){
    Snackbar.make(v,
            "This does not seem like an valid E-mail!",
            Snackbar.LENGTH_LONG).show();
}

Questions:
Answers:
public void EmailCheck(View v) // This is pattern method import by regular class
{
    String str = "";
    emailid = emailID.getText().toString();

    if(emailid.equalsIgnoreCase(str))
    {
        System.out.println("Please enter your email id");
     }
    else
    {
        Pattern p =Pattern.compile("[a-zA-Z0-9_.]*@[a-zA-Z]*.[a-zA-Z]*");
        Matcher m = p.matcher(emailid);
        boolean bm = m.matches();

        if(bm == true)
        {
            System.out.println("email id is valid");

        }
        else
        {
            System.out.println("email id is Invalid, Re-try again");

        }
    }
}

Questions:
Answers:

This is the simplest way to do it, without any regular expressions or Object-Armageddon.

“ABC.DEF@GHI.JKL” = 0

” ABC.DEF@GHI.JKL ” = 0 vorlaufende und nachlaufende Leerzeichen
werden unterdrueckt

“ABC_HH@T-OFFLINE.DE” = 0 Zeichen “_” und “-” duerfen vorkommen

“A@B.CD” = 0 minimal gueltige Laenge sind 6 Zeichen

“ABC.DEF@@GHI.JKL” = 11 doppeltes AT-Zeichen

“.ABC.DEF@GHI.JKL” = 5 Start auf .

“ABC.DEF@GHI.JKL.” = 16 Ende auf .

“ABCDEF@GHIJKL” = 13 Keinen Punkt gefunden

“ABC.DEF.@GHI.JKL” = 10 .@

“ABC.DEF@.GHI.JKL” = 9 @.

“ABC.DEF@7HI.JKL” = 3 Zahl nach dem AT-Zeichen

“ABC.DEF@_HI.JKL” = 3 Sonderzeichen nach dem AT-Zeichen

“ABC.DEF@GHI..JKL” = 4 keine 2 Punkte nacheinander

“ABC.DEF@” = 8 kein AT-Zeichen am Ende

“ABC.DEF@GHI.J” = 17 Top-Level-Domain muss 2 Stellen haben

null = 1 Eingabestring nicht gesetzt

” ” = 2 durch TRIM eine Laenge von 0

” A . B & C . D ” = 12 Leerzeichen innerhalb der eMail-Adresse

“(?).[!]@{&}.: ” = 12 Sonderzeichen sind nicht erlaubt

  public static int checkEMailAdresse( String pEingabe )
  {
    if ( pEingabe == null ) return 1; // Eingabe ist null

    String pruef_str = pEingabe.trim();

    int len_pruef_str = pruef_str.length();

    if ( ( len_pruef_str < 6 ) || ( len_pruef_str > 254 ) ) return 2; // Laengenbegrenzungen

    int pos_at_zeichen = -1;

    int letzter_punkt = -1;

    int zeichen_zaehler = 0;

    int akt_index = 0;

    while ( akt_index < len_pruef_str )
    {
      char aktuelles_zeichen = pruef_str.charAt( akt_index );

      if ( ( ( aktuelles_zeichen >= 'a' ) && ( aktuelles_zeichen <= 'z' ) ) || ( ( aktuelles_zeichen >= 'A' ) && ( aktuelles_zeichen <= 'Z' ) ) )
      {
        zeichen_zaehler++;
      }
      else if ( ( ( aktuelles_zeichen >= '0' ) && ( aktuelles_zeichen <= '9' ) ) || ( aktuelles_zeichen == '_' ) || ( aktuelles_zeichen == '-' ) )
      {
        if ( zeichen_zaehler == 0 ) return 3; // Zahl oder Sonderzeichen nur nach einem Zeichen hinter ABC (Teilstring darf nicht mit Zahl oder Sonderzeichen beginnen)
      }
      else if ( aktuelles_zeichen == '.' )
      {
        if ( letzter_punkt == -1 )
        {
          if ( akt_index == 0 ) return 5; // kein Beginn mit einem Punkt
        }
        else
        {
          if ( akt_index - letzter_punkt == 1 ) return 4; // keine zwei Punkte hintereinander
        }

        letzter_punkt = akt_index;

        zeichen_zaehler = 0;
      }
      else if ( aktuelles_zeichen == '@' )
      {
        if ( pos_at_zeichen == -1 )
        {
          if ( akt_index == 0 ) return 6; // kein AT-Zeichen am Anfang

          if ( akt_index > 64 ) return 7; // RFC 5321 ==> SMTP-Protokoll ==> maximale Laenge des Local-Parts sind 64 Bytes

          if ( ( akt_index + 1 ) == len_pruef_str ) return 8; // kein AT-Zeichen am Ende

          if ( akt_index - letzter_punkt == 1 ) return 10; // ungueltige Zeichenkombination ".@"

          if ( pruef_str.charAt( akt_index + 1 ) == '.' ) return 9; // ungueltige Zeichenkombination "@."

          pos_at_zeichen = akt_index;

          zeichen_zaehler = 0;
        }
        else
        {
          return 11; // kein weiteres AT-Zeichen zulassen, wenn schon AT-Zeichen gefunden wurde
        }
      }
      else
      {
        return 12; // ungueltiges Zeichen in der Eingabe gefunden 
      }

      akt_index++;
    }

    if ( letzter_punkt == -1 ) return 13; // keinen Punkt gefunden (Es muss mindestens ein Punkt fuer den Domain-Trenner vorhanden sein)

    if ( pos_at_zeichen == -1 ) return 14; // kein AT-Zeichen gefunden

    if ( letzter_punkt < pos_at_zeichen ) return 15; // der letzte Punkt muss nach dem AT-Zeichen liegen (... hier eben die negative Form, wenn der letzte Punkt vor dem AT-Zeichen stand ist es ein Fehler)

    if ( ( letzter_punkt + 1 ) == len_pruef_str ) return 16; // der letzte Punkt darf nicht am Ende liegen

    if ( ( letzter_punkt + 1 ) > ( len_pruef_str - 2 ) ) return 17; // Top-Level-Domain muss mindestens 2 Stellen lang sein.

    return 0; 
  }

Questions:
Answers:

/*to validate email id without using regex and packages
and followed by your validate symbol and domain extensions u can add …
on below try1,holly methods */

import java.util.Scanner;
public test extends Exception
{
}
public class demo extends test
{
    public static boolean try1(char s)
    {
        boolean k = false;
         char[] d={'-','_','.'};//add valid Symbols
         for(int i=0;i<d.length;i++)
         {

             if( s==d[i])
             {
               k=true; 
             }
         }

        return k; 
    }
    public static boolean holly(String s) throws test
    {
         int i=s.lastIndexOf(".");
         int j=s.length();
         String o=s.substring(i+1,j);
         boolean d=false;
         String[] g={"co","in","com","org","net"};//add domain name extenstions
        for(int k=0;k<g.length;k++)
        {
            if(g[k].equals(o))
            {

                d=true;

            }
        }

        if(d==false)
        {
            throw new test();
        }
        return d;

    }
    public static void main(String[] args)
    {
        try
        {
          Scanner s=new Scanner(System.in);
          System.out.println("enter the email no of.id ");
           int n=s.nextInt();
           String[] id=new String[n];
            for(int i=0;i<n;i++)
             {
                 int l=0;
               id[i]=s.next();
               int c=1,c1=0;
                for(int k=c1;k<c;k++)
                    {
                        String b=id[k].toLowerCase();
                        boolean l1=holly(b);
                        if(id[k]==b)
                            {
                            System.out.println(b);
                            }
                    }c1++;
                      int x = 0;
                int count=0,count1=0;
                 char[] a=id[i].toCharArray();
                int g=0;
                 for(int j=0;j<a.length;j++)
                     {

                       if(Character.isLetterOrDigit(a[j]))
                        {
                         }
                       else     
                           {
                              if(a[j]=='@')
                               {
                                count++; 
                             }                       

                         else  
                             {
                              if(Character.isLetterOrDigit(a[j+1]))
                              {

                              }
                              else
                                  throw new test();
                             if(count==1)
                                {
                                  if(a[j]=='.')
                                   {
                                     l++; 
                                    }
                                 }
                              boolean z=try1(a[j]);

                                if(z==true)
                                {
                                }
                                else
                                    g=1;


                               }
                             }

                     }
                                     if(g==1)
                                       {
                                           throw new test();
                                       }
                                    if(count==0)
                                        {
                                            throw new test(); 
                                        }
                                    else if(count==2)
                                    {
                                        throw new test(); 
                                    }



                                    if(l==0)
                                        {
                                            throw new test(); 
                                        }
                    c++;


             }

    }
        catch(test ex)
        {
            System.out.println("enter the id is not correct");
        }
    }
}

Questions:
Answers:

I have made a class earlier for an Android Application you might find it useful

package com.amit.parking.parking.Analytics;

import android.widget.EditText;

import java.util.ArrayList;

/**
 * Created by Android Developer on 3/1/2015.
 */
public class EmailValidator {

private static String email;
private static int count = 0;


private static final Character [] alphabeticSmall = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
private static final Character [] alphabeticLarge = {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
private static final Character [] forbiddenSymbols = {
        '\'','^','[',',','!','#','$','%','&','*','+','/','=',
        '?','`','{','|','}','~',']','(',')',':','\\',' ','÷'
        ,'×','؛','<','>','|',';','"','₩','¥','£','€','`','°'
        ,'•','○','●','□','■','♤','♡','♢','♧','☆','¤','《',
        '》','¡','¿'
};

private String[] validEnds = {"ac", "ad", "ae", "aero", "af", "ag", "ai",
        "al", "am", "an", "ao", "aq", "ar", "arpa", "as", "asia", "at", "au",
        "aw", "ax", "az", "ba", "bb", "bd", "be", "bf", "bg", "bh", "bi", "biz",
        "bj", "bm", "bn", "bo", "br", "bs", "bt", "bv", "bw", "by", "bz", "ca",
        "cat", "cc", "cd", "cf", "cg", "ch", "ci", "ck", "cl", "cm", "cn", "co",
        "com", "coop", "cr", "cu", "cv", "cx", "cy", "cz", "de", "dj", "dk",
        "dm", "do", "dz", "ec", "edu", "ee", "eg", "er", "es", "et", "eu", "fi",
        "fj", "fk", "fm", "fo", "fr", "ga", "gb", "gd", "ge", "gf", "gg", "gh",
        "gi", "gl", "gm", "gn", "gov", "gp", "gq", "gr", "gs", "gt", "gu", "gw",
        "gy", "hk", "hm", "hn", "hr", "ht", "hu", "id", "ie", "il", "im", "in",
        "info", "int", "io", "iq", "ir", "is", "it", "je", "jm", "jo", "jobs",
        "jp", "ke", "kg", "kh", "ki", "km", "kn", "kp", "kr", "kw", "ky", "kz",
        "la", "lb", "lc", "li", "lk", "lr", "ls", "lt", "lu", "lv", "ly", "ma",
        "mc", "md", "me", "mg", "mh", "mil", "mk", "ml", "mm", "mn", "mo",
        "mobi", "mp", "mq", "mr", "ms", "mt", "mu", "museum", "mv", "mw", "mx",
        "my", "mz", "na", "name", "nc", "ne", "net", "nf", "ng", "ni", "nl",
        "no", "np", "nr", "nu", "nz", "om", "org", "pa", "pe", "pf", "pg", "ph",
        "pk", "pl", "pm", "pn", "pr", "pro", "ps", "pt", "pw", "py", "qa", "re",
        "ro", "rs", "ru", "rw", "sa", "sb", "sc", "sd", "se", "sg", "sh", "si",
        "sj", "sk", "sl", "sm", "sn", "so", "sr", "st", "su", "sv", "sy", "sz",
        "tc", "td", "tel", "tf", "tg", "th", "tj", "tk", "tl", "tm", "tn", "to",
        "tp", "tr", "travel", "tt", "tv", "tw", "tz", "ua", "ug", "uk", "um",
        "us", "uy", "uz", "va", "vc", "ve", "vg", "vi", "vn", "vu", "wf", "ws",
        "ye", "yt", "yu", "za", "zm", "zw"};

private static ArrayList<Character> correctSmallLetters;
private static ArrayList<Character> correctLargeLetters;
private static ArrayList<Character> forbiddenSymbolsArray;

private static CharSequence cleanText = "";
private static CharSequence [] cleanTextToArray;

private static int dynamicArraySize = 1;
private static Character [] dynamicArray;

public EmailValidator(String email){
    this.email = email;
    correctSmallLetters = new ArrayList<>();
    correctLargeLetters = new ArrayList<>();
    forbiddenSymbolsArray = new ArrayList<>();
}

public static boolean isEmailCharactersValidated(){
        if(equalsGetSmallLetters() || equalsGetLargeLetters()){
            return true;
        }
        return false;
}

private static boolean equalsGetSmallLetters() {
    count = 0;
    while(count < email.length()) {
        for (int smallLetterIndex = 0; smallLetterIndex < alphabeticSmall.length; smallLetterIndex++) {

            if(email.charAt(count) == alphabeticSmall[smallLetterIndex]){
                correctSmallLetters.add(email.charAt(count));
            }
        }
        count++;
    }
    count = 0;
    return correctSmallLetters.size() > 0;
}

private static boolean equalsGetLargeLetters() {
    count = 0;
    while(count < email.length()) {
        for (int largeLetterIndex = 0; largeLetterIndex < alphabeticLarge.length; largeLetterIndex++) {

            if(email.charAt(count) == alphabeticLarge[largeLetterIndex]){
                correctLargeLetters.add(email.charAt(count));
            }
        }
        count++;
    }
    count = 0;
    return correctLargeLetters.size() > 0;
}

public static boolean isEmailHasForbiddenSymbols(){
    count = 0;
    while(count < email.length()) {
        for (int symbolIndex = 0; symbolIndex < forbiddenSymbols.length; symbolIndex++) {

            if(email.charAt(count) == forbiddenSymbols[symbolIndex]){
                forbiddenSymbolsArray.add(email.charAt(count));
                //addToTheDynamicArray(email.charAt(count));
            }

        }
        count++;
    }
    count = 0;

    return forbiddenSymbolsArray.size() > 0;
}

/* THIS IS JUST A TEST METHOD... */
private static void addToTheDynamicArray(Character c){

    dynamicArray = new Character[dynamicArraySize];

    if (dynamicArray.length == 1) {
        dynamicArray[dynamicArraySize -1] = c;
        dynamicArraySize++;
    } else {
        dynamicArray = new Character[dynamicArraySize];
        dynamicArray[dynamicArraySize -1] = c;
        dynamicArraySize++;
    }
}

public static void removeForbiddenSymbols(EditText etEmail){

    try {
        count = 0;
        while (count < etEmail.getText().toString().length()) {
            for (int symbolIndex = 0; symbolIndex < forbiddenSymbols.length; symbolIndex++) {

                if (etEmail.getText().toString().charAt(count) == forbiddenSymbols[symbolIndex]) {
                    etEmail.setText(etEmail.getText().toString().replace(String.valueOf(etEmail.getText().toString().charAt(count)), ""));
                }
            }
            count++;
        }
        count = 0;
    }catch (Exception ignored) { }
}

public boolean isEmailCorrect() {return checkForAts() && checkForDots();}

private boolean checkForAts() {
    int atsCount = 0;
    ArrayList<Character> ats = new ArrayList<>();

    while(atsCount < email.length()){
        if(email.charAt(atsCount) == '@'){
            ats.add(email.charAt(atsCount));
        }
        atsCount++;
    }

    return ats.size() == 1;
}

public boolean isEmailHasValidEnd(){
    int validEndsCount = 0;
    int emailCharsCount = 0;
    while (emailCharsCount < email.length()){

        while(validEndsCount < validEnds.length){


            if(email.endsWith(validEnds[validEndsCount]))
                return true;

            validEndsCount++;
        }

        emailCharsCount++;
    }


    return false;
}

private boolean checkForDots() {
    int dotsCount = 0;
    ArrayList<Character> dots = new ArrayList<>();

    while(dotsCount < email.length()){
        if(email.charAt(dotsCount) == '.'){
            dots.add(email.charAt(dotsCount));
        }
        dotsCount++;
    }

    return dots.size() == 1;
}

public boolean isValidEmailAddress(String email) {
    String ePattern = "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$";
    java.util.regex.Pattern p = java.util.regex.Pattern.compile(ePattern);
    java.util.regex.Matcher m = p.matcher(email);
    return m.matches();
}

}

Leave a Reply

Your email address will not be published. Required fields are marked *