Question

我有String喜欢这个

String ipAddress= "192.168.1.12";

我想将最后一个索引值12自动递增到

13
14
15

所以它会像这样

192.168.1.13
192.168.1.14
192.168.1.15

Answer 1

您必须在最后一个点处拆分初始字符串，获取最后一个部分的数值，递增它并将其附加到字符串的初始部分：

    int posOfLastNumber = ipAddress.lastIndexOf('.') + 1;
    String last = ipAddress.substring(posOfLastNumber);
    String first = ipAddress.substring(0, posOfLastNumber);

    int lastNumber = Integer.parseInt(last) + 1;
    ipAddress = first + lastNumber;

Answer 2

我也想使用拆分。但它已经显示出来了。或者，您只需使用substring和lastIndexOf获取最后一个点的位置。

int idx = ipAddress.lastIndexOf(".")+1;
int last = Math.min(Integer.parseInt((ipAddress.substring(idx)))+1, 255);
String newIpAddress = ipAddress.substring(0, idx) + last;

如果你愿意，上面的内容可以写成一行。

Answer 3

我用.字符打破字符串，将最后一个元素转换为int，递增它，然后重新加入它们：

String ipAddress= "192.168.1.12";

String[] elements = ipAddress.split("\\.");
elements[elements.length - 1] = 
    String.valueOf(Integer.parseInt(elements[elements.length - 1]) + 1);

String newAddress = String.join(".", elements);

Answer 4

考虑引用：

＆＃34;智能数据结构和哑代码比其他方式更好。＆＃34;
- Eric Raymond，大教堂和市集

你所拥有的不仅仅是一个简单的字符串。你拥有的是一个具有字符串表示和一些附加功能的对象。这可能是一件简单的事情：

class IPAddress {
    private int firstByte;
    private int secondByte;
    private int thirdByte;
    private int fourthByte;

    public IPAddress(int firstByte, int secondByte, int thirdByte, int fourthByte) {
        this.firstByte = firstByte;
        // etc.
    }

    public String toString() {
        return String.format("%1$s.%2$s.%3$s.%4$s", firstByte, secondByte, thirdByte, fourthByte);
    }

    public void increment() {
        // this would be a good place for bounds checking
        fourthByte++;
    }
}

这将功能封装到IPAddress数据类型本身，而不是要求消费代码在其上执行各种字符串解析逻辑。所有消费代码都需要在对象上调用.increment()。

如果原始输入是一个字符串，那么你可以在这里创建另一个构造函数，它接受一个字符串并将其解析为地址的四个字节。

Answer 5

首先，String是不可变的。如果我理解你的问题，你想要的东西从一个IP地址开始，然后返回下一个。通过递增溢出的八位字节（ip地址）。像，

private static String incrementIp(String str) {
    String[] parts = str.split("\\.");
    int oct1 = Integer.parseInt(parts[0]);
    int oct2 = Integer.parseInt(parts[1]);
    int oct3 = Integer.parseInt(parts[2]);
    int oct4 = Integer.parseInt(parts[3]);
    oct4++;
    if (oct4 > 255) {
        oct4 = 0;
        oct3++;
    }
    if (oct3 > 255) {
        oct3 = 0;
        oct2++;
    }
    if (oct2 > 255) {
        oct2 = 0;
        oct1++;
    }
    if (oct1 > 255) {
        oct1 = 0;
    }
    return String.format("%d.%d.%d.%d", oct1, oct2, oct3, oct4);
}

我们可以通过增加10次来测试这个，如

public static void main(String[] args) {
    String ipAddress = "192.168.1.254";
    for (int i = 0; i < 10; i++) {
        System.out.printf("Before: %s, After: %s%n", ipAddress,
                incrementIp(ipAddress));
        ipAddress = incrementIp(ipAddress);
    }
}

哪些输出（可能预期）

Before: 192.168.1.254, After: 192.168.1.255
Before: 192.168.1.255, After: 192.168.2.0
Before: 192.168.2.0, After: 192.168.2.1
Before: 192.168.2.1, After: 192.168.2.2
Before: 192.168.2.2, After: 192.168.2.3
Before: 192.168.2.3, After: 192.168.2.4
Before: 192.168.2.4, After: 192.168.2.5
Before: 192.168.2.5, After: 192.168.2.6
Before: 192.168.2.6, After: 192.168.2.7
Before: 192.168.2.7, After: 192.168.2.8

增加最后一个字符串索引值

5 个答案: