Mobile Number Validation in Java

Each country has its own mobile number format. It is difficult to validate mobile numbers for each country. So, in this section, we will learn how to validate mobile numbers in Java using regular expression and Google's libphonenumber API. In this section, we will create Java programs to validate Indian and US number formats only. On the basis of these two countries, we can validate mobile numbers for other countries by making some modifications in the code.

US Mobile Numbers Formats

1234567890
123-456-7890
123-456-7890 x1234
123-456-7890 ext1234
(123)-456-7890
123.456.7890
123 456 7890

Indian Mobile Number Formats

9123124123
09123124123
+919123124123
+91-9123124123
+91 9222222222
+7666 999 999

How to Validate Mobile Number?

There are two ways to validate mobile number in Java:

Using Regular Expression
- Using Pattern Class
- Using String.matches() Method
Using Google libphonenumber API

Using Regular Expression

Using Pattern Class

The Pattern class belongs to java.util.regex package. It provides the compile() method that compiles the given regular expression into a pattern. It accepts a string of regular expressions to be compiled.

Syntax:

Another method is provided by the class is matcher() which creates a matcher that will match the given input against this pattern. It accepts character sequence to be matched.

Syntax:

Another class that we have used in the following program is the Matcher class. It is a final class that that performs match operations on a character sequence by interpreting a Pattern. Note that a matcher is created from the pattern.

The class provides the find() method that finds the next subsequence of the input sequence that matches the pattern. It starts at the beginning of this matcher's region, or if a previous invocation of the method was successful. It returns true, if and only if a subsequence of the input sequence matches this matcher's pattern.

The group() method of the class returns the input subsequence matched by the previous match.

The equals(obj) method of the String class compares the string to the specified object and returns true if and only if the argument is not null and is a string object.

MobileNumberValidation.java

import java.util.regex.*;
public class MobileNumberValidation
{
//function to check if the mobile number is valid or not    
public static boolean isValidMobileNo(String str)
{
//(0/91): number starts with (0/91)
//[7-9]: starting of the number may contain a digit between 0 to 9
//[0-9]: then contains digits 0 to 9
Pattern ptrn = Pattern.compile("(0/91)?[7-9][0-9]{9}");
//the matcher() method creates a matcher that will match the given input against this pattern
Matcher match = ptrn.matcher(str);
//returns a boolean value
return (match.find() && match.group().equals(str));
}
//driver code
public static void main(String args[])
{
//mobile number to check    
String str = "9800088899";
//method calling
if (isValidMobileNo(str))
System.out.println("It is a valid mobile number.");	
else
System.out.println("Entered mobile number is invalid.");	
}
} 

Output:

It is a valid mobile number.

Using String.matches() Method

In the following program, we have used the matches() method of the Java String class. It tells that the string matches with regular expression or not.

Syntax:

The method accepts a parameter of String type known as a regular expression and returns a Boolean value. It throws PatternSyntaxException if regular expression syntax is invalid.

MobileNumberValidation1.java

public class MobileNumberValidation1
{
//driver code	
public static void main(String args[]) 
{
//calling method and validate different formats	
System.out.println("1234567890 : " + validateNumber("1234567890"));
System.out.println("1234 567 890 : " + validateNumber("1234 567 890")); 
System.out.println("123 456 7890 : " + validateNumber("123 456 7890"));
System.out.println("123-567-8905 : " + validateNumber("123-567-8905"));
System.out.println("9866-767-545 : " + validateNumber("9866-767-545"));
System.out.println("9866.767.545 : " + validateNumber("9866.767.545"));
System.out.println("9866-767.545 : " + validateNumber("9866-767.545"));
System.out.println("123-456-7890 ext4444 : " + validateNumber("123-456-7890 ext4444"));
System.out.println("123-456-7890 x4444 : " + validateNumber("123-456-7890 x4444"));
}
//function validates mobile numbers 
private static boolean validateNumber(String mobNumber) 
{
//validates phone numbers having 10 digits (9998887776)
if (mobNumber.matches("\\d{10}"))
return true;
//validates phone numbers having digits, -, . or spaces
else if (mobNumber.matches("\\d{3}[-\\.\\s]\\d{3}[-\\.\\s]\\d{4}"))
return true;
else if (mobNumber.matches("\\d{4}[-\\.\\s]\\d{3}[-\\.\\s]\\d{3}"))
return true;
//validates phone numbers having digits and extension (length 3 to 5)
else if (mobNumber.matches("\\d{3}-\\d{3}-\\d{4}\\s(x|(ext))\\d{3,5}"))
return true;
//validates phone numbers having digits and area code in braces
else if (mobNumber.matches("\\(\\d{3}\\)-\\d{3}-\\d{4}"))
return true;
else if (mobNumber.matches("\\(\\d{5}\\)-\\d{3}-\\d{3}"))
return true;
else if (mobNumber.matches("\\(\\d{4}\\)-\\d{3}-\\d{3}"))
return true;
//return false if any of the input matches is not found
else
return false;
}
}

Output:

If we go with the above approach, we need to do lots of testing work to cover all the cases. But if we have some API that provides this functionality with proper testing that would be good to use in our application.

Using Google libphonenumber API

The libphonenumber is an open-source library provided by Google. It provides functionalities such as parsing, formatting, validating, and storing international phone numbers. The Java version of the library is optimized for running on smartphones and is used by the Android framework since 4.0.

The API supports the following types of numbers:

FIXED_LINE
FIXED_LINE_OR_MOBILE
MOBILE
PAGER
PERSONAL_NUMBER
PREMIUM_RATE
SHARED_COST
TOLL_FREE
UAN
UNKNOWN
VOICEMAIL
VOIP

Note: Before running the program, ensure that libphonenumber-8.12.24.jar file is added to the project.

In the following program, we have used PhoneNumberUtil class that provides getInstance(), isValidNumber() and parse() method.

MobileNumberValidation2.java

import com.google.i18n.phonenumbers.NumberParseException;
import com.google.i18n.phonenumbers.PhoneNumberUtil;
import com.google.i18n.phonenumbers.Phonenumber.PhoneNumber;
public class MobileNumberValidation2
{
public static void main(String args[]) throws NumberParseException 
{
System.out.println("US Number Formats: ");
//creating an array of US number formats
String[] usFormats = { "(541) 777-3777", "+1-541-999-3111", "1-541-788-5010", "001-541-876-9090", "181 541 745 9090" };
//method calling to validate numbers
validateNumber(usFormats, "US");
System.out.println("\nIndian Number Formats: ");
//creating an array of Indian number formats
String[] indiaNumberFormats = { "+91 9999999999", "8888888888", "+91-3333333333", "+91 9222222222", "+91 8888 999 777", "+7666 999 999" };
//method calling to validate numbers
validateNumber(indiaNumberFormats, "IN"); 
}
//function that validates mobile numbers
private static void validateNumber(String[] phoneNumbers, String country) throws NumberParseException 
{
//PhoneNumberUtil class provides formatting, parsing and validation
//getInstance() method is loaded with all phone number metadata
PhoneNumberUtil numberUtil = PhoneNumberUtil.getInstance();
//for each loop iterate over the number formats array
for (String number : phoneNumbers) 
{
//the parse() method parses a string and country and returns it as a phone number in proto buffer format	
PhoneNumber phoneNumber = numberUtil.parse(number, country);
//tests whether a phone number matches a valid pattern or not
boolean isValid = numberUtil.isValidNumber(phoneNumber);
if (isValid) 
{
//prints if a number is a valid number
System.out.println(number + " is a valid mobile number.");
} 
else
{
//prints if the number is invalid	
System.out.println(number + " is a not valid mobile number.	");
}
}
}
}

Output: