Main Tutorials

Java – Convert IP address to Decimal Number

java-ip-to-decimal

In this tutorial, we show you how to convert an IP address to its decimal equivalent in Java, and vice versa. For examples :


255.255.255.255  <->  4294967295
192.168.1.2      <->  3232235778

1. IP Address to Decimal

We show you two ways to convert an IP address to a decimal number

  1. Normal power of 256
  2. Bit shifting

1.1 First Example – Power of 256
The IP address is “base 256”, to convert 192.168.1.2 to decimal (base 10) the formula is:


192 x (256)^3 + 168 x (256)^2 + 1 x (256)^1 + 2 (256)^0 = ?
3221225472 + 11010048 + 256 + 2 = 3232235778

  public long ipToLong(String ipAddress) {

	String[] ipAddressInArray = ipAddress.split("\\.");

	long result = 0;
	for (int i = 0; i < ipAddressInArray.length; i++) {

		int power = 3 - i;
		int ip = Integer.parseInt(ipAddressInArray[i]);
		result += ip * Math.pow(256, power);

	}

	return result;
  }

Some developers prefer to use modular like this


result += (Integer.parseInt(ipAddressInArray[i]) % 256 * Math.pow(256, power));

1.2 Second Example – Bit shifting
Review the binary bit shifting graph below :


  public long ipToLong(String ipAddress) {
		
	long result = 0;
		
	String[] ipAddressInArray = ipAddress.split("\\.");

	for (int i = 3; i >= 0; i--) {
			
		long ip = Long.parseLong(ipAddressInArray[3 - i]);
			
		//left shifting 24,16,8,0 and bitwise OR
			
		//1. 192 << 24
		//1. 168 << 16
		//1. 1   << 8
		//1. 2   << 0
		result |= ip << (i * 8);
		
	}

	return result;
  }

192         00000000 00000000 00000000 11000000 
-----------------------------------------------
192 << 24   11000000 00000000 00000000 00000000 
Result      00000000 00000000 00000000 00000000 
Result |=   11000000 00000000 00000000 00000000 

168         00000000 00000000 00000000 10101000 
-----------------------------------------------
168 << 16   00000000 10101000 00000000 00000000 
Result	    11000000 00000000 00000000 00000000 
Result |=   11000000 10101000 00000000 00000000

1           00000000 00000000 00000000 00000001 
-----------------------------------------------
1   << 8    00000000 00000000 00000001 00000000 
Result	    11000000 10101000 00000000 00000000 
Result |=   11000000 10101000 00000001 00000000

2           00000000 00000000 00000000 00000010 
-----------------------------------------------
2 << 0      00000000 00000000 00000000 00000010 
Result	    11000000 10101000 00000001 00000000 
Result |=   11000000 10101000 00000001 00000010

Convert the final binary code to decimal, by hand calculation 🙂 ~


Result      11000000 10101000 00000001 00000010
index       0 - 31, start from right.
      	    31(1),30(1),29,28,27,26,25,24,23(1),22,21(1),20,19(1),18,17,16,15,14,13,12,11,10,9,8(1),7,6,5,4,3,2,1(1),0
Decimal     1x2^31 + 1x2^30 + 1x2^23 + 1x2^21 + 1x2^19 + 1x2^8 + 1x2^1
            2147483648 + 1073741824 + 8388608 + 2097152 + 524288 + 256 + 2
            3232235778

2. Decimal to IP Address

We show you two bit shifting and “0xff” masking examples to convert a decimal number back to IP address. The bit shifting is very hard to explain in words, it’s better review the binary flows below :

2.1 First Example.


  //ip = 3232235778
  public String longToIp(long ip) {
	StringBuilder result = new StringBuilder(15);

	for (int i = 0; i < 4; i++) {
		
		result.insert(0,Long.toString(ip & 0xff));

		if (i < 3) {
			sb.insert(0,'.');
		}

		ip = ip >> 8;
	}
	return result.toString();
  }

Review the bit shifting flows :


3232235778		11000000 10101000 00000001 00000010

<<Loop 1>>
-----------------------------------------------------------
ip      		11000000 10101000 00000001 00000010 
& 0xff			00000000 00000000 00000000 11111111 
Result                  00000000 00000000 00000000 00000010 = 2
Result Append           .2
                                 -------------------------> 8
ip >> 8			00000000 11000000 10101000 00000001 {off 00000010}

<<Loop 2>>
-----------------------------------------------------------
ip      		00000000 11000000 10101000 00000001
& 0xff			00000000 00000000 00000000 11111111 
Result                  00000000 00000000 00000000 00000001 = 1
Result Append           1.2
                                          ----------------> 8
ip >> 8			00000000 00000000 11000000 10101000 {off 00000001}

<<Loop 3>>
-----------------------------------------------------------
ip      		00000000 00000000 11000000 10101000
& 0xff			00000000 00000000 00000000 11111111 
Result                  00000000 00000000 00000000 10101000 = 168
Result Append           168.1.2
                                                   -------> 8
ip >> 8			00000000 00000000 00000000 11000000 {off 10101000}

<<Loop 4>>
-----------------------------------------------------------
ip      		00000000 00000000 00000000 11000000
& 0xff			00000000 00000000 00000000 11111111 
Result                  00000000 00000000 00000000 11000000 = 192
Result Append           192.168.1.2
                                                            -----------> 8
ip >> 8			00000000 00000000 00000000 00000000 {off 11000000}

2.2 Second Example.


  //ip = 3232235778
  public String longToIp(long ip) {

	return ((ip >> 24) & 0xFF) + "." 
		+ ((ip >> 16) & 0xFF) + "." 
		+ ((ip >> 8) & 0xFF) + "." 
		+ (ip & 0xFF);

  }

3232235778		11000000 10101000 00000001 00000010

1. (ip >> 24) & 0xFF
-----------------------------------------------------------
ip      		11000000 10101000 00000001 00000010 
                                                   -------------------------------------> 24
ip >> 24                00000000 00000000 00000000 11000000 {off 10101000 00000001 00000010}  
& 0xff			00000000 00000000 00000000 11111111 
Result                  00000000 00000000 00000000 11000000 = 192

2. (ip >> 16) & 0xFF
-----------------------------------------------------------
ip      		11000000 10101000 00000001 00000010 
                                          -------------------------------------> 16
ip >> 16                00000000 00000000 11000000 10101000 {off 00000001 00000010}  
& 0xff			00000000 00000000 00000000 11111111 
Result                  00000000 00000000 00000000 10101000 = 168

3. (ip >> 8) & 0xFF
-----------------------------------------------------------
ip      		11000000 10101000 00000001 00000010 
                                 --------------------------------------> 8
ip >> 24                00000000 11000000 10101000 00000001 {off 00000010}  
& 0xff			00000000 00000000 00000000 11111111 
Result                  00000000 00000000 00000000 00000001 = 1

4. ip & 0xFF
-----------------------------------------------------------
ip      		11000000 10101000 00000001 00000010 
& 0xff			00000000 00000000 00000000 11111111 
Result                  00000000 00000000 00000000 00000010 = 2

3. Java Source Code

Full Java example to demonstrate above scenario :


package com.mkyong.core;

public class JavaBitwiseExample {

	public static void main(String[] args) {

		JavaBitwiseExample obj = new JavaBitwiseExample();

		System.out.println("iptoLong  : " + obj.ipToLong("192.168.1.2"));
		System.out.println("iptoLong2 : " + obj.ipToLong2("192.168.1.2"));

		System.out.println("longToIp  : " + obj.longToIp(3232235778L));
		System.out.println("longToIp2 : " + obj.longToIp2(3232235778L));

	}

	// example : 192.168.1.2
	public long ipToLong(String ipAddress) {

		// ipAddressInArray[0] = 192
		String[] ipAddressInArray = ipAddress.split("\\.");

		long result = 0;
		for (int i = 0; i < ipAddressInArray.length; i++) {

			int power = 3 - i;
			int ip = Integer.parseInt(ipAddressInArray[i]);

			// 1. 192 * 256^3
			// 2. 168 * 256^2
			// 3. 1 * 256^1
			// 4. 2 * 256^0
			result += ip * Math.pow(256, power);

		}

		return result;

	}

	public long ipToLong2(String ipAddress) {

		long result = 0;

		String[] ipAddressInArray = ipAddress.split("\\.");

		for (int i = 3; i >= 0; i--) {

			long ip = Long.parseLong(ipAddressInArray[3 - i]);

			// left shifting 24,16,8,0 and bitwise OR

			// 1. 192 << 24
			// 1. 168 << 16
			// 1. 1 << 8
			// 1. 2 << 0
			result |= ip << (i * 8);

		}

		return result;
	}

	public String longToIp(long i) {

		return ((i >> 24) & 0xFF) + 
                   "." + ((i >> 16) & 0xFF) + 
                   "." + ((i >> 8) & 0xFF) + 
                   "." + (i & 0xFF);

	}

	public String longToIp2(long ip) {
		StringBuilder sb = new StringBuilder(15);

		for (int i = 0; i < 4; i++) {

			// 1. 2
			// 2. 1
			// 3. 168
			// 4. 192
			sb.insert(0, Long.toString(ip & 0xff));

			if (i < 3) {
				sb.insert(0, '.');
			}

			// 1. 192.168.1.2
			// 2. 192.168.1
			// 3. 192.168
			// 4. 192
			ip = ip >> 8;

		}

		return sb.toString();
	}

	/*
	private static void printPrettyBinary(String binary) {

		String s1 = String.format("%32s", binary).replace(' ', '0');

		System.out.format("%8s %8s %8s %8s %n", 
			s1.substring(0, 8), 
			s1.substring(8, 16), 
			s1.substring(16, 24), 
			s1.substring(24, 32));
	}
	*/
}

Output


iptoLong  : 3232235778
iptoLong2 : 3232235778
longToIp  : 192.168.1.2
longToIp2 : 192.168.1.2

References

  1. Java and 0xff example
  2. bitwiseOR example
  3. Convert base 10 to ip
  4. Microsoft : IP Addressing
  5. Wikipedia : power of two
  6. Wikipedia : Bitwise operation
  7. Stackoverflow : ip address conversion to decimal and vice versa
  8. Stackoverflow : Absolute Beginner’s Guide to Bit Shifting?

About Author

author image
Founder of Mkyong.com, love Java and open source stuff. Follow him on Twitter. If you like my tutorials, consider make a donation to these charities.

Comments

Subscribe
Notify of
18 Comments
Most Voted
Newest Oldest
Inline Feedbacks
View all comments
body
3 years ago

IP to Long without .split():

public static long IPToLong(String ipAddress) {
    int[] dots = new int[3];
    long result = 0, value;
    for (int i = 0; i < 4; i++) {
        if(i < 3) {
            dots[i] = ipAddress.indexOf('.', i == 0 ? 0 : dots[i - 1] + 1);
            value = Long.parseLong(ipAddress.substring(i == 0 ? 0 : dots[i - 1] + 1, dots[i]));
        } else {
            value = Long.parseLong(ipAddress.substring(dots[i - 1] + 1));
        }

        result |= value << ((3 - i) * 8);
    }
    return result;
}
Vadim
5 years ago

2.1 Example
if (i < 3) {
sb.insert(0,'.');
}
Here is an error, no sb declared, change to result

Jegors
1 year ago

an article (ru) where mentioned your algorithms: https://habr.com/ru/post/679008/

ersoviet
5 years ago

thank for information and example, but how for IPv6?

nitesh
5 years ago

in same way please share code for print system subnet mask

ilw
6 years ago

Why long, not int ?

Oliver Doepner
10 years ago

I think this tutorial is bad on several levels:

1) What is the benefit of converting IP4 addresses to numbers? The author says: sorting, searching, comparison. I don’t see how searching would be any easier because the decimal (10 based) format does not help with sub-string searches against search text entered by a user. Sorting and greater-than comparisons are actually easier, but that assumes that you are interested in a “is-greater-than” relationship, which just doesn’t make very much sense for IP addresses.

2) Through the conversion to a long you lose the “base 256” structure which is what you need in all user facing contexts. So in any real scenario this involves a lot of back and forth conversion.

3) Let’s be realistic: What are typical operations on IP addresses? I can think of equality (equals() and hashCode() methods), checking if it matches a certain subnet pattern and basically the methods in java.net.InetAddress and its two subclasses.

4) The blog post does not mention these JDK classes Inet4Address and Inet6Address and thereby fails another basic criteria for good tutorials: Mention the standard before delving into your hobby code. Also, please not that the JDK classes do _not_ implement Comparable for a reason.

5) Inet4Address and Inet6Address provide a getAddress() method that returns a byte array. If you absolutely want to generate long decimals to do numeric sorting and size comparison, it could be derived from that byte array.

6) Another bad thing about treating IP addresses just as Strings or numbers is that you have no type-safety and have to deal with potentially invalid values. It is much better to deal with properly typed objects like Inet4Address, Inet6Address and pass those around in your application code, instead of raw String or longs.

mkyong
10 years ago
Reply to  Oliver Doepner

Thanks for your comments.

For my case, I saved both raw IP and decimal IP format.
1. Raw IP for whatever standard IP purpose.
2. Decimal IP for searching a range of IP.

Will update the article to include more “standard” ways.

P.S Thanks for your tip 5.

Mick
9 months ago
Reply to  mkyong

Thank you. I need these conversion algorithms to use these free databases…
https://lite.ip2location.com/database/db3-ip-country-region-city
I guess I’ll have to do IPv6 myself 🙁
🙂

Psycho
10 years ago

Thanks for sharing. Could be interesting that you explain in which case you use this and why! (sorry for previous post)

mkyong
10 years ago
Reply to  Psycho

IP decimal is more easy to search, filter or compare, for example, search an ip address in range.

Psycho
10 years ago

Thanks for sharing. Good be intersting in which case you use this and why!

Alvin Ge
10 years ago

What about IPV6 can be convert to decimal?

Bhupal
6 years ago
Reply to  Alvin Ge

How we can convert IPV6 to Decimal. Could you please let me Know

mkyong
10 years ago
Reply to  Alvin Ge

Above code is not working for IPv6

Mayur
10 years ago

Does it guarantee of generation of unique decimal for each ip

Abhimanyu Rana
7 years ago
Reply to  Mayur

It is basically a mathematical formula multiplying it with different powers of 256. So if you enter unique IPs you will get unique ip number. It is as simple as that.

mkyong
10 years ago
Reply to  Mayur

yes, it should.