UVA 1590 IP Networks JAVA

题意：输入m代表接下来的数据个数，计算接下来输入数据的网络掩码，和最小网络地址。

思路：
①子网掩码：先将数据转为二进制，判断从哪一位开始有数据不一样，记下下标index,
则子网掩码是index的前面是1，后面是0（2#），就是子网掩码，再转为10#输出；

②最小网络地址：用任意一个IP与子网掩码进行按位与运算得出最小IP，与运算的符号为&。

import java.util.Scanner;

public class UVA1590 {

    public static void main(String[] args) {
            Scanner scanner=new Scanner(System.in);
            int m;
            while(scanner.hasNext())
            {
                m=scanner.nextInt();
                String[][] strTwo=new String[1000][4];//输入的数据存为二进制
                StringBuffer[] stringBuffer=new StringBuffer[4];
                int[] resCover=new int[4];//掩码结果 10#
                int[] resMin=new int[4];//最小网络地址结果 10#
                int [][] numTen = new int[1000][4];//输入的数据存为10进制
                for(int i=0;i<m;i++)
                {
                    String string=scanner.next();
                    String [] strTen=string.split("\\.");//"."有特殊含义，要加\\
                    int [] numTwo=new int[4];
                    for(int j=0;j<strTen.length;j++)
                    {
                        //ε=(´ο｀*)))唉，不知道为什么我这么麻烦
                        numTen[i][j]=Integer.parseInt(strTen[j].toString());//string->int  10#
                        strTwo[i][j]=Integer.toBinaryString(numTen[i][j]);//10#->2#
                        numTwo[j]=Integer.parseInt(strTwo[i][j]);//string->int 2#
                        strTwo[i][j]=String.format("%08d", numTwo[j]);//2# 标准化，如果有1000->00001000
                    }
                }
                int index=32;//最左一个不同出现的地方的下标，他前面全是1，后面全是0（子网掩码）
                boolean flag=true;
                for(int j=0;j<4&&flag;j++)
                {
        
                    for(int k=0;k<8&&flag;k++)
                    {
                        char ch=strTwo[0][j].charAt(k);
                        for(int l=0;l<m;l++)
                        {
                            if(strTwo[l][j].charAt(k)!=ch)
                            {
                                index=(j)*8+k;
                                flag=false;
                                break;
                            }
                        }
                    }
                }
                StringBuffer Cover=new StringBuffer();
                StringBuffer[] strCover=new StringBuffer[4];
                strCover[0]=new StringBuffer();
                strCover[1]=new StringBuffer();
                strCover[2]=new StringBuffer();
                strCover[3]=new StringBuffer();
                for(int j=0,n=0;j<32;j++)
                {
                    if(j<index)
                        strCover[j/8].append('1');
                    else
                        strCover[j/8].append('0');
                }
                for(int j=0;j<4;j++)
                    {
                        resCover[j]=Integer.parseInt(strCover[j].toString(), 2);
                    }

                int indexmin=0;//与掩码相与的下标

                for(int j=0;j<4;j++)
                {
                    int res=resCover[j]&numTen[indexmin][j];//任意一个子网与掩码相与，则为最小网络地址
                    resMin[j]=res;
                }
                
                for(int j=0;j<4;j++)
                {
                    if(j!=0)
                        System.out.print(".");
                    System.out.print(resMin[j]);
                }
                System.out.print("\n");
                for(int j=0;j<4;j++)
                {
                    if(j!=0)
                        System.out.print(".");
                    System.out.print(resCover[j]);
                }
                System.out.print("\n");
            }
    }
}