解题2（IpIsSameSubNet）

题目描述

子网掩码是用来判断任意两台计算机的IP地址是否属于同一子网络的根据。
子网掩码与IP地址结构相同，是32位二进制数，其中网络号部分全为“1”和主机号部分全为“0”。利用子网掩码可以判断两台主机是否中同一子网中。若两台主机的IP地址分别与它们的子网掩码相“与”后的结果相同，则说明这两台主机在同一子网中。

示例：
I P 地址　 192.168.0.1
子网掩码　 255.255.255.0

转化为二进制进行运算：

I P 地址　11010000.10101000.00000000.00000001
子网掩码　11111111.11111111.11111111.00000000

AND运算
 　　　　11000000.10101000.00000000.00000000

转化为十进制后为：
 　　　　192.168.0.0

I P 地址　 192.168.0.254
子网掩码　 255.255.255.0

转化为二进制进行运算：

I P 地址　11010000.10101000.00000000.11111110
子网掩码　11111111.11111111.11111111.00000000

AND运算
　　　　　11000000.10101000.00000000.00000000

转化为十进制后为：
　　　　　192.168.0.0

通过以上对两台计算机IP地址与子网掩码的AND运算后，我们可以看到它运算结果是一样的。均为192.168.0.0，所以这二台计算机可视为是同一子网络。

/* 
* 功能: 判断两台计算机IP地址是同一子网络。 
* 输入参数：    String Mask: 子网掩码，格式：“255.255.255.0”； 
*               String ip1: 计算机1的IP地址，格式：“192.168.0.254”；
*               String ip2: 计算机2的IP地址，格式：“192.168.0.1”；
*

* 返回值：      0：IP1与IP2属于同一子网络；     1：IP地址或子网掩码格式非法；    2：IP1与IP2不属于同一子网络
*/ 
public int checkNetSegment(String mask, String ip1, String ip2) 
{     
    /*在这里实现功能*/
    return 0;
}

输入描述:

输入子网掩码、两个ip地址

输出描述:

得到计算结果

示例1

输入

255.255.255.0 192.168.224.256 192.168.10.4

输出

1

代码如下：

 package com.yzh.hehe;

 import java.util.Scanner;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 public class IpIsSameSubNet {

     public static void main(String[] args) {
         Scanner scanner =new Scanner(System.in);
         String  mask,ip1,ip2;
         mask=scanner.nextLine();
         ip1=scanner.nextLine();
         ip2=scanner.nextLine();
         scanner.close();
         System.out.println(checkNetSegment(mask, ip1, ip2));
     } 

     public static int checkNetSegment(String mask, String ip1, String ip2)
     {
         if (!isSubNetYanMa(mask)||!isIP(ip1)||!isIP(ip2)) {
             return ;
         }
         String yu1=binaryYu(mask,ip1);
         String yu2=binaryYu(mask,ip2);
         if (!yu1.equals(yu2)) {
             return ;
         }

         return ;

     }

      private static boolean isIP(String addr)  //判断是否是ip
      {
          if(addr.length() <  || addr.length() >  || "".equals(addr))
          {
              return false;
          }
          /**
           * 判断IP格式和范围
           */
          String rexp = "([1-9]|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])(\\.(\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])){3}";  

          Pattern pat = Pattern.compile(rexp);    

          Matcher mat = pat.matcher(addr);    

          boolean ipAddress = mat.find();  

          return ipAddress;
      } 

      /*
       * 判断是否是子网掩码，方法：先判断是否是ip，再对ip的二进制表示反转，再末位加1，得到的结果是2的n次方就是子网掩码
       */
      private static boolean isSubNetYanMa(String code) {
         if (!isIP(code)) {
             return false;
         }
         String[] ips = code.split("\\.");
         StringBuilder binaryVal = new StringBuilder();
         for (int i = ; i < ips.length; i++)  //转换成二进制
         {
             String binaryStr = Integer.toBinaryString(Integer.parseInt(ips[i]));  

             Integer times =  - binaryStr.length();  

             for(int j = ; j < times; j++)
             {
                 binaryStr = "" +  binaryStr;
             }
             binaryVal.append(binaryStr); //+= binaryStr;
         }  

         binaryVal.reverse();//反转
         for (int i = ; i < binaryVal.length(); i++) {//末位加一
             if (binaryVal.charAt(i)=='') {

                 String temp =binaryVal.toString().replace('', '');
                 binaryVal=new StringBuilder(temp);
                 binaryVal.replace(i-,i , "");
                 break;
             }
         }
         int codeNumber= Integer.parseInt(binaryVal.toString(), );//二进制转十进制
         if(nCF(codeNumber)){
             return true;
         }else {
             return false;
         }

     }

      public static boolean nCF(int n){  //判断一个是否是2的n次方
             boolean b = false;
             while(true){
                 int j=n%;
                 n=n/;
                 if(j==){
                     b=false;
                     break;
                 }
                 if(n==){
                     b=true;
                     break;
                 }
             }
             return b;
         }  

      private static String binaryYu(String b1,String b2) {//两个ip地址相与
          String[] bs1 = b1.split("\\.");
          String[] bs2 = b2.split("\\.");
          int[] iArr1=new int[];
          int[] iArr2=new int[];
          StringBuilder stringBuilder=new StringBuilder();
          int temp=;
          String tempstrString=null;
          for (int i = ; i < iArr2.length; i++) {
             iArr1[i]=Integer.valueOf(bs1[i]);
             iArr2[i]=Integer.valueOf(bs2[i]);
             temp=iArr1[i]&iArr2[i];
             tempstrString=Integer.toBinaryString(temp);
             for (int j = ; j < (-tempstrString.length()); j++) {
                 stringBuilder.append("");
             }
             stringBuilder.append(tempstrString);
         }

          return stringBuilder.toString();
      }
 }