Переход с 127.0.0.1 на 2130706433 и обратно

Question

Используя стандартные библиотеки Java, какой самый быстрый способ получить от точечного строкового представления IPV4-адреса ("127.0.0.1") до эквивалентного целочисленного представления (2130706433).

И, соответственно, какой самый быстрый способ инвертировать указанную операцию - перейти от целого числа 2130706433 к строковому представлению "127.0.0.1"?

Answer 1

Строка в int:

int pack(byte[] bytes) {
  int val = 0;
  for (int i = 0; i < bytes.length; i++) {
    val <<= 8;
    val |= bytes[i] & 0xff;
  }
  return val;
}

pack(InetAddress.getByName(dottedString).getAddress());

Int в строку:

byte[] unpack(int bytes) {
  return new byte[] {
    (byte)((bytes >>> 24) & 0xff),
    (byte)((bytes >>> 16) & 0xff),
    (byte)((bytes >>>  8) & 0xff),
    (byte)((bytes       ) & 0xff)
  };
}


InetAddress.getByAddress(unpack(packedBytes)).getHostAddress()

Answer 2

Вы также можете использовать Google Guava InetAddress Класс

String ip = "192.168.0.1";
InetAddress addr = InetAddresses.forString(ip);
// Convert to int
int address = InetAddresses.coerceToInteger(addr);
// Back to str 
String addressStr = InetAddresses.fromInteger(address));

Answer 3

Я изменил свой оригинальный ответ. В реализации Sun InetAddress метод hashCode создает целочисленное представление адреса IPv4, но, как правильно указали комментаторы, это не гарантируется JavaDoc. Поэтому я решил использовать класс ByteBuffer для вычисления значения адреса IPv4.

import java.net.InetAddress;
import java.nio.ByteBuffer;

// ...

try {
    // Convert from integer to an IPv4 address
    InetAddress foo = InetAddress.getByName("2130706433");
    String address = foo.getHostAddress();
    System.out.println(address);

    // Convert from an IPv4 address to an integer
    InetAddress bar = InetAddress.getByName("127.0.0.1");
    int value = ByteBuffer.wrap(bar.getAddress()).getInt();
    System.out.println(value);

} catch (Exception e) {
    e.printStackTrace();
}

Вывод будет:

127.0.0.1
2130706433

Answer 4

Если вам нужно изучить математику с длинными руками, вы можете использовать Substr, чтобы вырывать октеты. Mutliply первый октет, обозначающий класс как (256 * 256 * 256) или (2 ^ 24) второе умноженное на (256 * 256) (2 ^ 16) третий умноженный на (256) (2 ^ 8) четвертый умноженный на 1 или (2 ^ 0)

127 * (2 ^ 24) + 0 * (2 ^ 16) + 0 * (2 ^ 8) + 1 * (2 ^ 0) 2130706432 + 0 + 0 + 1 = 2130706433

Answer 5

Используя библиотеку Java IPAddress это просто, одна строка кода для каждого направления. Отказ от ответственности: я руководитель проекта этой библиотеки.

    IPv4Address loopback = new IPAddressString("127.0.0.1").getAddress().toIPv4();
    System.out.println(loopback.intValue());
    IPv4Address backAgain = new IPv4Address(loopback.intValue());
    System.out.println(backAgain);

Выход:

    2130706433
    127.0.0.1

Answer 6

Я не пробовал это. производительность, но самый простой способ - использовать NIO ByteBuffer .

, например

 byteBuffer.put(integer).array();

вернет вам байтовый массив, представляющий целое число. Вам может необходимо изменить порядок байтов.

Answer 7

Другой способ:

public static 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;
  }