Java中IP地址的表示方法及常见操作

# 1. IP地址简介

## 1.1 IP地址的概念与作用

在计算机网络中，IP地址（Internet Protocol Address）是用于识别和定位网络中设备的一种地址标识符。它是网络通信中非常重要的一部分，类似于现实生活中的门牌号码，能够唯一标识一个设备或主机在网络上的位置。

## 1.2 IPv4与IPv6的区别

IPv4（Internet Protocol version 4）是目前广泛采用的IP地址版本，使用32位地址，约有42亿个可用地址，但由于互联网的快速发展，地址资源已经日益枯竭。IPv6（Internet Protocol version 6）是为了解决IPv4地址枯竭问题而诞生的新一代IP地址标准，采用128位地址，理论上拥有更加庞大的地址空间。

## 1.3 IP地址的分类

根据IP地址的分配情况和用途，IP地址可以按照其所在网络的范围分为A、B、C、D、E五类，其中前三类（A、B、C）用于标识主机，D类地址用于多播（Multicast）通信，E类地址保留未分配。每个类别的IP地址范围和用途略有不同，需要根据实际情况分配和使用。

在这一部分，我们简要介绍了IP地址的概念、IPv4与IPv6的区别以及IP地址的分类情况。接下来，我们会深入探讨Java中IP地址的表示方法及常见操作。

# 2. Java中表示IP地址的类
2.1 InetAddress类的介绍
2.2 Inet4Address与Inet6Address的区别
2.3 通过InetAddress类获取IP地址

在Java中，用于表示IP地址的主要类是`InetAddress`类。这个类提供了一种表示网络地址的方式，可以表示IPv4和IPv6地址。在Java中，IP地址被抽象成了`InetAddress`对象，通过这个对象可以获取和处理IP地址的相关信息。

### 2.1 InetAddress类的介绍
`InetAddress`类是Java中用于表示IP地址的类。它包含了表示IPv4和IPv6地址的方法，可以获取主机名、IP地址字节数组等信息。通过`InetAddress`类，可以实现对IP地址的解析和操作。

### 2.2 Inet4Address与Inet6Address的区别
在`InetAddress`类中，`Inet4Address`表示IPv4地址，`Inet6Address`表示IPv6地址。IPv4地址由32位构成，而IPv6地址由128位构成。因此，在Java中通过不同的子类来表示这两种不同版本的IP地址。

### 2.3 通过InetAddress类获取IP地址
下面是一个简单的示例代码演示如何通过`InetAddress`类获取本地主机的IP地址：

import java.net.InetAddress;
import java.net.UnknownHostException;

public class IPAddressExample {
    public static void main(String[] args) {
        try {
            InetAddress inetAddress = InetAddress.getLocalHost();
            System.out.println("Host Address: " + inetAddress.getHostAddress());
            System.out.println("Host Name: " + inetAddress.getHostName());
        } catch (UnknownHostException e) {
            System.out.println("Error occurred: " + e.getMessage());
        }
    }
}

**代码说明**：
- 通过`getLocalHost()`方法获取本地主机的`InetAddress`对象。
- 使用`getHostAddress()`方法获取主机的IP地址。
- 使用`getHostName()`方法获取主机的主机名。

**代码总结**：
通过`InetAddress`类，可以方便地获取和操作IP地址，在网络编程和系统管理中非常有用。

**结果说明**：
当运行上述代码时，将输出本地主机的IP地址和主机名信息。

# 3. IP地址的转换操作

在Java中，常常需要进行IP地址相关的转换操作，接下来我们将介绍如何将IP地址与字节数组之间进行转换，并给出示例代码演示。

#### 3.1 将IP地址转换为字节数组

通过InetAddress类的getAddress()方法，可以将IP地址转换为字节数组。示例代码如下：

import java.net.InetAddress;
import java.net.UnknownHostException;

public class Main {
    public static void main(String[] args) {
        try {
            InetAddress ip = InetAddress.getByName("127.0.0.1");
            byte[] bytes = ip.getAddress();

            // 输出字节数组
            for (byte b : bytes) {
                System.out.print(b & 0xFF); // 将byte转换为无符号整数
                System.out.print(".");
            }
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

**代码解析：**
- 首先通过`InetAddress.getByName()`方法获取IP地址对象。
- 调用`getAddress()`方法将IP地址转换为字节数组。
- 遍历字节数组并输出每个字节的值（转换为无符号整数）。

**代码运行结果：** 输出为 `127.0.0.1.`，表示成功将IP地址转换为字节数组格式。

#### 3.2 将字节数组转换为IP地址

如果需要将字节数组表示的IP地址转换为字符串形式的IP地址，可以使用InetAddress的静态方法getByAddress(byte[])。示例代码如下：

import java.net.InetAddress;
import java.net.UnknownHostException;

public class Main {
    public static void main(String[] args) {
        byte[] bytes = {127, 0, 0, 1};

        try {
            InetAddress ip = InetAddress.getByAddress(bytes);
            System.out.println(ip.getHostAddress());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

**代码解析：**
- 创建一个字节数组表示IP地址。
- 使用`InetAddress.getByAddress()`方法将字节数组转换为InetAddress对象。
- 调用`getHostAddress()`方法获取IP地址的字符串形式。

**代码运行结果：** 输出为 `127.0.0.1`，表示成功将字节数组转换为IP地址字符串形式。

#### 3.3 示例代码演示

下面我们结合示例代码演示了如何在Java中进行IP地址的转换操作，包括将IP地址转换为字节数组和将字节数组转换为IP地址的过程。在实际应用中，这些转换操作能够帮助我们处理IP地址数据，进行网络通信等操作。

# 4. IP地址的验证与校验

在Java中处理IP地址时，常常需要对IP地址进行验证和校验，以确保其格式的正确性和有效性。下面将介绍一些常见的IP地址验证与校验操作。

#### 4.1 利用正则表达式验证IP地址格式

import java.util.regex.Pattern;

public class IPAddressValidation {

    public static boolean isValidIPAddress(String ipAddress) {
        String IP_PATTERN = "^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$";
        return Pattern.matches(IP_PATTERN, ipAddress);
    }

    public static void main(String[] args) {
        String ipAddress1 = "192.168.1.1";
        String ipAddress2 = "256.0.0.1";

        System.out.println(ipAddress1 + " is valid: " + isValidIPAddress(ipAddress1));
        System.out.println(ipAddress2 + " is valid: " + isValidIPAddress(ipAddress2));
    }
}

**代码说明：** 上面的代码使用正则表达式来验证IP地址的格式是否正确，其中IP_PATTERN是匹配IP地址格式的正则表达式。通过调用`isValidIPAddress`方法，我们可以验证给定的IP地址是否符合标准IPv4格式。

**代码运行结果：**

192.168.1.1 is valid: true
256.0.0.1 is valid: false

#### 4.2 检查IP地址的有效性

在Java中，除了验证IP地址的格式外，还可以检查IP地址的有效性，即IP地址是否可达或合法。这通常涉及到网络通信的操作，如使用Socket进行连接检测等。

#### 4.3 处理IP地址为空或无效的情况

在实际应用中，IP地址有可能为空或无效，此时我们需要编写相应的异常处理代码来处理这种情况，以确保程序的稳定性和可靠性。

# 5. IP地址的匹配与过滤

在网络编程中，经常需要对IP地址进行匹配和过滤操作，以满足各类需求。下面将介绍如何在Java中进行IP地址的匹配与过滤操作。

#### 5.1 使用正则表达式进行IP地址匹配

IP地址通常符合一定的格式，可以利用正则表达式来匹配IP地址的合法性。以下是一个示例代码，用于验证输入的字符串是否为合法的IPv4地址：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class IPAddressMatcher {

    public static boolean isValidIPv4(String ipAddress) {
        String ipv4Pattern = "^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$";
        Pattern pattern = Pattern.compile(ipv4Pattern);
        Matcher matcher = pattern.matcher(ipAddress);
        return matcher.matches();
    }

    public static void main(String[] args) {
        String ip1 = "192.168.0.1";
        String ip2 = "256.0.0.1";

        System.out.println(ip1 + " is valid: " + isValidIPv4(ip1));
        System.out.println(ip2 + " is valid: " + isValidIPv4(ip2));
    }
}

**代码解释：**
- `isValidIPv4`方法使用正则表达式验证IPv4地址的合法性。
- 在`main`方法中，我们验证了两个不同的IP地址字符串。
- 正则表达式`ipv4Pattern`用于匹配IPv4地址格式。

**结果说明：**
- `192.168.0.1` 是合法的IPv4地址，输出为 `true`。
- `256.0.0.1` 不是合法的IPv4地址，输出为 `false`。

#### 5.2 通过Subnet进行IP地址过滤

有时候我们需要基于子网进行IP地址过滤，只允许特定范围内的IP地址访问。以下是一个简单示例，展示如何使用子网掩码过滤IP地址：

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.regex.Pattern;

public class SubnetFilter {

    public static boolean isIPAllowed(String ipAddress, String subnet, String subnetMask) throws UnknownHostException {
        byte[] ipBytes = InetAddress.getByName(ipAddress).getAddress();
        byte[] subnetBytes = InetAddress.getByName(subnet).getAddress();
        byte[] subnetMaskBytes = InetAddress.getByName(subnetMask).getAddress();

        for (int i = 0; i < ipBytes.length; i++) {
            if ((ipBytes[i] & subnetMaskBytes[i]) != (subnetBytes[i] & subnetMaskBytes[i])) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) throws UnknownHostException {
        String ip = "192.168.0.15";
        String subnet = "192.168.0.0";
        String subnetMask = "255.255.255.0";

        System.out.println(ip + " is allowed: " + isIPAllowed(ip, subnet, subnetMask));
    }
}

**代码解释：**
- `isIPAllowed`方法通过比较IP地址与子网掩码来确定是否在指定子网范围内。
- 在`main`方法中，我们检查 `192.168.0.15` 是否属于 `192.168.0.0/24` 子网内。

**结果说明：**
- `192.168.0.15` 在 `192.168.0.0/24` 子网范围内，输出为 `true`。

#### 5.3 IP地址的黑白名单管理

在实际应用中，可能需要维护IP地址的黑名单或白名单，以控制访问权限。以下是一个简单示例，展示如何管理IP地址的黑白名单：

import java.util.HashSet;
import java.util.Set;

public class IPBlackWhiteList {

    private static Set<String> blackList = new HashSet<>();
    private static Set<String> whiteList = new HashSet<>();

    public static void addToBlackList(String ipAddress) {
        blackList.add(ipAddress);
    }

    public static void addToWhiteList(String ipAddress) {
        whiteList.add(ipAddress);
    }

    public static boolean isAllowed(String ipAddress) {
        if (blackList.contains(ipAddress)) {
            return false; // IP在黑名单中
        } else if (whiteList.contains(ipAddress)) {
            return true; // IP在白名单中
        } else {
            return false; // 没有在白名单中，也不是黑名单中的IP
        }
    }

    public static void main(String[] args) {
        addToBlackList("10.0.0.1");
        addToWhiteList("192.168.1.1");

        String ip = "10.0.0.1";
        System.out.println(ip + " is allowed: " + isAllowed(ip));

        ip = "192.168.1.1";
        System.out.println(ip + " is allowed: " + isAllowed(ip));

        ip = "172.16.0.1";
        System.out.println(ip + " is allowed: " + isAllowed(ip));
    }
}

**代码解释：**
- `addToBlackList` 和 `addToWhiteList` 方法用于添加IP地址到黑名单和白名单。
- `isAllowed` 方法检查IP地址是否在黑白名单中。
- 在 `main` 方法中，我们添加IP地址到黑白名单，并检查不同IP地址的访问权限。

**结果说明：**
- `10.0.0.1` 在黑名单中，输出为 `false`。
- `192.168.1.1` 在白名单中，输出为 `true`。
- `172.16.0.1` 既不在黑名单也不在白名单中，输出为 `false`。

# 6. IP地址的网络通信操作

在Java中，IP地址的网络通信操作通常通过Socket来实现，Socket是网络通信的基础。下面将介绍如何基于Socket进行简单的IP地址通信应用。

#### 6.1 基于Socket的网络通信

网络通信中，Socket是用于描述IP地址和端口的工具，能够建立客户端和服务器之间的连接。在Java中，可以使用Socket类来实现网络通信。

import java.net.Socket;

public class Client {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("127.0.0.1", 8080);
            // 连接到服务器端的IP地址为127.0.0.1，端口号为8080
            System.out.println("成功连接到服务器端");
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

#### 6.2 IP地址与端口的绑定

在网络通信中，除了IP地址外，端口号也是非常重要的，可以通过端口实现不同服务的区分。下面是一个简单的服务器端代码，展示了IP地址与端口的绑定：

import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8080);
            // 监听本地的8080端口
            System.out.println("服务器启动，等待客户端连接...");
            Socket socket = serverSocket.accept();
            // 等待客户端连接
            System.out.println("客户端连接成功：" + socket.getInetAddress());
            socket.close();
            serverSocket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

#### 6.3 实现简单的IP地址通信应用

通过上面的客户端和服务器端代码，我们可以实现一个简单的IP地址通信应用。客户端连接到服务器端的IP地址和端口号，实现简单的通信。

在此案例中，我们展示了如何使用Socket在Java中进行IP地址的网络通信操作，通过建立连接和绑定端口实现简单的通信功能。读者可以根据需求进一步扩展和优化这段代码。