分区号段范围分布的判断，号码分布判断

package com.tyy;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * 分区号段合并后范围的判断：假设要求号码范围必须是0-999，
 * 其中，允许以0-333,334-666,667-999这样分段的方式存在；
 * 如果分段中间有断裂，则返回"号码分布异常"，
 * 即0-333,340-666,667-999这样的分段分布就不符合要求。
 * @author ferndean
 * @date 2012-11-27
 */
public class Numferndean
{

	private static final int MIN =0;
	private static final int MAX =999;
	
	public static void main(String[] args)
	{
		/*
		 * 举例，输入参数为一个List对象valueList,对象值为：
		 * {[{SN =1, DSAID=2, NUMTYPE=1, BEGIN=0, END=999)],
		 * [{SN =2, DSAID=2, NUMTYPE=16, BEGIN=0, END=333)],
		 * [{SN =3, DSAID=2, NUMTYPE=16, BEGIN=334, END=666)],
		 * [{SN =4, DSAID=2, NUMTYPE=16, BEGIN=667, END=999)]}
		 * 其中，SN为序列号，DSAID为dsa标识，NUMTYPE为号段类型，BEGIN为号段起始值，END为号段终止值。
		 * 这里，我按DSAID 和 NUMTYPE号段类型组合为唯一key来进行分类判断。
		 */
		List valueList = createList();
		
		// 这个groupMap是总体Map的用来存放自定义key和上述每条记录的映射
		// 组装好groupMap后，才开始对其进行判断号段分布的情况。
		Map groupMap = new HashMap();
		List dsaList = new ArrayList();
		
		// for循环里面的代码逻辑很重点，我也是错了很多回才得到下面的正确逻辑。
		for(int i=0;i<valueList.size();i++)
		{
			Map record = (Map)valueList.get(i);
			//
			int dsaid = Integer.parseInt(String.valueOf(record.get("DSAID")));
			//
			int numtype =Integer.parseInt(String.valueOf(record.get("NUMTYPE")));
			Map keyMap = new HashMap();
			keyMap.put(numtype, dsaid);
			if(!isMapExist(numtype,dsaid,groupMap))
			{
				dsaList = new ArrayList();
				dsaList.add(record);
			}
			else
			{
				dsaList.add(record);
			}
			groupMap.put(keyMap, dsaList);
		}
		/*
		 * 这里的groupMap结果参考如下：
		 * {{1-2}=[{END=999,DSAID=2,SN=3,NUMTYPE=1,BEGIN=0}],
		 * {16-2}=[{END=333,DSAID=2,SN=1,NUMTYPE=16,BEGIN=0},
		 * {END=666,DSAID=2,SN=3,NUMTYPE=16,BEGIN=334},
		 * {END=999,DSAID=2,SN=3,NUMTYPE=16,BEGIN=667}]}
		 */
		checkIDSA(groupMap);
	}
	
	/**
	 * 进行号段分区范围的具体判断
	 * 
	 * @param groupMap
	 */
	private static void checkIDSA(Map groupMap)
	{
		Iterator it = groupMap.keySet().iterator();
		while(it.hasNext())
		{
			Map key = (Map) it.next();
			List dsaList = (List)groupMap.get(key);
			StringBuffer sb = new StringBuffer();
			sb.append("号段类型");
			
			if (dsaList.size() == 1)
			{
				Map record = (Map) dsaList.get(0);
				int start = Integer.parseInt(String.valueOf(record.get("BEGIN")));
				int end = Integer.parseInt(String.valueOf(record.get("END")));
				String numtype = String.valueOf(record.get("NUMTYPE"));
				sb.append(numtype).append(",号段分布：").append(start).append("-").append(end).append(
						",");
				if (start == MIN && end == MAX)
				{
					System.out.println(sb.toString() + " 号码分布正常O(∩_∩)O");
				}
				else
				{
					System.out.println(sb.toString() + " 号码分布异常%>_<%");
				}
			}
			else
			{
				Iterator kit =  key.keySet().iterator();
				String numtype = "";
				if(kit.hasNext())
				{
					numtype = String.valueOf(kit.next());
				}
				sb.append(numtype).append(",号段分布：");
				
				int min = 999;// 默认值
				int max = 0;// 默认值
				List endList = new ArrayList();
				List startList = new ArrayList();
				for (int i = 0; i < dsaList.size(); i++)
				{
					Map record = (Map) dsaList.get(i);
					int start = Integer.parseInt(String.valueOf(record.get("BEGIN")));
					int end = Integer.parseInt(String.valueOf(record.get("END")));
					min = (start <= min) ? start : min;
					if (start > MIN)
					{
						startList.add(start);
					}
					max = (end >= max) ? end : max;
					if (end < MAX)
					{
						endList.add(end);
					}
					sb.append(start).append("-").append(end).append(",");
				}

				boolean flag = true;
				for (int i = 0; i < endList.size(); i++)
				{
					int tend = Integer.parseInt(String.valueOf(endList.get(i)));
					for (int j = 0; j < startList.size(); j++)
					{
						int tStrt = Integer.parseInt(String.valueOf(startList.get(j)));
						if (tend + 1 >= tStrt)
						{
							startList.remove(j);
						}
						else
						{
							flag = false;
							break;
						}
					}
				}
				if (!flag)
				{
					System.out.println(sb.toString() + " 号码分布异常%>_<%");
				}
				else
				{
					if (min == MIN && max == MAX)
					{
						System.out.println(sb.toString() + " 号码分布正常O(∩_∩)O");
					}
					else
					{
						System.out.println(sb.toString() + " 号码分布异常%>_<%");
					}
				}

			}
		}
	}
	
	private static boolean isMapExist(int numtype,int dsaid,Map tmp)
	{
		boolean isFlag = false;
		Iterator it = tmp.keySet().iterator();
		while(it.hasNext())
		{
			Map keyMap = (Map)it.next();
			if(keyMap.containsKey(numtype) && keyMap.get(numtype).equals(dsaid))
			{
				isFlag = true;
			}
		}
		
		return isFlag;
	}
	
	/**
	 * 模拟一个valueList出来，用于此类的实验
	 * 
	 * @return
	 */
	private static List createList()
	{
		List valueList = new ArrayList();
		Map map = new HashMap();
		map.put("SN", 1);
		map.put("DSAID", 2);
		map.put("NUMTYPE", 1);
		map.put("BEGIN", 0);
		map.put("END", 999);
		valueList.add(map);
		
		Map map2 = new HashMap();
		map2.put("SN", 2);
		map2.put("DSAID", 2);
		map2.put("NUMTYPE", 16);
		map2.put("BEGIN", 0);
		map2.put("END", 333);
		valueList.add(map2);
		
		Map map3 = new HashMap();
		map3.put("SN", 3);
		map3.put("DSAID", 2);
		map3.put("NUMTYPE", 16);
		map3.put("BEGIN", 334);
		map3.put("END", 666);
		valueList.add(map3);
		
		Map map4 = new HashMap();
		map4.put("SN", 4);
		map4.put("DSAID", 2);
		map4.put("NUMTYPE", 16);
		map4.put("BEGIN", 667);
		map4.put("END", 999);
		valueList.add(map4);
		
		return valueList;
	}
}