1.简述：
描述
子网掩码是用来判断任意两台计算机的IP地址是否属于同一子网络的根据。
子网掩码与IP地址结构相同，是32位二进制数，其中网络号部分全为“1”和主机号部分全为“0”。利用子网掩码可以判断两台主机是否中同一子网中。若两台主机的IP地址分别与它们的子网掩码相“与”后的结果相同，则说明这两台主机在同一子网中。
示例：
I P 地址 192.168.0.1
子网掩码 255.255.255.0
转化为二进制进行运算：
I P 地址 11000000.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 地址 11000000.10101000.00000000.11111110
子网掩码 11111111.11111111.11111111.00000000
AND运算 11000000.10101000.00000000.00000000
转化为十进制后为：
192.168.0.0
通过以上对两台计算机IP地址与子网掩码的AND运算后，我们可以看到它运算结果是一样的。均为192.168.0.0，所以这二台计算机可视为是同一子网络。
输入一个子网掩码以及两个ip地址，判断这两个ip地址是否是一个子网络。若IP地址或子网掩码格式非法则输出1，若IP1与IP2属于同一子网络输出0，若IP1与IP2不属于同一子网络输出2。
注:有效掩码与IP的性质为：
1. 掩码与IP每一段在 0 - 255 之间
2. 掩码的二进制字符串前缀为网络号，都由‘1’组成；后缀为主机号，都由'0'组成
本题有多组输入
输入描述：
多组输入，一组3行，第1行是输入子网掩码、第2，3行是输入两个ip地址
输出描述：
若IP地址或子网掩码格式非法则输出1，若IP1与IP2属于同一子网络输出0，若IP1与IP2不属于同一子网络输出2
示例1
输入：
255.255.255.0
192.168.224.256
192.168.10.4
255.0.0.0
193.194.202.15
232.43.7.59
255.255.255.0
192.168.0.254
192.168.0.1复制输出：
1
2
0复制说明：
对于第一个例子:
255.255.255.0
192.168.224.256
192.168.10.4
其中IP:192.168.224.256不合法，输出1
对于第二个例子:
255.0.0.0
193.194.202.15
232.43.7.59
2个与运算之后，不在同一个子网，输出2
对于第三个例子，2个与运算之后，如题目描述所示，在同一个子网，输出02.代码实现：
方法一:字符串比较
具体方法
首先本题中包括两个目标，一个是判断ip地址及掩码是否规范 第二个是判断两个ip地址是否属于同一子网 对于判断是否规范问题，首先题目中给出了要求： 1、掩码与IP每一段在0-255之间 2、掩码的二进制字符串，前缀全为1，后缀全为0 直接按照字面意思判断即可 对于判断是否属于同一子网，我们可以将ip地址转换成二进制字符串，通过字符串的比较进行判断
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String mask = sc.nextLine();
String ip1 = sc.nextLine();
String ip2 = sc.nextLine();
String[] _mask = mask.split("\\.");
String[] iip1 = ip1.split("\\.");
String[] iip2 = ip2.split("\\.");
StringBuilder mask_sb = new StringBuilder();
StringBuilder ip1_sb = new StringBuilder();
StringBuilder ip2_sb = new StringBuilder();
boolean flag = true; //判断是否有大于255的不规范
for(int i=0; i<4; i++){
int num = Integer.parseInt(_mask[i]);
if(num>255 || num<0){
flag = false;
break;
}
String num2 = Integer.toBinaryString(num);
while(num2.length()<8){
num2 = "0" + num2;
}
mask_sb.append(num2);
num = Integer.parseInt(iip1[i]);
if(num>255 || num<0){
flag = false;
break;
}
num2 = Integer.toBinaryString(num);
while(num2.length()<8){
num2 = "0" + num2;
}
ip1_sb.append(num2);
num = Integer.parseInt(iip2[i]);
if(num>255 || num<0){
flag = false;
break;
}
num2 = Integer.toBinaryString(num);
while(num2.length()<8){
num2 = "0" + num2;
}
ip2_sb.append(num2);
}
if(!flag){
System.out.println(1);
continue;
}
mask = mask_sb.toString();
ip1 = ip1_sb.toString();
ip2 = ip2_sb.toString();
int left = 0, right = 31;
while(mask.charAt(left)=='1'){
left++;
}
while(mask.charAt(right)=='0'){
right--;
}
if(left!=right+1){ //判断掩码是否规范
System.out.println(1);
continue;
}
boolean ans = true;
for(int i=0; i<32 && mask.charAt(i)=='1'; i++){
if(ip1.charAt(i) != ip2.charAt(i)){
ans = false;
break;
}
}
if(ans){
System.out.println(0);
}else{
System.out.println(2);
}
}
}
}方法二：与运算判断
具体方法
对于规范问题判断同上 对于是否属于同一子网的问题，我们可以通过与运算的方式，转化成二进制，然后进行与运算
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String mask = sc.nextLine();
String ip1 = sc.nextLine();
String ip2 = sc.nextLine();
String[] _mask = mask.split("\\.");
String[] iip1 = ip1.split("\\.");
String[] iip2 = ip2.split("\\.");
StringBuilder mask_sb = new StringBuilder();
StringBuilder ip1_sb = new StringBuilder();
StringBuilder ip2_sb = new StringBuilder();
boolean flag = true; //判断是否有大于255的不规范
for(int i=0; i<4; i++){
int num = Integer.parseInt(_mask[i]);
if(num>255 || num<0){
flag = false;
break;
}
String num2 = Integer.toBinaryString(num);
while(num2.length()<8){
num2 = "0" + num2;
}
mask_sb.append(num2);
num = Integer.parseInt(iip1[i]);
if(num>255 || num<0){
flag = false;
break;
}
num2 = Integer.toBinaryString(num);
while(num2.length()<8){
num2 = "0" + num2;
}
ip1_sb.append(num2);
num = Integer.parseInt(iip2[i]);
if(num>255 || num<0){
flag = false;
break;
}
num2 = Integer.toBinaryString(num);
while(num2.length()<8){
num2 = "0" + num2;
}
ip2_sb.append(num2);
}
if(!flag){
System.out.println(1);
continue;
}
mask = mask_sb.toString();
ip1 = ip1_sb.toString();
ip2 = ip2_sb.toString();
int left = 0, right = 31;
while(mask.charAt(left)=='1'){
left++;
}
while(mask.charAt(right)=='0'){
right--;
}
if(left!=right+1){ //判断掩码是否规范
System.out.println(1);
continue;
}
boolean ans = true;
long mask_num = Long.parseLong(mask, 2);
long ip1_num = Long.parseLong(ip1, 2);
long ip2_num = Long.parseLong(ip2, 2);
ans = (mask_num & ip1_num) == (mask_num & ip2_num);
if(ans){
System.out.println(0);
}else{
System.out.println(2);
}
}
}
}
