root@generate-random:~/ip-addresses/java$ _

Generate Random IP Addresses in Java

Complete code tutorial with examples and best practices

PHP JavaScript Python

Java

C# C++ Ruby Go

[ Code Example - Quick Summary ]

Language: Java

What: Generate random IPv4 and IPv6 addresses in Java using Random and InetAddress. Includes validation, RFC 1918 private ranges, and integration with JavaFaker library.

Try it: Use our interactive Ip-addresses generator or integrate this code into your Java application.

Generate random IPv4 and IPv6 addresses in Java using Random and InetAddress. Includes validation, RFC 1918 private ranges, and integration with JavaFaker library. Looking for other languages? Check our code examples in PHP , JavaScript , Python , C# , C++ , Ruby and Go or use our interactive web generator.

Java Code Example

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class IpAddressGenerator {
    private static final Random random = new Random();

    // Generate random IPv4 address
    public static String randomIpv4() {
        return String.format("%d.%d.%d.%d",
            random.nextInt(256),
            random.nextInt(256),
            random.nextInt(256),
            random.nextInt(256)
        );
    }

    // Generate random private IPv4 (RFC 1918)
    public static String randomPrivateIpv4() {
        int range = random.nextInt(3);
        switch (range) {
            case 0: // 10.0.0.0/8
                return String.format("10.%d.%d.%d",
                    random.nextInt(256),
                    random.nextInt(256),
                    random.nextInt(256));
            case 1: // 172.16.0.0/12
                return String.format("172.%d.%d.%d",
                    random.nextInt(16) + 16,
                    random.nextInt(256),
                    random.nextInt(256));
            default: // 192.168.0.0/16
                return String.format("192.168.%d.%d",
                    random.nextInt(256),
                    random.nextInt(256));
        }
    }

    // Generate random public IPv4
    public static String randomPublicIpv4() {
        String ip;
        do {
            ip = randomIpv4();
        } while (isPrivateIp(ip));
        return ip;
    }

    // Check if IP is private
    public static boolean isPrivateIp(String ip) {
        return ip.matches("^10\\..*") ||
               ip.matches("^172\\.(1[6-9]|2[0-9]|3[01])\\..*") ||
               ip.matches("^192\\.168\\..*") ||
               ip.matches("^127\\..*") ||
               ip.matches("^0\\..*");
    }

    // Generate random IPv6 address
    public static String randomIpv6() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 8; i++) {
            if (i > 0) sb.append(":");
            sb.append(String.format("%04x", random.nextInt(0x10000)));
        }
        return sb.toString();
    }

    // Generate IPv4 with CIDR notation
    public static String randomIpv4WithCidr(int minCidr, int maxCidr) {
        String ip = randomIpv4();
        int cidr = random.nextInt(maxCidr - minCidr + 1) + minCidr;
        return String.format("%s/%d", ip, cidr);
    }

    // Validate IPv4 address using InetAddress
    public static boolean isValidIp(String ip) {
        try {
            InetAddress.getByName(ip);
            return true;
        } catch (UnknownHostException e) {
            return false;
        }
    }

    // Generate multiple IP addresses
    public static List<String> generateIpAddresses(int count, String type) {
        List<String> ips = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            ips.add(type.equals("ipv6") ? randomIpv6() : randomIpv4());
        }
        return ips;
    }

    // Using JavaFaker library (add dependency: com.github.javafaker:javafaker:1.0.2)
    // import com.github.javafaker.Faker;
    // Faker faker = new Faker();
    // String ipv4 = faker.internet().ipV4Address();
    // String ipv6 = faker.internet().ipV6Address();
    // String privateIp = faker.internet().privateIpV4Address();
    // String publicIp = faker.internet().publicIpV4Address();

    public static void main(String[] args) {
        System.out.println("Random IPv4: " + randomIpv4());
        System.out.println("Private IPv4: " + randomPrivateIpv4());
        System.out.println("Public IPv4: " + randomPublicIpv4());
        System.out.println("IPv6: " + randomIpv6());
        System.out.println("IPv4 with CIDR: " + randomIpv4WithCidr(8, 32));
        System.out.println("Batch: " + String.join(", ", generateIpAddresses(5, "ipv4")));
        System.out.println("Is valid: " + isValidIp("192.168.1.1"));
    }
}

[EXPLANATION]

This implementation uses Random.nextInt(256) for generating octets and String.format() for formatting. Java's InetAddress class provides validation but doesn't directly support random generation. Private IP ranges follow RFC 1918. The JavaFaker library provides convenient methods like ipV4Address(), ipV6Address(), privateIpV4Address(), and publicIpV4Address() for production testing frameworks.

Expected Output

Random IPv4: 198.51.100.42
Private IPv4: 192.168.15.234
Public IPv4: 203.0.113.89
IPv6: 2001:0db8:85a3:0000:0000:8a2e:0370:7334
IPv4 with CIDR: 198.51.100.42/24
Batch: 203.0.113.15, 198.51.100.89, 192.0.2.45, 198.51.100.123, 203.0.113.67
Is valid: true