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");
             }
     }
 }