格式化部门数据

1. 组织架构图

2. 原数据格式

deptId	path
A614B189-1BD6-4533-875D-B57A655A3D7B	总裁-市场中心-策划部
09036122-2832-4A27-918E-7B7592237767	总裁-市场中心-调研部
F520534E-D513-4F3D-94AA-0635C925A46B	总裁-市场中心-工程部
719DA506-A973-4657-A5EB-7E33035AB3E8	总裁-行政中心-人力资源部-招聘组
A856094D-5F88-4988-B04B-C9E6A55F2CC7	总裁-行政中心-人力资源部-培训组
0F54E168-D3E9-4C09-AC78-4CC6CFE48111	总裁-行政中心-人力资源部-薪酬
03892A6D-E205-4C99-8DE8-53725E20F755	总裁-行政中心-运营管理部-统计组
51AB6193-2947-4AA8-87EB-CCFC4EB8D4E8	总裁-行政中心-运营管理部-储运组
EF92AACB-E123-48F0-8534-1CA7B5F40512	总裁-客服部-渠道客户服务部
6C32AD04-BC29-4F00-BF43-BEBDF6B1C818	总裁-客服部-个人客户服务部
6DA9818D-8D83-4355-AB83-B88F21FAF834	总裁-客服部-个人客户服务部
B661FFD5-46E3-4842-9248-6C54F9033C9B	总裁-营销部-A产品事业部-华中事业部
EE599C63-BF0E-4596-A408-8985119823F9	总裁-营销部-A产品事业部-外围事业部
849DA5E9-9649-4F78-BA5D-81F11DB30124	总裁-营销部-B产品事业部-直销部
8C56D670-6EB7-42CE-9904-CEC48E7512EA	总裁-营销部-B产品事业部-渠道部

3. 格式化后的JSON数据

[
    {
        "id": "0653e632-45f1-4911-bc74-f1e9837994b0",
        "name": "总裁",
        "list": [
            {
                "id": "277399b5-8faf-4b00-a497-a5df3e22e852",
                "name": "市场中心",
                "list": [
                    {
                        "id": "A614B189-1BD6-4533-875D-B57A655A3D7B",
                        "name": "策划部",
                        "list": []
                    },
                    {
                        "id": "09036122-2832-4A27-918E-7B7592237767",
                        "name": "调研部",
                        "list": []
                    },
                    {
                        "id": "F520534E-D513-4F3D-94AA-0635C925A46B",
                        "name": "工程部",
                        "list": []
                    }
                ]
            },
            {
                "id": "3f9ea368-0309-4923-b081-7cf85a8faf73",
                "name": "行政中心",
                "list": [
                    {
                        "id": "60dd5c5b-32c9-4de3-bc0e-a39a46d20adc",
                        "name": "人力资源部",
                        "list": [
                            {
                                "id": "719DA506-A973-4657-A5EB-7E33035AB3E8",
                                "name": "招聘组"
                            },
                            {
                                "id": "A856094D-5F88-4988-B04B-C9E6A55F2CC7",
                                "name": "培训组"
                            },
                            {
                                "id": "0F54E168-D3E9-4C09-AC78-4CC6CFE48111",
                                "name": "薪酬"
                            }
                        ]
                    },
                    {
                        "id": "e666e2f4-bdfc-47f3-b938-dc9e1db5dafe",
                        "name": "运营管理部",
                        "list": [
                            {
                                "id": "03892A6D-E205-4C99-8DE8-53725E20F755",
                                "name": "统计组"
                            },
                            {
                                "id": "51AB6193-2947-4AA8-87EB-CCFC4EB8D4E8",
                                "name": "储运组"
                            }
                        ]
                    }
                ]
            },
            {
                "id": "a3cd38cf-7386-495f-be2c-c43b49492d09",
                "name": "客服部",
                "list": [
                    {
                        "id": "EF92AACB-E123-48F0-8534-1CA7B5F40512",
                        "name": "渠道客户服务部",
                        "list": []
                    },
                    {
                        "id": "6C32AD04-BC29-4F00-BF43-BEBDF6B1C818",
                        "name": "个人客户服务部",
                        "list": []
                    }
                ]
            },
            {
                "id": "3b703cc6-f9d0-4877-a0a1-a6c008be9225",
                "name": "营销部",
                "list": [
                    {
                        "id": "e153be66-bd30-4515-ad03-af12c9c8a1a8",
                        "name": "A产品事业部",
                        "list": [
                            {
                                "id": "B661FFD5-46E3-4842-9248-6C54F9033C9B",
                                "name": "华中事业部"
                            },
                            {
                                "id": "EE599C63-BF0E-4596-A408-8985119823F9",
                                "name": "外围事业部"
                            }
                        ]
                    },
                    {
                        "id": "2fce50f5-e59a-4027-bb18-5331fc6783e5",
                        "name": "B产品事业部",
                        "list": [
                            {
                                "id": "849DA5E9-9649-4F78-BA5D-81F11DB30124",
                                "name": "直销部"
                            },
                            {
                                "id": "8C56D670-6EB7-42CE-9904-CEC48E7512EA",
                                "name": "渠道部"
                            }
                        ]
                    }
                ]
            }
        ]
    }
]

4. Java代码

FormatData.java

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

public class FormatData {
	public static void main(String[] args) {
		// 格式化部门数据
		// 1.分层显示
		// 2.分层后，没有部门id的数据，需要根据名称到数据库获取
		List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
		Map<String, Object> map1 = new HashMap<String, Object>();
		map1.put("deptId", "A614B189-1BD6-4533-875D-B57A655A3D7B");
		map1.put("path", "总裁-市场中心-策划部");
		Map<String, Object> map2 = new HashMap<String, Object>();
		map2.put("deptId", "09036122-2832-4A27-918E-7B7592237767");
		map2.put("path", "总裁-市场中心-调研部");
		Map<String, Object> map3 = new HashMap<String, Object>();
		map3.put("deptId", "F520534E-D513-4F3D-94AA-0635C925A46B");
		map3.put("path", "总裁-市场中心-工程部");
		Map<String, Object> map4 = new HashMap<String, Object>();
		map4.put("deptId", "719DA506-A973-4657-A5EB-7E33035AB3E8");
		map4.put("path", "总裁-行政中心-人力资源部-招聘组");
		Map<String, Object> map5 = new HashMap<String, Object>();
		map5.put("deptId", "A856094D-5F88-4988-B04B-C9E6A55F2CC7");
		map5.put("path", "总裁-行政中心-人力资源部-培训组");
		Map<String, Object> map6 = new HashMap<String, Object>();
		map6.put("deptId", "0F54E168-D3E9-4C09-AC78-4CC6CFE48111");
		map6.put("path", "总裁-行政中心-人力资源部-薪酬");
		Map<String, Object> map7 = new HashMap<String, Object>();
		map7.put("deptId", "03892A6D-E205-4C99-8DE8-53725E20F755");
		map7.put("path", "总裁-行政中心-运营管理部-统计组");
		Map<String, Object> map8 = new HashMap<String, Object>();
		map8.put("deptId", "51AB6193-2947-4AA8-87EB-CCFC4EB8D4E8");
		map8.put("path", "总裁-行政中心-运营管理部-储运组");
		Map<String, Object> map9 = new HashMap<String, Object>();
		map9.put("deptId", "EF92AACB-E123-48F0-8534-1CA7B5F40512");
		map9.put("path", "总裁-客服部-渠道客户服务部");
		Map<String, Object> map10 = new HashMap<String, Object>();
		map10.put("deptId", "6C32AD04-BC29-4F00-BF43-BEBDF6B1C818");
		map10.put("path", "总裁-客服部-个人客户服务部");
		Map<String, Object> map11 = new HashMap<String, Object>();
		map11.put("deptId", "6DA9818D-8D83-4355-AB83-B88F21FAF834");
		map11.put("path", "总裁-客服部-个人客户服务部");
		Map<String, Object> map12 = new HashMap<String, Object>();
		map12.put("deptId", "B661FFD5-46E3-4842-9248-6C54F9033C9B");
		map12.put("path", "总裁-营销部-A产品事业部-华中事业部");
		Map<String, Object> map13 = new HashMap<String, Object>();
		map13.put("deptId", "EE599C63-BF0E-4596-A408-8985119823F9");
		map13.put("path", "总裁-营销部-A产品事业部-外围事业部");
		Map<String, Object> map14 = new HashMap<String, Object>();
		map14.put("deptId", "849DA5E9-9649-4F78-BA5D-81F11DB30124");
		map14.put("path", "总裁-营销部-B产品事业部-直销部");
		Map<String, Object> map15 = new HashMap<String, Object>();
		map15.put("deptId", "8C56D670-6EB7-42CE-9904-CEC48E7512EA");
		map15.put("path", "总裁-营销部-B产品事业部-渠道部");
		list.add(map1);
		list.add(map2);
		list.add(map3);
		list.add(map4);
		list.add(map5);
		list.add(map6);
		list.add(map7);
		list.add(map8);
		list.add(map9);
		list.add(map10);
		list.add(map11);
		list.add(map12);
		list.add(map13);
		list.add(map14);
		list.add(map15);
		// 用于封装格式化后的数据
		List<Map<String, Object>> deptList = new ArrayList<Map<String, Object>>();
		for (Map<String, Object> map : list) {
			String depId = String.valueOf(map.get("deptId"));
			String path = String.valueOf(map.get("path"));
			formatDeptData(deptList, depId, path);
		}
		System.out.println(JsonUtil.toJson(deptList));
	}

	/**
	 * 格式化部门数据
	 * 
	 * @param deptList
	 *            封装格式化后的数据list
	 * @param depId
	 *            部门ID
	 * @param path
	 *            部门路径
	 */
	@SuppressWarnings("unchecked")
	private static void formatDeptData(List<Map<String, Object>> list, String depId, String path) {
		// 限制了，最多4层数据
		String[] strArr = path.split("-");
		String str1 = "";
		String str2 = "";
		String str3 = "";
		String str4 = "";
		int len = strArr.length;
		// 取出每层数据
		if (len > 0) {
			str1 = strArr[0];
		}
		if (len > 1) {
			str2 = strArr[1];
		}
		if (len > 2) {
			str3 = strArr[2];
		}
		if (len > 3) {
			str4 = strArr[3];
		}
		// 标记位，用于确认对应层数据是否已经存在
		boolean flag1 = false;// 标记第1层是否有重复
		boolean flag2 = false;// 标记第2层是否有重复
		boolean flag3 = false;// 标记第3层是否有重复
		boolean flag4 = false;// 标记第4层是否有重复
		if (list != null && list.size() > 0) {
			for (Map<String, Object> map1 : list) {
				if (str1 != null && str1 != "") {
					// 取出第一层数据比较
					String name1 = String.valueOf(map1.get("name"));
					if (name1.equals(str1)) {
						flag1 = true;
					}
					List<Map<String, Object>> list1 = (List<Map<String, Object>>) map1.get("list");
					if (list1 != null && list1.size() > 0) {
						for (Map<String, Object> map2 : list1) {
							if (str2 != null && str2 != "") {
								// 取出第二层数据比较
								String name2 = String.valueOf(map2.get("name"));
								if (name2.equals(str2)) {
									flag2 = true;
								}
								List<Map<String, Object>> list2 = (List<Map<String, Object>>) map2.get("list");
								if (list2 != null && list2.size() > 0) {
									for (Map<String, Object> map3 : list2) {
										if (str3 != null && str3 != "") {
											// 取出第三层数据比较
											String name3 = String.valueOf(map3.get("name"));
											if (name3.equals(str3)) {
												flag3 = true;
											}
											// 第四层数据无需比较，最后一层数据唯一（不管是哪一层数据）
											// 当长度小于4，则无第四层数据
											if (len < 4) {
												flag4 = true;
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}

		// 根据固定标志位，添加数据
		// 添加第1层数据
		if (str1 != null && str1 != "") {
			if (!flag1) {
				Map<String, Object> map1 = new HashMap<String, Object>();
				// 数据长度只有一层，则id取现成值
				// 否则id需要从数据库获取
				if (len == 1) {
					map1.put("id", depId);
				} else {
					String deptId1 = UUID.randomUUID().toString();// 数据库获取部门id，这里使用随机UUID代替
					map1.put("id", deptId1);
				}
				map1.put("name", str1);
				map1.put("list", new ArrayList<Map<String, Object>>());
				list.add(map1);
			}
		}
		// 添加第2层数据
		if (str2 != null && str2 != "") {
			if (!flag2) {
				for (Map<String, Object> map1 : list) {
					String name1 = String.valueOf(map1.get("name"));
					if (name1.equals(str1)) {
						List<Map<String, Object>> list1 = (List<Map<String, Object>>) map1.get("list");
						Map<String, Object> map2 = new HashMap<String, Object>();
						// 数据长度只有二层，则id取现成值
						// 否则id需要从数据库获取
						if (len == 2) {
							map2.put("id", depId);
						} else {
							String deptId2 = UUID.randomUUID().toString();// 数据库获取部门id，这里使用随机UUID代替
							map2.put("id", deptId2);
						}
						map2.put("name", str2);
						map2.put("list", new ArrayList<Map<String, Object>>());
						list1.add(map2);
					}
				}
			}
		}
		// 添加第3层数据
		if (str3 != null && str3 != "") {
			if (!flag3) {
				for (Map<String, Object> map1 : list) {
					String name1 = String.valueOf(map1.get("name"));
					if (name1.equals(str1)) {
						List<Map<String, Object>> list1 = (List<Map<String, Object>>) map1.get("list");
						for (Map<String, Object> map2 : list1) {
							String name2 = String.valueOf(map2.get("name"));
							if (name2.equals(str2)) {
								List<Map<String, Object>> list2 = (List<Map<String, Object>>) map2.get("list");
								Map<String, Object> map3 = new HashMap<String, Object>();
								// 数据长度只有三层，则id取现成值
								// 否则id需要从数据库获取
								if (len == 3) {
									map3.put("id", depId);
								} else {
									String deptId3 = UUID.randomUUID().toString();// 数据库获取部门id，这里使用随机UUID代替
									map3.put("id", deptId3);
								}
								map3.put("name", str3);
								map3.put("list", new ArrayList<Map<String, Object>>());
								list2.add(map3);
							}
						}
					}
				}
			}
		}
		// 添加第4层数据
		if (str4 != null && str4 != "") {
			if (!flag4) {
				for (Map<String, Object> map1 : list) {
					String name1 = String.valueOf(map1.get("name"));
					if (name1.equals(str1)) {
						List<Map<String, Object>> list1 = (List<Map<String, Object>>) map1.get("list");
						for (Map<String, Object> map2 : list1) {
							String name2 = String.valueOf(map2.get("name"));
							if (name2.equals(str2)) {
								List<Map<String, Object>> list2 = (List<Map<String, Object>>) map2.get("list");
								for (Map<String, Object> map3 : list2) {
									String name3 = String.valueOf(map3.get("name"));
									if (name3.equals(str3)) {
										List<Map<String, Object>> list3 = (List<Map<String, Object>>) map3.get("list");
										Map<String, Object> map4 = new HashMap<String, Object>();
										// 数据长度只有四层，则id取现成值
										// 否则id需要从数据库获取
										if (len == 4) {
											map4.put("id", depId);
										} else {
											String deptId4 = UUID.randomUUID().toString();// 数据库获取部门id，这里使用随机UUID代替
											map4.put("id", deptId4);
										}
										map4.put("name", str4);
										list3.add(map4);
									}
								}
							}
						}
					}
				}
			}
		}
	}
}

JsonUtil.java

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.JsonPrimitive;

public class JsonUtil {
	/**
	 * 获取对象的string字符
	 * 
	 * @param obj
	 *            需要转换的对象
	 * @return 对象的string字符
	 */
	public static String toJson(Object obj) {
		Gson gson = new Gson();
		return gson.toJson(obj);
	}

	/**
	 * 获取string字符的对象. {@code new TypeToken<List<Map<String,String>>>() .getType()}
	 * 
	 * @param str
	 *            需要转换的字符串
	 * @param type
	 *            需要转换的对象类型
	 * @return 对象
	 */
	public static <T> T fromJson(String str, Type type) {
		Gson gson = new Gson();
		return gson.fromJson(str, type);
	}

	/**
	 * 获取string字符的对象
	 * 
	 * @param str
	 *            需要转换的字符串
	 * @param type
	 *            需要转换的对象类型
	 * @return 对象
	 */
	public static <T> T fromJson(String str, Class<T> type) {
		Gson gson = new Gson();
		return gson.fromJson(str, type);
	}

	/**
	 * 将标准形式的JSON字符串转换为Map对象
	 * 
	 * @param str
	 *            字符串
	 * @return 转换后的Map对象
	 */
	@SuppressWarnings("unchecked")
	public static Map<String, Object> jsonToMap(String str) {
		JsonParser jsonParser = new JsonParser();
		JsonElement jsonElement = jsonParser.parse(str);
		if (!jsonElement.isJsonObject()) {
			System.out.println("can't parse '" + str + "' to map ");
			return new HashMap<String, Object>();
		}

		return (Map<String, Object>) getValue(jsonElement);
	}

	/**
	 * 递归查询
	 * 
	 * @param jsonElement
	 *            元素对象
	 * @return 转换后的对象
	 */
	@SuppressWarnings("unchecked")
	private static Object getValue(JsonElement jsonElement) {
		if (jsonElement.isJsonObject()) {
			JsonObject object = jsonElement.getAsJsonObject();
			Set<Map.Entry<String, JsonElement>> set = object.entrySet();
			Object[] obja = set.toArray();
			Map<String, Object> map = new HashMap<String, Object>();
			for (Object objcc : obja) {
				Map.Entry<String, JsonElement> mapTemp = (Map.Entry<String, JsonElement>) objcc;
				map.put(mapTemp.getKey(), getValue(mapTemp.getValue()));
			}
			return map;

		} else if (jsonElement.isJsonArray()) {
			JsonArray array = jsonElement.getAsJsonArray();
			int size = array.size();
			List<Object> list = new ArrayList<Object>();
			for (int i = 0; i < size; i++) {
				list.add(getValue(array.get(i)));
			}
			return list;
		} else if (jsonElement.isJsonPrimitive()) {
			JsonPrimitive primitive = jsonElement.getAsJsonPrimitive();
			if (primitive.isString()) {
				return primitive.getAsString();
			}
			if (primitive.isBoolean()) {
				return primitive.getAsBoolean();
			}
			if (primitive.isNumber()) {
				return primitive.getAsNumber();
			}

			return primitive.getAsString();
		}
		return null;
	}

}

5. 用到的Jar包

gson-1.4.jar