IP Address Regex Java Validator

What is an IP Address?

An IP (Internet Protocol) Address is a unique identifier for devices on a network. It exists in two formats:

• IPv4: 4 decimal octets (e.g. 192.168.0.1)

• IPv6: 8 hexadecimal blocks (e.g. 2001:0db8:85a3:0000:0000:8a2e:0370:7334)

  
  

Correct validation ensures data routing and device identification works seamlessly.

IP Address Regex Patterns

IPv4 Regex Pattern:

^((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.|$)){4}$

Explanation:

• Ensures four blocks of numbers

• Each block ranges from 0–255

• Periods separate blocks
  
  

Let’s break down how this works for IPv4 addresses:

• 25[0-5]: Matches numbers 250–255

• 2[0-4]\d: Matches numbers 200–249

• 1\d\d: Matches numbers 100–199

• [1-9]?\d: Matches numbers 0–99 (handles single or double digits, ensuring no leading zeroes except for 0 itself)

Each of these patterns ensures that every octet (the value between the dots) is a valid number between 0 and 255. The groups are separated by literal periods, and the pattern as a whole enforces exactly four such octets, just as required by the IPv4 standard.

IPv6 Regex Pattern:

^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$

Explanation:

• Ensures 8 groups of 1–4 hex digits

• Groups are separated by colons

JavaScript Example: Validating IP Addresses

If you want to validate IP addresses in JavaScript, regular expressions are your best friend. Here’s a quick guide on how to check both IPv4 and IPv6 addresses using regex.

// Regular expressions for IPv4 and IPv6
const ipv4Pattern = /^((25[0-5]2[0-4]\d1\d\d[1-9]?\d)(\.$)){4}$/;
const ipv6Pattern = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
/**

Validates whether a given string is a valid IPv4 or IPv6 address.
@param {string} ip - IP address to validate.
@returns {string} - The type of IP address or 'Invalid IP'.
*/
function validateIPAddress(ip) {
if (ipv4Pattern.test(ip)) {
return "Valid IPv4 Address";
}
if (ipv6Pattern.test(ip)) {
return "Valid IPv6 Address";
}
return "Invalid IP";
}

// Try it out with a few examples:
console.log(validateIPAddress("127.0.0.1"));                       // Valid IPv4 Address
console.log(validateIPAddress("2001:0db8:85a3:0000:0000:8a2e:0370:7334")); // Valid IPv6 Address
console.log(validateIPAddress("300.168.0.1"));                     // Invalid IP

This approach ensures that only properly formatted and valid ranges for both IPv4 and IPv6 pass your validation. Handy for frontend forms, backend validations, or quick command-line utilities.

Java Code Example (IPv4)

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

public class IPv4Validator {
public static void main(String[] args) {
String ip = "192.168.1.1";
String ipv4Regex = "^((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.|$)){4}$";
    Pattern pattern = Pattern.compile(ipv4Regex);
    Matcher matcher = pattern.matcher(ip);

    if (matcher.matches()) {
        System.out.println("Valid IPv4 Address");
    } else {
        System.out.println("Invalid IPv4 Address");
    }
}

}

Common Validation Scenarios

Test Case 1

• Input: 000.12.12.034

• Output: true

Test Case 2

• Input: 121.234.12.12

• Output: true

Test Case 3

• Input: 000.12.234.23.23

• Output: false

Test Case 4

• Input: I.Am.not.an.ip

• Output: false
  
  

Java Code Example (IPv6)

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

public class IPv6Validator {
public static void main(String[] args) {
String ip = "2001:0db8:85a3:0000:0000:8a2e:0370:7334";
String ipv6Regex = "^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$";
    Pattern pattern = Pattern.compile(ipv6Regex);
    Matcher matcher = pattern.matcher(ip);

    if (matcher.matches()) {
        System.out.println("Valid IPv6 Address");
    } else {
        System.out.println("Invalid IPv6 Address");
    }
}

}

Sample Inputs

Valid IPv4:

• 127.0.0.1

• 192.168.100.100

  
  

Invalid IPv4:

• 256.300.888.1

• 192.168.1

  
  

Valid IPv6:

• 2001:0db8:85a3:0000:0000:8a2e:0370:7334

• fe80::1ff:fe23:4567:890a

  
  

Invalid IPv6:

• 2001:db8:85a3::8a2e:370g:7334 (invalid characters)

• 1234:5678:90ab (too short)

Experiment with these examples and test cases to ensure your regex is working as intended. Accurate validation up front helps prevent downstream errors and keeps your apps running smoothly.

Additional Examples:

These examples cover a range of typical cases you'll encounter—spanning valid and invalid IPv4 and IPv6 addresses, as well as edge cases like extra segments or non-numeric input. Use them to test your validation logic or as reference points for building robust IP address filters.

Performance Considerations

Time Complexity:
Validating an IP address using these regular expressions operates in linear time, or O(N), where N is the length of the input string. The pattern scans each character once, making it efficient even for longer addresses.

Space Complexity:
The space usage remains constant at O(1), as the regex engine doesn't require additional memory that scales with input size—just a fixed amount for tracking matches and capturing groups.

This makes regex-based IP validation both speedy and lightweight for everyday applications.

Use Cases

• Login Attempts Tracking: Log IPs for failed or successful logins.

• Geo IP Processing: Map user locations based on IPs.

• API Whitelisting: Validate incoming IPs against allow-lists.

• Form Validation: Accept only correctly formatted IPs in admin panels or dashboards.

Pro Tips

• Use separate regex for IPv4 and IPv6 instead of a merged pattern to avoid confusion.

• Clean input before validation (e.g., trim whitespace).

• Don’t rely solely on regex—after format validation, use InetAddress.getByName() to confirm routable status.

• Avoid trusting user-submitted IPs for security-sensitive operations like geo-location or access control.

• Store IPs in consistent format (either full or shortened IPv6) in databases.

• Use Java Regex Tester to test and fine-tune custom variations (e.g., CIDR ranges).

Combine with These Tools

• MAC Address Regex Java Validator – for validating hardware addresses

• Java Regex Tester – for custom regex testing

• Email Regex Java Validator – verify email formats from users

• Base64 Encoder – encode IP addresses if needed for API headers

• Token Generator – generate secure tokens to map with IPs