以字符串格式递增 IP 地址答案

【问题标题】：Incrementing through IP addresses in String format以字符串格式递增 IP 地址
【发布时间】：2021-12-31 13:52:43
【问题描述】：

我是 java 新手，我正在尝试找到一种通过用户输入 IP 地址范围递增的方法。

例如从192.168.0.1 到192.168.0.255。然而，我的应用程序目前的工作方式是将 from 和 ip 地址作为String。

有没有一种方法可以增加用户输入 from 和 to 的所有 IP 地址？

希望这是有道理的，请不要喷我，我已经在寻找答案了！

编辑！

它实际上是通过地址范围ping，所以到目前为止，这里有一个小代码，“主机”是从另一个类传入的，我想循环访问地址：

    public static String stringPing(String stringPing, String host){

    String ipAddress;
    ipAddress = host;

    try
    {
        InetAddress inet = InetAddress.getByName(ipAddress);

        boolean status = inet.isReachable(2000); 

        if (status)
        {
            stringPing = "\n" +host +" is reachable";
            return stringPing;
        }
        else
        {
            stringPing = "\n" +host +" is unreachable";
            return stringPing;
        }
    }
    catch (UnknownHostException e)
    {
        System.err.println("Host does not exists");
    }
    catch (IOException e)
    {
        System.err.println("Error in reaching the Host");
    }

    return stringPing;

}

【问题讨论】：

如果你想让人们帮忙，你必须展示一些代码。您的问题也有点令人困惑..“增量通过”是什么意思..您的意思是迭代通过吗？如果您可以保证用户输入格式正确，则可以将其拆分为句点并使用 parseInt 进行编号，然后继续直到到达 255。
from 和 to 地址由用户输入。我必须找到一种方法来循环浏览用户输入的范围......
请参阅下面的@Dims 回答。这是正确的方法，适用于任何 IP 范围（不仅仅是 C 类）。 IPv4 地址只是网络字节顺序（大端）的 4 字节整数。
谢谢一百万，只是查看了一些答案，Dims 看起来很适合：)

标签： java string

【解决方案1】：

保持地址应为 - 作为 32 位整数，并以这种形式递增。仅在需要时将其从或转换为 String。示例如下。我的IPAddress 课程已完成且功能齐全。

class IPAddress {

    private final int value;

    public IPAddress(int value) {
        this.value = value;
    }

    public IPAddress(String stringValue) {
        String[] parts = stringValue.split("\\.");
        if( parts.length != 4 ) {
            throw new IllegalArgumentException();
        }
        value = 
                (Integer.parseInt(parts[0], 10) << (8*3)) & 0xFF000000 | 
                (Integer.parseInt(parts[1], 10) << (8*2)) & 0x00FF0000 |
                (Integer.parseInt(parts[2], 10) << (8*1)) & 0x0000FF00 |
                (Integer.parseInt(parts[3], 10) << (8*0)) & 0x000000FF;
    }

    public int getOctet(int i) {

        if( i<0 || i>=4 ) throw new IndexOutOfBoundsException();

        return (value >> (i*8)) & 0x000000FF;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();

        for(int i=3; i>=0; --i) {
            sb.append(getOctet(i));
            if( i!= 0) sb.append(".");
        }

        return sb.toString();

    }

    @Override
    public boolean equals(Object obj) {
        if( obj instanceof IPAddress ) {
            return value==((IPAddress)obj).value;
        }
        return false;
    }

    @Override
    public int hashCode() {
        return value;
    }

    public int getValue() {
        return value;
    }

    public IPAddress next() {
        return new IPAddress(value+1);
    }


}

public class App13792784 {

    /**
     * @param args
     */
    public static void main(String[] args) {


        IPAddress ip1 = new IPAddress("192.168.0.1");

        System.out.println("ip1 = " + ip1);

        IPAddress ip2 = new IPAddress("192.168.0.255");

        System.out.println("ip2 = " + ip2);

        System.out.println("Looping:");

        do {

            ip1 = ip1.next();

            System.out.println(ip1);

        } while(!ip1.equals(ip2));


    }

}

【讨论】：

看起来正是我所需要的。当我开始实施时，我会报告
@Brian，我不同意。我只使用与字节顺序无关的按位和移位运算符。整个 32 位整数是一个完整的二进制数，其中没有任何字节标记。字节顺序未知。如果您将int 传递给一些第三方网络例程，这将很重要，但它会被适当地转换，因为例程应该知道int 的字节序。
哦，顺便说一下 +1 - 这是解决这个问题的正确方法。
@Brian，但你认为交换代码在哪里？例如，构造函数代码不交换任何内容：IP 地址的最左边部分 (192) 转到部件数组的最左边部分 (part[0])，然后转到值的最左边部分 (& 0xFF000000)。最左边总是保持在最左边，没有交换。
@Dims - 我觉得自己像个白痴 - 我昨晚显然已经超过了啤酒：SO 的比例，我脑子里的东西完全混乱了......但还是继续打字。你是绝对正确的，我删除了我的 cmets。（我脑海中的倒退是您必须从网络字节顺序转换才能正确排序 IP 地址）。

【解决方案2】：

如果您只需要从 ip + 0...255 打印所有内容

public void iterateOverIPRange(String ip) {
    int i = 0;
    while(i < 256) {
        System.out.println(ip + "." + i)
        i++;
    }
}

或者如果你需要从 0 到 255：

public String[] iterateOverIPRange(String ip) {
    String[] ips = new ip[255];
    int i = 0;
    while(i < 256)) {
        String s = ip + "." + i;
        ips[i] = s;
        i++;
    }
    return ips;
}

如果要指定范围：

public String[] iterateOverIPRange(String ip, int from, int to) {
    String[] ips = new ip[to];
    int index = 0;
    while(from < (to + 1)) {
        String s = ip + "." + from;
        ips[index] = s;
        from++;
        index++;
    }
    return ips;
}

当您拥有 String[] 时，您可以简单地遍历它并 ping 每一个。

【讨论】：

我认为 From 和 To 是 192.168.0.1 和 192.168.0.255 只是 OP 给出的一个例子。
好了。现在应该遇到所有 3 件事。
我不确定这些是否合适。我认为我没有说清楚:(。从地址和到地址是由用户输入的，我需要一种在该范围内的所有地址之间循环的方法。但是，我面临的问题是从和到都是字符串。我需要一种方法来访问中间的每个地址...
您只需要将基本 IP 作为字符串（前 3 部分），然后将最后一部分作为 Int。你可以很容易地改变它，我敢肯定。即使您不能，这些方法中的任何一种都应该很容易更改以满足您的需求。如果您需要从字符串中提取整数，请使用Integer.parseInt(String)。请记住，如果它没有解析一个整数，它将抛出一个未经检查的NumberFormatException

【解决方案3】：

由于我不喜欢位移，我为我曾经制作的漏洞扫描器制作了自己的 IP 迭代构造。照原样，代码只是打印地址加上一个额外的点。如果您取消注释 ping 实用程序或端口扫描器，它也可以正常工作。

对于一些次优的变量名称和广泛的例外，我很抱歉，我写这个是出于我曾经写过的一个更整洁的类的记忆。这只是为了表明 Java 确实使我们能够在不使用位移位的情况下迭代更大范围的 IP，然后只遍历 1 个子网。

package com.cybergrinder.core;

import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class ScanClient {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    try {
        // get input from somewhere, in this case we use the scanner for convenience and testing
        // try for example with 192.0.0.0 and 192.255.255.255 to scan the entire 192-B ranges
        Scanner scanner = new Scanner(System.in);
        System.out.println("start part of the address");
        String rangeStart = scanner.nextLine();
        System.out.println("end part of the address");
        String rangeEnd = scanner.nextLine();

        int[] startAdrElements = new int[4];
        int[] endAdrElements = new int[4];

        // System.out.println(rangeStart.split("\\.")[0]);

        int startA1 = (Integer.parseInt(rangeStart.split("\\.")[0]));
        int startB1 = (Integer.parseInt(rangeStart.split("\\.")[1]));
        int startC1 = (Integer.parseInt(rangeStart.split("\\.")[2]));
        int startD1 = (Integer.parseInt(rangeStart.split("\\.")[3]));
        int endA = (Integer.parseInt(rangeEnd.split("\\.")[0]));
        int endB = (Integer.parseInt(rangeEnd.split("\\.")[1]));
        int endC = (Integer.parseInt(rangeEnd.split("\\.")[2]));
        int endD = (Integer.parseInt(rangeEnd.split("\\.")[3]));

        int a = 0, b = 0, c = 0, d = 0; // args to work with after itteration proces
        for (int startA = startA1; startA <= endA; startA++) {// max 255.255.255.255, could implement sanitisation later..

            a = startA;

            for (int startB = startB1; startB <= endB; startB++) {

                b = startB;

                for (int startC = startC1; startC <= endC; startC++) {

                    c = startC;

                    for (int startD = startD1; startD <= endD; startD++) {

                        d = startD;

                        // convert intArray to byteArray
                        int[] intArray = new int[] { a, b, c, d };
                        String address = "";
                        for (int e : intArray) {
                            address += e + ".";
                        }

                        try {
                            System.out.println(address);

                            // enable pinging
                            /*
                            address = address.substring(0, (address.length() - 1));
                            InetAddress ipBytes = InetAddress.getByName(address);
                            boolean up = false;
                            up = ipBytes.isReachable(500);

                            if (up == true) {
                                System.out.println("host at " + ipBytes + " is up");
                            }
                            */

                            // enable portscanning
                            /*
                             * int port = 80; Socket sock = new Socket();
                             * sock.connect(new InetSocketAddress(ipBytes,
                             * port), 2000); //if it does not connect flow
                             * goes to catch System.out.println(port +"/tcp"
                             * + " is open ");
                             */

                        } catch (Exception e) {

                            // e.printStackTrace(); System.out.println("host
                            // is down");

                        }

                    }
                }
            }
        }

    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } finally {
    }

}
}

【讨论】：

【解决方案4】：

只是简单的逻辑。我们可以使用以下逻辑（0.0.0.0 - 255.255.255.255）生成多达 40 亿（4228250625）个 IP

public class IpGenerator {
    public static void main(String[] args) throws Exception {
        int totalIP = 50000;//Set the total IPs to be generated
        String startIP= "10.10.1.1"; // Set the IP start range
        int A = Integer.parseInt(startIP.split("\\.")[0]);
        int B = Integer.parseInt(startIP.split("\\.")[1]);
        int C = Integer.parseInt(startIP.split("\\.")[2]);
        int D = Integer.parseInt(startIP.split("\\.")[3]);
        int total=0;
        while (total<=totalIP) {
            total++;
            if(255>D) {D++;}
            else {D=0;
                if(255>C) {C++;}
                else {C=0;
                    if(255>B) {B++;}
                    else {B=0;
                        if(255>A) {A++;}
                        else {
                            throw new Exception("IP LIMIT EXCEEDED !!!!!");
                        }
                    }
                }
            }
            String IP=A+"."+B+"."+C+"."+D;
            System.out.println("IP:"+IP);
        }
    }
}
Sample 
--------
...............
...............
...............
IP:10.10.193.251
IP:10.10.193.252
IP:10.10.193.253
IP:10.10.193.254
IP:10.10.193.255
IP:10.10.194.0
IP:10.10.194.1
IP:10.10.194.2
IP:10.10.194.3
IP:10.10.194.4
...............
...............
...............

【讨论】：

【解决方案5】：

只需将最后一位数字设为整数，并在执行过程中递增。

public String strIp = "192.168.0.";
public Sting ip;

for (int x = 1; x == 255, x++) {
    ip = strIp+x;
}

【讨论】：

我认为 From 和 To 是 192.168.0.1 和 192.168.0.255 只是 OP 给出的一个例子