Sorting IP Addresses with Java Radix Sort

What I built

I built a Java program called RadixIP. It stores several IPv4 addresses, converts each dotted-decimal address into an integer, then uses a base-256 radix sort to sort them.

Why IP addresses fit radix sort

An IPv4 address is made of four octets. Each octet is one byte, and one byte can hold values from 0 to 255. That makes base 256 a natural match.

192.168.15.200

192  = first byte
168  = second byte
15   = third byte
200  = fourth byte

The sorting workflow

The program performs four sorting passes. It starts with the least significant byte, which is the last octet, and works toward the most significant byte, which is the first octet.

Data structures used

The project is small, but the data-structure choices matter.

Code walkthrough

The main radix-sort class stores the list being sorted, creates 256 queues, distributes values into buckets, then collects them back into the list.

class RadixSortBase256 {
    List<Integer> toSort;
    ArrayList<Queue<Integer>> bins;
    final int BASE = 256;
    final int numBytes = 4;

    RadixSortBase256(List<Integer> toSort) {
        this.toSort = toSort;
        bins = new ArrayList<>(BASE);

        for (int i = 0; i < BASE; i++) {
            bins.add(new LinkedList<>());
        }
    }
}

How one byte is selected

This line is the key part of the program. It uses bit shifting to select one byte from the integer representation of the IP address.

int bucket = (ip >>> (8 * bytePass)) & 0xFF;

Distribute and collect

Each pass has two main steps. First, distribute each IP into the correct byte bucket. Then, collect the buckets back into the main list in order.

public void distribute(int bytePass) {
    for (Integer ip : toSort) {
        int bucket = (ip >>> (8 * bytePass)) & 0xFF;
        bins.get(bucket).add(ip);
    }
}

public void collect() {
    toSort.clear();

    for (Queue<Integer> b : bins) {
        while (!b.isEmpty()) {
            toSort.add(b.poll());
        }
    }
}

Converting IP strings to integers

The program starts with readable dotted-decimal IP strings, splits them on periods, parses each octet, then packs the four octets into one integer using bit shifts.

private static int ip(String s) {
    String[] p = s.split("\\.");

    return (Integer.parseInt(p[0]) << 24)
            | (Integer.parseInt(p[1]) << 16)
            | (Integer.parseInt(p[2]) << 8)
            |  Integer.parseInt(p[3]);
}

Converting integers back to IP strings

For readable output, the program converts each sorted integer back into normal dotted-decimal form.

private static String intToIp(int x) {
    return ((x >>> 24) & 0xFF) + "."
            + ((x >>> 16) & 0xFF) + "."
            + ((x >>> 8) & 0xFF) + "."
            + (x & 0xFF);
}

Sample input

The demo sorts a small list of hardcoded IPv4 addresses.

ips.add(ip("10.0.143.92"));
ips.add(ip("10.12.8.77"));
ips.add(ip("172.16.0.14"));
ips.add(ip("192.168.15.200"));
ips.add(ip("172.31.254.9"));
ips.add(ip("192.168.0.3"));
ips.add(ip("203.0.113.45"));

Final sorted output

After four passes, the addresses are sorted numerically by IPv4 value.

10.0.143.92
10.12.8.77
172.16.0.14
172.31.254.9
192.168.0.3
192.168.15.200
203.0.113.45

What I learned

This project helped connect sorting algorithms, Java data structures, and networking basics.

Future improvements

This is a simple demo, but it could become more practical with a few upgrades.

Run it locally

Since the public class is named RadixIP, the file should be saved as RadixIP.java before compiling.

javac RadixIP.java
java RadixIP

Final idea