函数与提取：
 public static boolean isSameAddress(String resourceIp, String requestIp)；判断是否属于同一网段，默认子网掩码
 public static boolean isSameAddress(String resourceIp, String requestIp, String subnetMask)；判断是否属于同一网段，指定子网掩码
 public static String getIpType(String ip)；判断IP地址类型A、B、C类
 
package com.laiwei.stream.util;

import com.laiwei.framework.exception.RuleIllegalArgumentException;
import org.junit.Test;

public class IpV4Util {

	public static final String DEFAULT_SUBNET_MASK_A = "255.0.0.0";
	public static final String DEFAULT_SUBNET_MASK_B = "255.255.0.0";
	public static final String DEFAULT_SUBNET_MASK_C = "255.255.255.0";
	public static final String TYPE_IP_A = "A";
	public static final String TYPE_IP_B = "B";
	public static final String TYPE_IP_C = "C";
	public static final String TYPE_IP_D = "D";
	public static final String TYPE_IP_LOCATE = "locate";
	//	@Test
	//	public void test() {
	//		System.out.println(isSameAddress("192.168.1.1", "192.168.1.5", DEFAULT_SUBNET_MASK_C));
	//
	//	}
		@Test
		public void test() {
			String ip_a="127.0.01.15";
			String ip_c="192.168.1.1";
			String binaryIp = getBinaryIp("192.168.1.1");
			System.out.println(getIpType(ip_a));

		}
		//判断ip是否属于同一网段，默认子网掩码
	public static boolean isSameAddress(String resourceIp, String requestIp) {
		if (getIpType(resourceIp).equals(getIpType(requestIp))){
			return isSameAddress(resourceIp,requestIp,getIpDefaultMask(getIpType(resourceIp)));
		}
		return false;
	}
	//通过ip类型，获取默认IP子网掩码
	private static String getIpDefaultMask(String ipType){
			switch (ipType){
				case TYPE_IP_A:return DEFAULT_SUBNET_MASK_A;
				case TYPE_IP_B:return DEFAULT_SUBNET_MASK_B;
				case TYPE_IP_C:return DEFAULT_SUBNET_MASK_C;
				default:throw new RuleIllegalArgumentException("没有对应的mask地址");
			}
	}
		//判断ip是否属于同一网段
	public static boolean isSameAddress(String resourceIp, String requestIp, String subnetMask) {
		String resourceAddr = getAddrIp(resourceIp, subnetMask);
		String subnetMaskAddr = getAddrIp(requestIp, subnetMask);
		if (resourceAddr.equals(subnetMaskAddr)) {
			return true;
		}
		return false;
	}
	//获取ip的二进制字符串
	private static String getBinaryIp(String data) {
		String[] datas = data.split("\\.");
		String binaryIp = "";
		for (String ipStr : datas) {
			long signIp = Long.parseLong(ipStr);
			String binary = Long.toBinaryString(signIp);
			long binaryInt = Long.parseLong(binary);
			binaryIp += String.format("%08d", binaryInt);
		}
		return binaryIp;
	}
	//获取ip的地址位
	private static String getAddrIp(String ip, String subnetMask) {
		StringBuilder addrIp = new StringBuilder();
		String binaryIp = getBinaryIp(ip);
		String binarySubnetMask = getBinaryIp(subnetMask);
		for (int i = 0; i < 32; i++) {
			byte ipByte = Byte.parseByte(String.valueOf(binaryIp.charAt(i)));
			byte subnetMaskByte = Byte.parseByte(String.valueOf(binarySubnetMask.charAt(i)));
			addrIp.append(ipByte & subnetMaskByte);
		}
		return addrIp.toString();
	}
		//获取ip是什么类型，ABCD
	public static String getIpType(String ip) {
		String binaryIp = getBinaryIp(ip);
		System.out.println(binaryIp);
		if (ip.startsWith("127")){
			return TYPE_IP_LOCATE;
		}
		if (binaryIp.startsWith("0")){
			return TYPE_IP_A;
		}
		if (binaryIp.startsWith("10")){
			return TYPE_IP_B;
		}
		if (binaryIp.startsWith("110")){
			return TYPE_IP_C;
		}
		if (binaryIp.startsWith("1110")){
			return TYPE_IP_D;
		}
		throw new RuleIllegalArgumentException("无效ip异常");
	}
}

一、原理
 
让ip地址和子网掩码进行与操作，如果最后得到的结果相同代表是同一局域网
如：
let ip1 = '172.18.2.200';  
let zw1 = '255.255.255.0';
---> 172&255 , 18&255 , 2&255 , 200&0,
let ip2 = '172.18.3.139';
let zw2 = '255.255.255.0'
--->172&255 , 18&255 , 3&255 , 139&0 ,
两个结果相同则为同一局域网
 
二、代码实现
 
let ip1 = '172.18.2.200';  //-->[172,18,2,200]
let zw1 = '255.255.255.0'
let ip2 = '172.18.3.139';
let zw2 = '255.255.255.0'

//先转化为数组
const toArr =(data)=>{
    let arr = data.split('.')
    return arr.map((item)=>(Number(item)))
}
//按位与操作
const and = (addres,addres2)=>{
    if(addres.length !==addres2.length){
           return false 
    }
    let arr =[];
    const len = addres.length;
    for (let i = 0; i <len ; i++) {
         arr.push(addres[i] & addres2[i])
    }
    return  arr.join(".")
}
//第一组数据
const arr1 =toArr(ip1)
const arr2 =toArr(zw1)
const resIp1 =and(arr1,arr2)

//第二组数据
const arr3 =toArr(ip2)
const arr4 =toArr(zw2)
const resIp2 =and(arr3,arr4)
console.log(resIp1 ==resIp2)

怎么判断ＩＰ地址的是否在同一网段。
 
相信好多人都认为ＩＰ只要前三段相同，就是在同一网段了，其实，不是这样的，同样，我想把ＩＰ的每一段转换为一个二进制数，这里就拿ＩＰ：192.168.0.1，子网掩码：255.255.255.0做实验吧。
 
192.168.0.1
 
11000000.10101000.00000000.00000001
 
（这里说明一下，和子网掩码一样，每段8位，不足8位的，前面加0补齐。）
 
ＩＰ　　　　11000000.10101000.00000000.00000001
 
子网掩码　　11111111.11111111.11111111.00000000
 
在这里，向大家说一下到底怎么样才算同一网段。
 
要想在同一网段，必需做到网络标识相同，那网络标识怎么算呢？
 
各类ＩＰ的网络标识算法都是不一样的。Ａ类的，只算第一段。Ｂ类，只算第一、二段。Ｃ类，算第一、二、三段。
 
算法只要把ＩＰ和子网掩码的每位数AND就可以了。
 
AND方法：0和1＝0　0和0＝0　1和1＝1
 
如：And　192.168.0.1，255.255.255.0，先转换为二进制，然后AND每一位
 
ＩＰ　　　　　　11000000.10101000.00000000.00000001
 
子网掩码　　　　11111111.11111111.11111111.00000000
 
得出AND结果　 11000000.10101000.00000000.00000000
 
转换为十进制192.168.0.0，这就是网络标识，
 
再将子网掩码反取，也就是00000000.00000000.00000000.11111111，与IP:192.168.0.1　AND
 
得出结果00000000.00000000.00000000.00000001，转换为10进制，即0.0.0.1，
 
这0.0.0.1就是主机标识。
 
 
 
要想在同一网段，必需做到网络标识一样。
 
 
 
　　我们再来看看这个改为默认子网掩码的Ｂ类ＩＰ
 
如ＩＰ：188.188.0.111，188.188.5.222，子网掩码都设为255.255.254.0，在同一网段吗？
 
先将这些转换成二进制
 
188.188.0.111　10111100.10111100.00000000.01101111
 
188.188.5.222　10111100.10111100.00000101.11011010
 
255.255.254.0　11111111.11111111.11111110.00000000
 
分别AND，得
 
10111100.10111100.00000000.00000000
 
10111100.10111100.00000100.00000000
 
网络标识不一样，即不在同一网段。
 
 
 
 
 
 
 
这里所说的网络标识也就是子网

算法只要把IP和子网掩码的每位数AND就可以了。
 AND方法：0和1=0　0和0=0　1和1=1
 如：And　192.168.0.1，255.255.255.0，先转换为二进制，然后AND每一位
 IP　11000000.10101000.00000000.00000001
 子网掩码　11111111.11111111.11111111.00000000
 得出AND结果　 11000000.10101000.00000000.00000000
 转换为十进制192.168.0.0，这就是网络标识，
 再将子网掩码反取，也就是00000000.00000000.00000000.11111111，与IP　AND
 得出结果00000000.00000000.00000000.00000001，转换为10进制，即0.0.0.1，
 这0.0.0.1就是主机标识。要想在同一网段，必需做到网络标识一样。
 我们再来看看这个改为默认子网掩码的B类IP
 如IP：188.188.0.111，188.188.5.222，子网掩码都设为255.255.254.0，在同一网段吗？
 先将这些转换成二进制
 188.188.0.111　10111100.10111100.00000000.01101111
 188.188.5.222　10111100.10111100.00000101.11011110
 255.255.254.0　11111111.11111111.11111110.00000000
 分别AND，得
 10111100.10111100.00000000.00000000
 10111100.10111100.00000100.00000000
 网络标识不一样，即不在同一网段。
 判断是不是在同一网段，你会了吧，下面，我们来点实际的。
 一个公司有530台电脑，组成一个对等局域网，子网掩码和IP设多少最合适？
 子网掩码不说了，前面算出结果来了11111111.11111111.11111100.00000000，也就是255.255.252.0
 我们现在要确定的是IP如何分配，首先，选一个B类IP段，这里就选188.188.x.x吧
 这样，IP的前两段确定的，关键是要确定第三段，只要网络标识相同就可以了。我们先来确定网络号。（我们把子网掩码中的1和IP中的 对就起来，0和*对应起来，如下：）
 255.255.252.0　11111111.11111111.11111100.00000000
 188.188.x.x　10111100.10111100. .******
 网络标识　10111100.10111100. 00.00000000
 由此可知， *处随便填（只能用0和1填，不一定全是0和1）