解题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 1;
        }
        String yu1=binaryYu(mask,ip1);
        String yu2=binaryYu(mask,ip2);
        if (!yu1.equals(yu2)) {
            return 2;
        }
        
        return 0;
     
    }
    
     private static boolean isIP(String addr)  //判断是否是ip
     {   
         if(addr.length() < 7 || addr.length() > 15 || "".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 = 0; i < ips.length; i++)  //转换成二进制
        {  
            String binaryStr = Integer.toBinaryString(Integer.parseInt(ips[i]));  
              
              
            Integer times = 8 - binaryStr.length();  
              
            for(int j = 0; j < times; j++)  
            {  
                binaryStr = "0" +  binaryStr;  
            }  
            binaryVal.append(binaryStr); //+= binaryStr;  
        }  
        
        binaryVal.reverse();//反转
        for (int i = 0; i < binaryVal.length(); i++) {//末位加一
            if (binaryVal.charAt(i)=='1') {
                
                String temp =binaryVal.toString().replace('1', '0'); 
                binaryVal=new StringBuilder(temp);
                binaryVal.replace(i-1,i , "1");
                break;
            }
        }
        int codeNumber= Integer.parseInt(binaryVal.toString(), 2);//二进制转十进制
        if(nCF(codeNumber)){
            return true;
        }else {
            return false;
        }
        
    }
     
     public static boolean nCF(int n){  //判断一个是否是2的n次方
            boolean b = false;  
            while(true){  
                int j=n%2;  
                n=n/2;  
                if(j==1){  
                    b=false;  
                    break;  
                }
                if(n==2){  
                    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[4]; 
         int[] iArr2=new int[4]; 
         StringBuilder stringBuilder=new StringBuilder();
         int temp=0;
         String tempstrString=null;
         for (int i = 0; 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 = 0; j < (8-tempstrString.length()); j++) {
                stringBuilder.append("0");
            } 
            stringBuilder.append(tempstrString); 
        }
         
         return stringBuilder.toString();
     }
}