java 如何按升序对ip地址进行排序

How to sort ip address in ascending order

提问by John

Is there any method to sort this? Or do I just need to split it and use a loop to compare? Input

有什么方法可以排序吗？还是我只需要拆分它并使用循环进行比较？输入

123.4.245.23
104.244.253.29
1.198.3.93
32.183.93.40
104.30.244.2
104.244.4.1

Output

输出

1.198.3.93
32.183.93.40
104.30.244.2
104.244.4.1
104.244.253.29
123.4.245.23

So far I use HashMap to stored my data. I want sort the value by the Ip address in ascending order. Seems TreeMap is better choice?

到目前为止，我使用 HashMap 来存储我的数据。我想按升序按 Ip 地址对值进行排序。似乎 TreeMap 是更好的选择？

回答by Dan

TLDR

TLDR

You may jump directly to an efficient comparison method (See Editsection below) OR
continue your reading.

您可以直接跳转到有效的比较方法（请参阅下面的编辑部分）或
继续阅读。

---

---

In order to sort IPs you first need to know a bit about them. There are two types of IPs; 32 Bitand 128 Bit.

为了对 IP 进行排序，您首先需要对它们有所了解。IP有两种类型；32 Bit和128 Bit。

32 BitSource

32位源

• The 32 bit IPis split into 4 groups of numbers between 0and 255. These groups are seperated via a .
• A single group, as shown above, is 8 bits of data. This is the reason the numbers in a group are limited between 0and 255.
• For a 32 bit IPto be formatted correctly it should be int.int.int.int. Even if the int is a 0it must be shown in the IP address. This is different to a 128 bit IPwhich may omit 0s. For example ::5:which is the same as 0:0:5:0:0:0:0:0.

• 将32 bit IP被分成4组，每组之间的数字的0和255。这些组通过一个.
• 如上所示，单个组是 8 位数据。这就是组中的数字限制在0和之间的原因255。
• 要32 bit IP正确格式化a ，它应该是int.int.int.int. 即使 int 是 a0它也必须显示在 IP 地址中。这与128 bit IP可以省略0s 的a 不同。例如::5:，这与0:0:5:0:0:0:0:0.

128 BitSource

128 位源

• The 128 bit IPis split into 8 groups of numbers between 0and FFFF(which is equivalent to 65535). Unlike a 32 bit IPsgroup, these groups are separated buy a :.
• A single group, as show above, is 16 bits of data. This is the reason the numbers in the groups are limited between 0and FFFF.
• To format a 128 bit IPproperly there are several rules you have to follow. 0s may be omitted from groups and if the remaining groups all are 0then the groups may also be omitted. The groups have to be separated by a :. If you are omitting groups the last group which isn't a 0has to be followed by a :. These rules leave us with a format int:int:int:int:int:int:int:int. An example of 0s and groups being omitted would be 58f:::fff:2:. This is the same as 58f:0:0:fff:2:0:0:0.

• 的128 bit IP被分成8组之间的数字的0和FFFF（它等效于65535）。与32 bit IPs组不同，这些组是分开购买的:。
• 如上所示，单个组是 16 位数据。这就是组中的数字限制在0和之间的原因FFFF。
• 要128 bit IP正确格式化 a，您必须遵循几条规则。0s 可以从组中省略，如果剩余的组都是，0则也可以省略组。这些组必须以:.分隔。如果您省略组，则不是 a 的最后一组0必须后跟 a :。这些规则给我们留下了格式int:int:int:int:int:int:int:int。0s 和组被省略的一个例子是58f:::fff:2:. 这与58f:0:0:fff:2:0:0:0.

Sorting

排序

Once the IPs have been sorted into their respective groups they can be sorted. To sort an IP you need to use a method called weighting. This is because simply adding or multiplying different groups together wouldn't work. For example take the these two IPs; 192.5.48.198and 198.48.5.192. If you add or multiply the values of the groups together you get the same answer. So there is no way to accurately compare them using addition and multiplication. If you use weighting you get something like this.

一旦 IP 被分类到它们各自的组中，它们就可以被分类。要对 IP 进行排序，您需要使用一种称为加权的方法。这是因为简单地将不同的组相加或相乘是行不通的。以这两个IP为例；192.5.48.198和198.48.5.192。如果将组的值相加或相乘，您会得到相同的答案。所以没有办法使用加法和乘法来准确比较它们。如果你使用加权，你会得到这样的结果。

32 Bit Weighting

32 位加权

Value of IP = (Group one value * 256^4) + (Group two value * 256^3) +
              (Group three value * 256^2) + (Group four value * 256)

128 Bit Weighting

128 位加权

Value of IP = (Group one value * 65536^8) + (Group two value * 65536^7) +
              (Group three value * 65536^6) + (Group four value * 65536^5) +
              (Group five value * 65536^4) + (Group six value * 65536^3) +
              (Group seven value * 65536^2) + (Group eight value * 65536)

The Code in Java

Java 中的代码

As long as the IP is formatted reasonably correctly this code will separate the two kinds of IP and then sort them.

只要 IP 的格式合理正确，此代码就会将两种 IP 分开，然后对它们进行排序。

import java.util.*;
import java.math.*; //For BigInteger
import java.util.regex.*;
import java.lang.*;

public class IPSort
{
    String[] tests = {":8:","::::5:6::8","::::5:6::7","::::5:6::8","123..245.23","1...","..1.","123...23",".1..","123..245.23", "123..245.23", "104.244.253.29", "1.198.3.93", "32.183.93.40", "32.183.93.40", "104.30.244.2", "104.244.4.1","0.0.0.1",":a:","::5:3:4:5:6:78","1::2:3","1::2:3:4","1::5:256.2.3.4","1:1:3000.30.30.30","ae80::217:f2ff:254:7:237:98"};
    ArrayList<String> bit32 = new ArrayList<String>();
    ArrayList<String> bit128 = new ArrayList<String>();
    ArrayList<String> cleanBit32 = new ArrayList<String>();
    ArrayList<String> cleanBit128 = new ArrayList<String>();

    boolean myMatcher32Bit(String s)
    {
        Pattern patter32Bit = Pattern.compile("^(?=(?:[^.]*\.){3}[^.]*$)(?=(?:[^:]*:){0}[^:]*$)(?=(?:[^a-zA-Z]*[^a-zA-Z])*$)");
        Matcher matcher32Bit = patter32Bit.matcher(s);
        return matcher32Bit.find();
    }

    boolean myMatcher128Bit(String s)
    {
        Pattern patter128Bit = Pattern.compile("^(?=(?:[^.]*\.){0}[^.]*$)(?=(?:[^:]*:){1,7}[^:]*$)");
        Matcher matcher128Bit = patter128Bit.matcher(s);
        return matcher128Bit.find();
    }

    public void sortIntoRespectiveIPTypes()
    {
        for(String s: tests)
        {
            if(myMatcher32Bit(s))
            {
                bit32.add(s);
            }
            else if(myMatcher128Bit(s))
            {
                bit128.add(s);
            }
        }

        System.out.println("32 bit IPs");
        for(String ip: bit32)
        {
            System.out.println("  "+ip);
        }

        System.out.println("\n128 bit IPs");
        for(String ip: bit128)
        {
            System.out.println("  "+ip);
        }

        int count = 0;
        for(String ip: tests)
        {
            if(myMatcher32Bit(ip)==false && myMatcher128Bit(ip)==false)
            {
                count++;
            }
        }

        if(count != 0)
        {
            System.out.println("\nDidn't match an IP format");
            for(String ip: tests)
            {
                if(myMatcher32Bit(ip)==false && myMatcher128Bit(ip)==false)
                {
                    System.out.println("  "+ip);
                }
            }
        }

    }

    public void sort32BitIPs(ArrayList<String> bit32, ArrayList<String> newBit32)
    {
        ArrayList<BigInteger> bigInt32Bit = new ArrayList<BigInteger>();
        for(String ip:bit32)
        {
            String[] tempArray = ip.split("\.");
            int i=0;
            for(String s:tempArray)
            {
                if(s.equals(""))
                {
                    tempArray[i]="0";
                }
                i++;
            }
            bigInt32Bit.add(convert32Bit(tempArray));
        }

        Collections.sort(bigInt32Bit);

        ArrayList<String> fixFormat = new ArrayList<String>();
        for(String ip:bit32)
        {
            String[] fixArray = ip.split("\.");
            int i=0;
            for(String s:fixArray)
            {
                if(s.equals(""))
                {
                    fixArray[i]="0";
                }
                i++;
            }

            StringBuilder strBuilder = new StringBuilder();
            for(int i2 = 0; i2 < 4; i2++) 
            {
                if(i2<3)
                {
                    try
                    {
                        if(!fixArray[i2].equals(""))
                        {
                            strBuilder.append(fixArray[i2]+".");
                        }
                        else
                        {
                            strBuilder.append(".");
                        }
                    }
                    catch(Exception e)
                    {
                        strBuilder.append("0.");
                    }
                }
                else
                {
                    try
                    {
                        strBuilder.append(fixArray[i2]);
                    }
                    catch(Exception e)
                    {
                        strBuilder.append("0");
                    }
                }
            }
            String newString = strBuilder.toString();
            fixFormat.add(newString);
            bit32=fixFormat;
        }

        for(BigInteger finalValue:bigInt32Bit)
        {
            for(String ip:bit32)
            {
                String[] tempArray = ip.split("\.");
                int i=0;
                for(String s:tempArray)
                {
                    if(s.equals(""))
                    {
                        tempArray[i]="0";
                    }
                    i++;
                }
                if(finalValue.equals(convert32Bit(tempArray)))
                {
                    if(!newBit32.contains(ip))
                    {
                        String str = bit32.toString();
                        String findStr = ip;
                        int lastIndex = 0;
                        int count = 0;

                        while(lastIndex != -1){

                            lastIndex = str.indexOf(findStr,lastIndex);

                            if(lastIndex != -1){
                                count++;
                                lastIndex += findStr.length();
                            }
                        }

                        for(int k = 0; k<count;k++)
                        {
                            newBit32.add(ip);
                        }
                    }
                }
            }
        }
    }

    BigInteger convert32Bit(String[] array)
    {
        int[] tempArray = new int[array.length];
        ArrayList<BigInteger> tempBigIntList = new ArrayList<BigInteger>();
        int i = 0;
        for(String s:array)
        {
            int power = 4-i;
            tempArray[i]= Integer.parseInt(s);
            String string = Integer.toString(tempArray[i]);
            BigInteger myBigInt = new BigInteger(string);
            BigInteger num2 = myBigInt.multiply(new BigInteger("256").pow(power));
            tempBigIntList.add(num2);
            i++;
        }
        BigInteger bigInt32Bit = new BigInteger("0");
        for(BigInteger bI:tempBigIntList)
        {
            bigInt32Bit = bigInt32Bit.add(bI);
        }
        return bigInt32Bit;
    }

    public void sort128BitIPs(ArrayList<String> bit128,ArrayList<String> newBit128)
    {
        ArrayList<BigInteger> bigInt128Bit = new ArrayList<BigInteger>();
        for(String ip:bit128)
        {
            String[] tempArray = ip.split(":");
            int i=0;
            for(String s:tempArray)
            {
                if(s.equals(""))
                {
                    tempArray[i]="0";
                }
                i++;
            }
            bigInt128Bit.add(convert128Bit(tempArray));
        }

        Collections.sort(bigInt128Bit);

        for(BigInteger finalValue:bigInt128Bit)
        {
            for(String ip:bit128)
            {
                String[] tempArray = ip.split(":");
                int i=0;
                for(String s:tempArray)
                {
                    if(s.equals(""))
                    {
                        tempArray[i]="0";
                    }
                    i++;
                }
                if(finalValue.equals(convert128Bit(tempArray)))
                {
                    if(!newBit128.contains(ip))
                    {
                        String str = bit128.toString();
                        String findStr = ip;
                        int lastIndex = 0;
                        int count = 0;

                        while(lastIndex != -1){

                            lastIndex = str.indexOf(findStr,lastIndex);

                            if(lastIndex != -1){
                                count++;
                                lastIndex += findStr.length();
                            }
                        }

                        for(int k = 0; k<count;k++)
                        {
                            newBit128.add(ip);
                        }
                    }
                }
            }
        }
    }

    BigInteger convert128Bit(String[] array)
    {
        int[] tempArray = new int[array.length];
        ArrayList<BigInteger> tempBigIntList = new ArrayList<BigInteger>();
        int i = 0;
        for(String s:array)
        {
            int power = 8-i;
            tempArray[i]= Integer.parseInt(s,16);
            String string = Integer.toString(tempArray[i]);
            BigInteger myBigInt = new BigInteger(string);
            BigInteger num2 = myBigInt.multiply(new BigInteger("65536").pow(power));
            tempBigIntList.add(num2);
            i++;
        }
        BigInteger bigInt128Bit = new BigInteger("0");
        for(BigInteger bI:tempBigIntList)
        {
            bigInt128Bit = bigInt128Bit.add(bI);
        }
        return bigInt128Bit;
    }

    public void printInOrder(ArrayList<String> bit32,ArrayList<String> bit128)
    {
        System.out.println("\nSorted IPs");

        System.out.println("Sorted 32 bit IPs - Ascending");
        for(String ip: bit32)
        {
            System.out.println("  "+ip);
        }

        Collections.reverse(bit32);
        System.out.println("\nSorted 32 bit IPs - Descending");
        for(String ip: bit32)
        {
            System.out.println("  "+ip);
        }

        System.out.println("\nSorted 128 bit IPs - Ascending");
        for(String ip: bit128)
        {
            System.out.println("  "+ip);
        }

        Collections.reverse(bit128);
        System.out.println("\nSorted 128 bit IPs - Descending");
        for(String ip: bit128)
        {
            System.out.println("  "+ip);
        }
    }

    public void run(ArrayList<String> bit32,ArrayList<String> bit128,ArrayList<String> newBit32,ArrayList<String> newBit128)
    {
        sortIntoRespectiveIPTypes();
        sort32BitIPs(bit32,newBit32);
        sort128BitIPs(bit128,newBit128);
        printInOrder(newBit32,newBit128);
    }

    public static void main(String[] args)
    {
        IPSort ipS = new IPSort();
        ipS.run(ipS.bit32,ipS.bit128,ipS.cleanBit32,ipS.cleanBit128);
    }
}

As a note it is possible to use this classto sort IPs but my code does not use it

请注意，可以使用此类对 IP 进行排序，但我的代码不使用它

This code also sorts the list into an ascending order, then into a descending order. This is printed out in the command console when the code is run

此代码还将列表按升序排序，然后按降序排序。这是在代码运行时在命令控制台中打印出来的

Output

输出

Edit

编辑

A more efficient and accurate way to do it is with the InetAddressclassmentioned above. Credits to 200_successfor code.

一种更有效和准确的方法是使用上面提到的InetAddress类。学分200_success代码。

import java.net.InetAddress;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.UnknownHostException;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Optional;
import java.util.stream.Stream;

public class IPSort {
    private static String[] TESTS = {"0:0:0:0:0:0:fff:ffff","::FFFF:222.1.41.90",":8:","::::5:6::8","::::5:6::7","::::5:6::8","123..245.23","1...","..1.","123...23",".1..","123..245.23", "123..245.23", "104.244.253.29", "1.198.3.93", "32.183.93.40", "32.183.93.40", "104.30.244.2", "104.244.4.1","0.0.0.1",":a:","::5:3:4:5:6:78","1::2:3","1::2:3:4","1::5:256.2.3.4","1:1:3000.30.30.30","ae80::217:f2ff:254:7:237:98","::2:3:4:5:6:7","2:3:4:5:6:7","::5:3:4:5:6:7:8","::5:3:4:5:6:7:8:9:0","1::8","1::2:3","1::2:3:4","1::5:256.2.3.4","1:1:3000.30.30.30","ae80::217:f2ff:254.7.237.98","1:2:3:4::5:1.2.3.4","2001:0000:1234:0000:0000:C1C0:ABCD:0876","12345::6:7:8","1::1.2.900.4","fe80::","::ffff:0:0"};

    public static class InetAddressComparator implements Comparator<InetAddress> {
        @Override
        public int compare(InetAddress a, InetAddress b) {
            byte[] aOctets = a.getAddress(),
                   bOctets = b.getAddress();
            int len = Math.max(aOctets.length, bOctets.length);
            for (int i = 0; i < len; i++) {
                byte aOctet = (i >= len - aOctets.length) ?
                    aOctets[i - (len - aOctets.length)] : 0;
                byte bOctet = (i >= len - bOctets.length) ?
                    bOctets[i - (len - bOctets.length)] : 0;
                if (aOctet != bOctet) return (0xff & aOctet) - (0xff & bOctet);
            }
            return 0;
        }
    }

    public static Optional<InetAddress> toInetAddress(String s) {
        try {
            return Optional.of(InetAddress.getByName(s));
        } catch (UnknownHostException badAddress) {
            return Optional.empty();
        }
    }

    public static void main(String[] args) throws Exception {
        System.out.println("Valid 32-bit addresses");
        Arrays.stream(TESTS)
              .map(IPSort::toInetAddress)
              .filter(Optional::isPresent)
              .map(Optional::get)
              .filter((addr) -> addr instanceof Inet4Address)
              .map(InetAddress::getHostAddress)
              .forEach(System.out::println);

        System.out.println("\nValid 128-bit addresses");
        Arrays.stream(TESTS)
              .map(IPSort::toInetAddress)
              .filter(Optional::isPresent)
              .map(Optional::get)
              .filter((addr) -> addr instanceof Inet6Address)
              .map(InetAddress::getHostAddress)
              .forEach(System.out::println);

        System.out.println("\nInvalid addresses");
        Arrays.stream(TESTS)
              .filter((s) -> !toInetAddress(s).isPresent())
              .forEach(System.out::println);

        System.out.println("\nSorted addresses");
        Arrays.stream(TESTS)
              .map(IPSort::toInetAddress)
              .filter(Optional::isPresent)
              .map(Optional::get)
              .sorted(new InetAddressComparator())
              .map(InetAddress::getHostAddress)
              .forEach(System.out::println);
    }
}

回答by totymedli

I would suggest to implement your own Comparator. See this post: Sorting IP addresses in Java

我建议实现你自己的比较器。请参阅此帖子：在 Java 中对 IP 地址进行排序

Copy paste only for you:

只为您复制粘贴：

/**
 * LGPL
 */
public class InetAddressComparator implements Comparator {
    @Override
    public int compare(InetAddress adr1, InetAddress adr2) {
        byte[] ba1 = adr1.getAddress();
        byte[] ba2 = adr2.getAddress();

        // general ordering: ipv4 before ipv6
        if(ba1.length < ba2.length) return -1;
        if(ba1.length > ba2.length) return 1;

        // we have 2 ips of the same type, so we have to compare each byte
        for(int i = 0; i < ba1.length; i++) {
            int b1 = unsignedByteToInt(ba1[i]);
            int b2 = unsignedByteToInt(ba2[i]);
            if(b1 == b2)
                continue;
            if(b1 < b2)
                return -1;
            else
                return 1;
        }
        return 0;
    }

    private int unsignedByteToInt(byte b) {
        return (int) b & 0xFF;
    }
}

回答by AlexWien

For the ip4 adresses you showed you just need to split it up. then i would convert it to a long value, and sort by that.

对于您显示的 ip4 地址，您只需要将其拆分即可。然后我会将它转换为一个长值，并以此排序。

long value = f3 + f2*256 + f1 * 256^2 + f0 * 256^3

where f0 - f3 are the splitted values.

其中 f0 - f3 是拆分值。

回答by Yogendra Singh

Pad each fragment in IPto length 3and then sorte.g. below:

将每个片段填充IP到长度3，然后sort例如在下面：

    List<String> ipList = new ArrayList<String>();
    ipList.add("123.4.245.23");
    ipList.add("104.244.253.29");
    ipList.add("1.198.3.93");
    ipList.add("32.183.93.40");
    ipList.add("104.30.244.2");
    ipList.add("104.244.4.1");
    Collections.sort(ipList, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            String[] ips1 = o1.split("\.");
            String updatedIp1 = String.format("%3s.%3s.%3s.%3s",
                                                  ips1[0],ips1[1],ips1[2],ips1[3]);
            String[] ips2 = o2.split("\.");
            String updatedIp2 = String.format("%3s.%3s.%3s.%3s",
                                                  ips2[0],ips2[1],ips2[2],ips2[3]);
            return updatedIp1.compareTo(updatedIp2);
        }
    });
    //print the sorted IP
    for(String ip: ipList){
        System.out.println(ip);
    }

---

---

It prints:

它打印：

1.198.3.93
32.183.93.40
104.30.244.2
104.244.4.1
104.244.253.29
123.4.245.23

1.198.3.93
32.183.93.40
104.30.244.2
104.244.4.1
104.244.253.29
123.4.245.23

回答by shashidhar kache

public class IpSort {  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        String[] arr = {"192.168.1.1",  
            "191.122.123.112",  
            "192.161.1.1",  
            "191.122.123.1",  
            "123.24.5.78",  
            "121.24.5.78",  
            "123.24.4.78",  
            "123.2.5.78",  
            "192.1.1.1",  
            "125.45.67.89",  
            "1.1.1.1",  
            "3.4.5.6",  
            "2.2.2.2",  
            "6.6.6.7",  
            "155.155.23.0"};  
        String tmp;  
        for(int i=0;i<arr.length;i++)  
        {  
                  for(int j=1;j<arr.length-i;j++)  
                  {  
                      String[] instr1 = arr[j-1].split("\.");  
                      String[] instr2 = arr[j].split("\.");  
                           if(Integer.parseInt(instr1[0]) > Integer.parseInt(instr2[0]))  
                           {  
                               tmp=arr[j-1];  
                               arr[j-1]=arr[j];  
                               arr[j]=tmp;  
                           }else if(Integer.parseInt(instr1[0]) == Integer.parseInt(instr2[0])  
                         && Integer.parseInt(instr1[1]) > Integer.parseInt(instr2[1]) )  
                           {  
                                tmp=arr[j-1];  
                                arr[j-1]=arr[j];  
                                arr[j]=tmp;  
                           } else if(Integer.parseInt(instr1[0]) == Integer.parseInt(instr2[0])  
                         && Integer.parseInt(instr1[1]) == Integer.parseInt(instr2[1])  
                         && Integer.parseInt(instr1[2]) > Integer.parseInt(instr2[2]) )  
                           {  
                                tmp=arr[j-1];  
                                arr[j-1]=arr[j];  
                                arr[j]=tmp;  
                           } else if(Integer.parseInt(instr1[0]) == Integer.parseInt(instr2[0])  
                         && Integer.parseInt(instr1[1]) == Integer.parseInt(instr2[1])  
                         && Integer.parseInt(instr1[2]) == Integer.parseInt(instr2[2])  
                         && Integer.parseInt(instr1[3]) > Integer.parseInt(instr2[3]) )  
                           {  
                               tmp=arr[j-1];  
                               arr[j-1]=arr[j];  
                               arr[j]=tmp;  
                           }  
                  }  

        }  
        System.out.println("final sorted list of ips :\n");  
        for(int k=0;k<arr.length;k++){  
            System.out.println(arr[k]);  
        }  
    }  
}  

回答by otamega

In Java8

在 Java8 中

import java.math.BigInteger;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.AbstractMap;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Map;

class Test {
    private static final Comparator<InetAddress> COMPARATOR = Comparator
            .comparing(InetAddress::getAddress,
                    Comparator.comparingInt((byte[] b) -> b.length)
                    .thenComparing(b -> new BigInteger(1, b)));

    public static void main(String[] args) {
        final String[] addresses = {
                "123.4.245.23",
                "104.244.253.29",
                "1.198.3.93",
                "32.183.93.40",
                "104.30.244.2",
                "104.244.4.1"
        };

        for (final String address : sort(addresses)) {
            System.out.println(address);
        }
    }

    public static String[] sort(final String[] addresses) {
        return Arrays.stream(addresses)
                .map(s -> new AbstractMap.SimpleImmutableEntry<>(toInetAddress(s), s))
                .sorted(Comparator.comparing(Map.Entry::getKey, Comparator.nullsLast(COMPARATOR)))
                .map(Map.Entry::getValue)
                .toArray(String[]::new);
    }

    private static InetAddress toInetAddress(final String address) {
        try {
            return InetAddress.getByName(address);
        } catch (final UnknownHostException | SecurityException e) {
            e.printStackTrace();
            return null;
        }
    }
}

Output:

输出：

1.198.3.93
32.183.93.40
104.30.244.2
104.244.4.1
104.244.253.29
123.4.245.23

回答by junaidp

Try this one

试试这个

@Override
public int compare(Object adr1, Object adr2) {
    try
    {
        if(adr1 == null || adr1.toString().isEmpty()) return -1;
        if(adr2 == null || adr2.toString().isEmpty()) return 1;
        String[] ba1 = adr1.toString().split( "\." );
        String[] ba2 = adr2.toString().split( "\." );

        for ( int i = 0; i < ba1.length; i++ )
        {
            int b1 = Integer.parseInt( ba1[ i ] );
            int b2 = Integer.parseInt( ba2[ i ] );

            if (b1 == b2)
                continue;
            if (b1 < b2)
                return -1;
            else
                return 1;
        }
        return 0;
    }
    catch ( Exception ex )
    {
        return 0;
    }

}

回答by sandy.sm

How about this plain logic:

这个简单的逻辑怎么样：

Ip Address: [10.1.1.2, 10.22.33.11, 10.12.23.12]

ip地址：[10.1.1.2, 10.22.33.11, 10.12.23.12]

1) Fill in the IP to complete 12 digits format with prefix 0: like [010.001.001.002, 010.022.033.011, 010.012.023,012]

1) 填写IP，以0为前缀完成12位数字格式：如[010.001.001.002, 010.022.033.011, 010.012.023,012]

2) Remove "."s to make it complete string of digits: [010001001002, 010022033011, 010012023012]

2) 删除“.”以使其成为完整的数字字符串：[010001001002, 010022033011, 010012023012]

3) Apply Sort [010001001002, 010012023012, 010022033011]

3) 应用排序 [010001001002, 010012023012, 010022033011]

4) Retain dots after every 3 digits: [010.001.001.002, 010.012.023.012, 010.022.033.011]

4）每3位保留点：[010.001.001.002, 010.012.023.012, 010.022.033.011]

5) Remove prefix 0's [10.1.1.2, 10.12.23.12, 10.22.33.11]

5) 移除前缀 0 的 [10.1.1.2, 10.12.23.12, 10.22.33.11]

6) Sorted!

6）排序！

回答by sunny

public class SortIP
{

    public static String getFormattedIP(String ip)
    {
        String arg[] = new String[4];
        arg = (ip).split("\.");

        int i=0;
        while(i<=3)
        {
            if(arg[i].length()==1)
            {
                arg[i]="00"+arg[i];
            }
            else if(arg[i].length()==2)
            {
                arg[i]="0"+arg[i];
            }

            i++;
        }

        return arg[0]+arg[1]+arg[2]+arg[3];
    }

    public static ArrayList<Integer> sortedList(Object[] obj,String order)
    {
        if(order.equalsIgnoreCase("Ascending"))
        {
            Arrays.sort(obj, new Comparator() {
                public int compare(Object o1, Object o2) {
                    return ((Map.Entry<Integer, Long>) o1).getValue()
                               .compareTo(((Map.Entry<Integer, Long>) o2).getValue());
                }
            });
        }
        else
        {
            Arrays.sort(obj, new Comparator() {
                public int compare(Object o1, Object o2) {
                    return ((Map.Entry<Integer, Long>) o2).getValue()
                               .compareTo(((Map.Entry<Integer, Long>) o1).getValue());
                }
            });
        }

        int counter=0;
        ArrayList<Integer> key = new ArrayList<Integer>();
        //int key[] = new int[ipRange.size()];

        for (Object e : obj) {
            key.add(((Map.Entry<Integer, Long>) e).getKey());
            //key[counter++]=((Map.Entry<Integer, Long>) e).getKey();

            System.out.println(((Map.Entry<Integer, Long>) e).getKey() + " : " + ((Map.Entry<Integer, Long>) e).getValue());
        }

        return key;
    }

    public static void main(String[] args) 
    {
        Map<Integer,String> ipRange= new TreeMap<Integer,String>();
        Map<Integer,Long> formatedIpRange= new TreeMap<Integer,Long>();

        ipRange.put(1, "10.1.4.100");
        ipRange.put(2, "1.10.400.10");
        ipRange.put(3, "196.0.14.15");
        ipRange.put(4, "196.70.5.1");
        ipRange.put(5, "196.70.7.3");
        ipRange.put(6, "153.70.7.0");

        for(int j=1;j<=ipRange.size();j++)
        {
            formatedIpRange.put(j, Long.parseLong(getFormattedIP(ipRange.get(j))));
        }

        Object[] a = formatedIpRange.entrySet().toArray();

        ArrayList<Integer> key = sortedList(a,"descending");

        System.out.println("ordered list ");

        for (Integer integer : key) 
        {
            System.out.println(ipRange.get(integer));
        }
    }
}