Java – Convert IP address to Decimal Number

朱雀 2022-06-08 07:13 280阅读 0赞

1. IP Address to Decimal

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

  • Normal power of 256
  • 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

  1. public long ipToLong(String ipAddress) {
  3. String[] ipAddressInArray = ipAddress.split("\\.");
  5. long result = 0;
  6. for (int i = 0; i < ipAddressInArray.length; i++) {
  8.     int power = 3 - i;
  9.     int ip = Integer.parseInt(ipAddressInArray[i]);
  10.     result += ip * Math.pow(256, power);
  12. }
  14. return result;
  15.   }

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 :

  1. public long ipToLong(String ipAddress) {
  3. long result = 0;
  5. String[] ipAddressInArray = ipAddress.split("\\.");
  7. for (int i = 3; i >= 0; i--) {
  9.     long ip = Long.parseLong(ipAddressInArray[3 - i]);
  11.     //left shifting 24,16,8,0 and bitwise OR
  13.     //1. 192 << 24
  14.     //1. 168 << 16
  15.     //1. 1 << 8
  16.     //1. 2 << 0
  17.     result |= ip << (i * 8);
  19. }
  21. return result;
  22.   }
  24. 192 00000000 00000000 00000000 11000000 -----------------------------------------------
  25. 192 << 24   11000000 00000000 00000000 00000000
  26. Result      00000000 00000000 00000000 00000000
  27. Result |=   11000000 00000000 00000000 00000000
  29. 168 00000000 00000000 00000000 10101000 -----------------------------------------------
  30. 168 << 16   00000000 10101000 00000000 00000000
  31. Result      11000000 00000000 00000000 00000000
  32. Result |=   11000000 10101000 00000000 00000000
  34. 1 00000000 00000000 00000000 00000001 -----------------------------------------------
  35. 1   << 8    00000000 00000000 00000001 00000000
  36. Result      11000000 10101000 00000000 00000000
  37. Result |=   11000000 10101000 00000001 00000000
  39. 2 00000000 00000000 00000000 00000010 -----------------------------------------------
  40. 2 << 0      00000000 00000000 00000000 00000010
  41. Result      11000000 10101000 00000001 00000000
  42. Result |=   11000000 10101000 00000001 00000010

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

  1. 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.

  1. //ip = 3232235778
  2.   public String longToIp(long ip) {
  3. StringBuilder result = new StringBuilder(15);
  5. for (int i = 0; i < 4; i++) {
  7.     result.insert(0,Long.toString(ip & 0xff));
  9.     if (i < 3) {
  10.         sb.insert(0,'.');
  11.     }
  13.     ip = ip >> 8;
  14. }
  15. return result.toString();
  16.   }

Review the bit shifting flows :

  1. 3232235778      11000000 10101000 00000001 00000010
  3. <<Loop 1>> -----------------------------------------------------------
  4. ip              11000000 10101000 00000001 00000010
  5. & 0xff          00000000 00000000 00000000 11111111
  6. Result                  00000000 00000000 00000000 00000010 = 2
  7. Result Append           .2
  8.  -------------------------> 8
  9. ip >> 8         00000000 11000000 10101000 00000001 {off 00000010}
  11. <<Loop 2>> -----------------------------------------------------------
  12. ip              00000000 11000000 10101000 00000001
  13. & 0xff          00000000 00000000 00000000 11111111
  14. Result                  00000000 00000000 00000000 00000001 = 1
  15. Result Append           1.2
  16.  ----------------> 8
  17. ip >> 8         00000000 00000000 11000000 10101000 {off 00000001}
  19. <<Loop 3>> -----------------------------------------------------------
  20. ip              00000000 00000000 11000000 10101000
  21. & 0xff          00000000 00000000 00000000 11111111
  22. Result                  00000000 00000000 00000000 10101000 = 168
  23. Result Append           168.1.2
  24.  -------> 8
  25. ip >> 8         00000000 00000000 00000000 11000000 {off 10101000}
  27. <<Loop 4>> -----------------------------------------------------------
  28. ip              00000000 00000000 00000000 11000000
  29. & 0xff          00000000 00000000 00000000 11111111
  30. Result                  00000000 00000000 00000000 11000000 = 192
  31. Result Append           192.168.1.2
  32.  -----------> 8
  33. ip >> 8         00000000 00000000 00000000 00000000 {off 11000000}

2.2 Second Example.

  1. //ip = 3232235778
  2.   public String longToIp(long ip) {
  4. return ((ip >> 24) & 0xFF) + "."
  5.     + ((ip >> 16) & 0xFF) + "."
  6.     + ((ip >> 8) & 0xFF) + "."
  7.     + (ip & 0xFF);
  9.   }
  11. 3232235778      11000000 10101000 00000001 00000010
  13. 1. (ip >> 24) & 0xFF -----------------------------------------------------------
  14. ip              11000000 10101000 00000001 00000010
  15.  -------------------------------------> 24
  16. ip >> 24                00000000 00000000 00000000 11000000 {off 10101000 00000001 00000010}
  17. & 0xff          00000000 00000000 00000000 11111111
  18. Result                  00000000 00000000 00000000 11000000 = 192
  20. 2. (ip >> 16) & 0xFF -----------------------------------------------------------
  21. ip              11000000 10101000 00000001 00000010
  22.  -------------------------------------> 16
  23. ip >> 16                00000000 00000000 11000000 10101000 {off 00000001 00000010}
  24. & 0xff          00000000 00000000 00000000 11111111
  25. Result                  00000000 00000000 00000000 10101000 = 168
  27. 3. (ip >> 8) & 0xFF -----------------------------------------------------------
  28. ip              11000000 10101000 00000001 00000010
  29.  --------------------------------------> 8
  30. ip >> 24                00000000 11000000 10101000 00000001 {off 00000010}
  31. & 0xff          00000000 00000000 00000000 11111111
  32. Result                  00000000 00000000 00000000 00000001 = 1
  34. 4. ip & 0xFF -----------------------------------------------------------
  35. ip              11000000 10101000 00000001 00000010
  36. & 0xff          00000000 00000000 00000000 11111111
  37. Result                  00000000 00000000 00000000 00000010 = 2

3. Java Source Code

Full Java example to demonstrate above scenario :

  1. package com.mkyong.core;
  3. public class JavaBitwiseExample {
  5.     public static void main(String[] args) {
  7.         JavaBitwiseExample obj = new JavaBitwiseExample();
  9.         System.out.println("iptoLong : " + obj.ipToLong("192.168.1.2"));
  10.         System.out.println("iptoLong2 : " + obj.ipToLong2("192.168.1.2"));
  12.         System.out.println("longToIp : " + obj.longToIp(3232235778L));
  13.         System.out.println("longToIp2 : " + obj.longToIp2(3232235778L));
  15.     }
  17.     // example : 192.168.1.2
  18.     public long ipToLong(String ipAddress) {
  20.         // ipAddressInArray[0] = 192
  21.         String[] ipAddressInArray = ipAddress.split("\\.");
  23.         long result = 0;
  24.         for (int i = 0; i < ipAddressInArray.length; i++) {
  26.             int power = 3 - i;
  27.             int ip = Integer.parseInt(ipAddressInArray[i]);
  29.             // 1. 192 * 256^3
  30.             // 2. 168 * 256^2
  31.             // 3. 1 * 256^1
  32.             // 4. 2 * 256^0
  33.             result += ip * Math.pow(256, power);
  35.         }
  37.         return result;
  39.     }
  41.     public long ipToLong2(String ipAddress) {
  43.         long result = 0;
  45.         String[] ipAddressInArray = ipAddress.split("\\.");
  47.         for (int i = 3; i >= 0; i--) {
  49.             long ip = Long.parseLong(ipAddressInArray[3 - i]);
  51.             // left shifting 24,16,8,0 and bitwise OR
  53.             // 1. 192 << 24
  54.             // 1. 168 << 16
  55.             // 1. 1 << 8
  56.             // 1. 2 << 0
  57.             result |= ip << (i * 8);
  59.         }
  61.         return result;
  62.     }
  64.     public String longToIp(long i) {
  66.         return ((i >> 24) & 0xFF) +
  67.                    "." + ((i >> 16) & 0xFF) +
  68.                    "." + ((i >> 8) & 0xFF) +
  69.                    "." + (i & 0xFF);
  71.     }
  73.     public String longToIp2(long ip) {
  74.         StringBuilder sb = new StringBuilder(15);
  76.         for (int i = 0; i < 4; i++) {
  78.             // 1. 2
  79.             // 2. 1
  80.             // 3. 168
  81.             // 4. 192
  82.             sb.insert(0, Long.toString(ip & 0xff));
  84.             if (i < 3) {
  85.                 sb.insert(0, '.');
  86.             }
  88.             // 1. 192.168.1.2
  89.             // 2. 192.168.1
  90.             // 3. 192.168
  91.             // 4. 192
  92.             ip = ip >> 8;
  94.         }
  96.         return sb.toString();
  97.     }
  99.     /* 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)); } */
  100. }

OUTPUT

  1. iptoLong  : 3232235778
  2. iptoLong2 : 3232235778
  3. longToIp  : 192.168.1.2
  4. longToIp2 : 192.168.1.2

https://www.mkyong.com/java/java-convert-ip-address-to-decimal-number/

发表评论

表情：
评论列表 （有 0 条评论，280人围观）

还没有评论，来说两句吧...

相关阅读