Валидация номера телефона java

In this article, we’ll learn how to validate mobile phone number of different country’s format using Java Regex (Regular Expressions)

Phone Number Format

A typical mobile phone number has following component:

+<country_code> <area_code> <subscriber_number>

Where depending on the country,

• country_code is somewhere between 1 to 3 digits
• area_code and subscriber_number combined is somewhere between 8 to 11 digits

If you simply require a regex to match all country format then here it is,

"^(\+\d{1,3}( )?)?((\(\d{1,3}\))|\d{1,3})[- .]?\d{3,4}[- .]?\d{4}$"

If you want to know **how we came up with this regex?** then please read this full article.

1. Regex to match 10 digit Phone Number with No space

This is simplest regex to match just 10 digits. We will also see here how to use regex to validate pattern:

String regex = "^\d{10}$";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher("9876543210");
matcher.matches(); // returns true if pattern matches, else returns false

Let’s break the regex and understand,

• ^ start of expression
• d{10} is mandatory match of 10 digits without any space
• $ end of expression

You can make regex more flexible to match between 8 to 11 digits phone number with no space, using this regex:

String noSpaceRegex = "^\d{8,11}$";

2. Regex to match 10 digit Phone Number with WhiteSpaces, Hyphens or No space

String spacesAndHyphenRegex = "^(\d{3}[- ]?){2}\d{4}$";

Let’s break the regex and understand,

• ^ start of expression
• d{3} is mandatory match of 3 digits
• [- ]? is optional match of whitespace or hyphen after 3 digits
• {2} is to repeat the above match d{3}[- ]? two times becomes total 6 digits
• d{4} is mandatory match of last 4 digits
• $ end of expression

3. Regex to match 10 digit Phone Number with Parentheses

String parenthesesRegex = "^((\(\d{3}\))|\d{3})[- ]?\d{3}[- ]?\d{4}$";

Let’s break the regex and understand,

• ^ start of expression
• (\(\d{3}\))|\d{3}) is mandatory match of 3 digits with or without parentheses
• [- ]? is optional match of whitespace or hyphen after after 3 digits
• \d{3}[- ]? is mandatory match of next 3 digits followed by whitespace, hyphen or no space
• \d{4} is mandatory match of last 4 digits
• $ end of expression

4. Regex to match 10 digit Phone number with Country Code Prefix

This regex is combined with regex to include parenthesis

String countryCodeRegex = "^(\+\d{1,3}( )?)?((\(\d{3}\))|\d{3})[- .]?\d{3}[- .]?\d{4}$";

Let’s break the regex and understand,

• ^ start of expression
• (\+\d{1,3}( )?)? is optional match of country code between 1 to 3 digits prefixed with + symbol, followed by space or no space.
• ((\(\d{3}\))|\d{3})[- .]?\d{3}[- .]?\d{4} is mandatory match of 10 digits with or without parenthesis, followed by whitespace, hyphen or no space
• $ end of expression

5. Regex to match Phone Number of All Country Formats

Before we start defining a regex, let’s look at some of the country phone number formats:-

Abkhazia    +995 442 123456
Afghanistan +93 30 539-0605
Australia   +61 2 1255-3456
China       +86 (20) 1255-3456
Germany     +49 351 125-3456
Indonesia   +62 21 6539-0605
Iran        +98 (515) 539-0605
Italy       +39 06 5398-0605
New Zealand +64 3 539-0605
Philippines +63 35 539-0605
Singapore   +65 6396 0605
Thailand    +66 2 123 4567
UK          +44 141 222-3344
USA         +1 (212) 555-3456
Vietnam     +84 35 539-0605

Let’s extract some information from these numbers:-

1. Country Code prefix starts with ‘+’ and has 1 to 3 digits
2. Last part of the number, also known as subscriber number is 4 digits in all of the numbers
3. Most of the countries have 10 digits phone number after excluding country code. A general observation is that all countries phone number falls somewhere between 8 to 11 digits after excluding country code.

Let’s see again on regex from previous example to validate country code:

String countryCodeRegex = "^(\+\d{1,3}( )?)?((\(\d{3}\))|\d{3})[- .]?\d{3}[- .]?\d{4}$"l

The above regex is to match 10 digit phone numbers, Let’s make some changes in this and make it more flexible to match 8 to 11 digits phone numbers:-

Regex to Match All Country Formats

String allCountryRegex = "^(\+\d{1,3}( )?)?((\(\d{1,3}\))|\d{1,3})[- .]?\d{3,4}[- .]?\d{4}$";

Let’s break the regex and understand,

• ^ start of expression
• (\+\d{1,3}( )?)? is optional match of country code between 1 to 3 digits prefixed with ‘+’ symbol, followed by space or no space.
• ((\(\d{1,3}\))|\d{1,3} is mandatory group of 1 to 3 digits with or without parenthesis followed by hyphen, space or no space.
• \d{3,4}[- .]? is mandatory group of 3 or 4 digits followed by hyphen, space or no space
• \d{4} is mandatory group of last 4 digits
• $ end of expression

6. Regex to match Phone Number of Specific Country Format

As you saw in the previous example that we have to add some flexibility in our regex to match all countries’ formats. If you want more strict validation of specific country format then here are examples of India and Singapore Phone number regex pattern:

String indiaRegex = "^(\+\d{2}( )?)?((\(\d{3}\))|\d{3})[- .]?\d{3}[- .]?\d{4}$";
String singaporeRegex = "^(\+\d{2}( )?)?\d{4}[- .]?\d{4}$";

Regular Expressions (RegEx) are a powerful tool and help us match patterns in a flexible, dynamic and efficient way, as well as to perform operations based on the results.

In this tutorial, we’ll take a look at how to validate an phone number in Java, using Regular Expressions (RegEx).

If you’d like to read more about Regular Expressions and the regex package, read out Guide to Regular Expressions in Java!

Validating Phone Numbers in Java with RegEx

Phone numbers aren’t easy to validate, and they’re notoriously flexible. Different countries have different formats, and some countries even use multiple formats and country codes.

To validate a phone number with Regular Expressions, you’ll have to make a couple of assertions that generalize well to phone numbers, unless you want to write many different expressions and validate through a list of them.

These assertions will depend on your project, its localization and the countries you wish to apply it to — but keep in mind that with an international project, you might have to be loose on the restrictions lest you end up not allowing a valid phone number through to the system.

For standard US phone number validation, we can use the lengthy, fairly robust expression of:

^(+d{1,2}s)?(?d{3})?[s.-]?d{3}[s.-]?d{4}$

The 4 groups in the expression correspond to the country code, area number, subscriber number and extension. The expressions in-between the groups are there to handle a wide-variety of different formatting you an see:

123-456-7890
(123) 456-7890
etc...

You could also build a different expression by imposing a set of rules for groups (depending on the country) and the formats. you may expect coming in.

You could technically go as simple as checking whether there’s 10 numbers in the string (12 if you count the country code as well), and it should be able to validate some of the phone numbers, but such simplicity would require additional validation either on the front-end, or the ability to adapt if an accepted phone number isn’t actually valid:

Pattern simplePattern = Pattern.compile("^\+\d{10,12}$");
Pattern robustPattern = Pattern.compile("^(\+\d{1,2}\s)?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}$");

String phoneNumber = "+12 345 678 9012";

Matcher simpleMatcher = simplePattern.matcher(phoneNumber);
Matcher robustMatcher = robustPattern.matcher(phoneNumber);

if (simpleMatcher.matches()) {
    System.out.println(String.format("Simple Pattern matched for string: %s", phoneNumber));
}
if(robustMatcher.matches()) {
    System.out.println(String.format("Robust Pattern matched for string: %s", phoneNumber));
}

The first matcher, here, will first and foremost have issues with the whitespaces present in the string, and would match otherwise. The robust pattern doesn’t have any issues with this, though:

Robust Pattern matched for string: +12 345 678 9012

The robust matcher here would be able to match for several formats:

Pattern robustPattern = Pattern.compile("^(\+\d{1,2}\s)?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}$");

List<String> phoneNumbers = List.of(
        "+12 345 678 9012",
        "+123456789012",
        "345.678.9012",
        "345 678 9012"
);

for (String number : phoneNumbers) {
    Matcher matcher = robustPattern.matcher(number);
    if(matcher.matches()) {
        System.out.println(String.format("Robust Pattern matched for string: %s", number));
    }
}

This would result in:

Robust Pattern matched for string: +12 345 678 9012
Robust Pattern matched for string: 345.678.9012
Robust Pattern matched for string: 345 678 9012

Combining Multiple Regular Expressions

Regular Expressions tend to get messy and long. At a certain point, they become cluttered enough that you can’t readily change them or interpret them.

Instead of having a single, universal, robust Regular Expression that encompasses all edge-cases, countries, etc. — you can opt to use several different patterns that will reasonably cover the phone numbers coming in. To make things simpler — you can chain these expressions via the | operator, to check whether the phone number matches any of the patterns:

Pattern robustPattern = Pattern
        .compile(
                // Robust expression from before
                "^(\+\d{1,2}\s)?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}$"
                // Area code, within or without parentheses,
                // followed by groups of 3-4 numbers with or without hyphens
                + "| ((\(\d{3}\) ?)|(\d{3}-))?\d{3}-\d{4}"
                // (+) followed by 10-12 numbers
                + "|^\+\d{10,12}"
);

List<String> phoneNumbers = List.of(
        "+12 345 678 9012",
        "+123456789012",
        "345.678.9012",
        "345 678 9012"
);

for (String number : phoneNumbers) {
    Matcher matcher = robustPattern.matcher(number);
    if(matcher.matches()) {
        System.out.println(String.format("Pattern matched for string: %s", number));
    }
}

This results in:

Pattern matched for string: +12 345 678 9012
Pattern matched for string: +123456789012
Pattern matched for string: 345.678.9012
Pattern matched for string: 345 678 9012

Conclusion

Phone numbers are tricky — that’s a fact. Regular Expressions are a really versatile and powerful tool and can address the issue of validating phone numbers, but it is admittedly a messy process.

Certain countries follow different standards, while some countries adopt and use multiple formats at the same time, making it hard to write a general-purpose expression to match phone numbers universally.

In this short article, we’ve taken a look at how to match phone numbers with Regular Expressions in Java, with a few different expressions.

Как проверить номер телефона в Java (регулярное выражение)

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ValidatePhoneNumber {
  public static void main(String[] argv) {

      String sPhoneNumber = "605-8889999";
      //String sPhoneNumber = "605-88899991";
      //String sPhoneNumber = "605-888999A";

      Pattern pattern = Pattern.compile("\d{3}-\d{7}");
      Matcher matcher = pattern.matcher(sPhoneNumber);

      if (matcher.matches()) {
          System.out.println("Phone Number Valid");
      }
      else
      {
          System.out.println("Phone Number must be in the form XXX-XXXXXXX");
      }
 }
}