一个非常难的问题,高分

jiangbai333 2016-01-20 11:08:59
一个下面类型的Map

Map<String, String[]> tempMap = new HashMap<String, String[]>();

现在里面存了这种数据:

key value
a[a1][a11] 一个字符串数组
a[a1][a12] 一个字符串数组
b[b1][b11] 一个字符串数组
b[b2][b21] 一个字符串数组
b[b2][b22] 一个字符串数组
b[b3][b31] 一个字符串数组
......... .........
n[nx][nxx]......[nxxxxx] 一个字符串数组



现在想把它转换成一个这种 比如a[a1][a11] 、a[a1][a12] 那么 建立一个Map1 它的key是 “a” 它的value 是 一个Map2 Map2的jkey是 “a1” Map2的value是Map3 Map3的key是“a11”和 “a12” “a11”和 “a12”对应的value 分别是a[a1][a11] 、a[a1][a12]对应的字符串数组。这样 当需要那个字符串数组就可以 这样调用了

Map.get("a").get("a1").get("a11");
Map.get("a").get("a1").get("a12");



请问 如何能把这个MAP转换出来!弄了两天了 没整明白
...全文
349 16 打赏 收藏 转发到动态 举报
写回复
用AI写文章
16 条回复
切换为时间正序
请发表友善的回复…
发表回复
jiangbai333 2016-01-21
  • 打赏
  • 举报
回复
引用 15 楼 u011376884 的回复:
[quote=引用 14 楼 jiangbai333 的回复:]
我尽力了,能不能用的上就不知道了

private static final Map<String,String> keyPathMap=new LinkedHashMap<String, String>();
	
	/**
	 * 入口 传入map
	 * @param tempMap
	 * @return
	 */
	private static Map<String, Object> changeMapToMapTree(Map<String, String[]> tempMap){
		Map<String, Object> checkMap=new HashMap<String, Object>();
		Set<String> keySet = tempMap.keySet();
		for (Iterator iterator = keySet.iterator(); iterator
				.hasNext();) {
			String str = (String) iterator.next();
			Map<String, Object> createMap = createMap(str, tempMap.get(str));
			checkMap = combine(checkMap, createMap);
			String[] split = str.replaceAll("]", "").split("\\[");
			Map<String, Object> map=new HashMap<String, Object>();
			for (int i = 0; i < split.length; i++) {
				if(i==0){
					keyPathMap.put(split[i], split[i]);
				}else{
					keyPathMap.put(split[i], keyPathMap.get(split[i-1])+","+split[i]);
				}
			}
		}
		return checkMap;
	}
	
	/**
	 * 格式化map
	 * @param mapKey map的key
	 * @param value
	 * @return
	 */
	private static Map<String, Object> createMap(String mapKey,String[] value){
		String[] split = mapKey.replaceAll("]", "").split("\\[");
		Map<String, Object> map=new HashMap<String, Object>();
		map.put(split[split.length-1], value);
		if(split.length-1==0){
			return map;
		}
		
		Map<String, Object> ownMap=new HashMap<String, Object>();
		ownMap.put(split[split.length-2], map);
		
		if(split.length-2==0){
			return ownMap;
		}
		Map<String, Object> allMap=new HashMap<String, Object>();
		
		for (int i = split.length-3; i >= 0; i--) {
			Map<String, Object> tempMap=new HashMap<String, Object>();
			tempMap.put(split[i], ownMap);
			ownMap=tempMap;
			allMap.putAll(ownMap);
		}
		Map<String, Object> temp = (Map<String, Object>) allMap.get(split[0]);
		allMap.clear();
		allMap.put(split[0], temp);
		return allMap;
	}
	
	/**
	 * 获取map的值
	 * @param infoMap map
	 * @param mapKey 按顺序排列的key值(变长数组)
	 * @return
	 */
	private static String[] getMapValue(Map<String, Object> infoMap,String... mapKey){
		Map<String, Object> tempMap=infoMap;
		for (int i = 0; i < mapKey.length; i++) {
			if(i==mapKey.length-1){
				return (String[])tempMap.get(mapKey[i]);
			}else{
				tempMap=(Map<String, Object>)tempMap.get(mapKey[i]);
			}
		}
		return null;
	}
	
	/**
	 * 获取map的深层次对象
	 * @param infoMap map
	 * @param mapKey 按顺序排列的key值(变长数组)
	 * @return
	 */
	private static Map<String, Object> getMapByKeys(Map<String, Object> infoMap,String... mapKey){
		Map<String, Object> tempMap=infoMap;
		for (int i = 0; i < mapKey.length; i++) {
			Object object = tempMap.get(mapKey[i]);
			if(object!=null){
				if(object.getClass() != String[].class){
					tempMap=(Map<String, Object>)object;
				}
			}
		}
		return tempMap;
	}
	

	/**
	 * 将两个map中key相同的value合并起来
	 * 
	 * @param map1
	 * @param map2
	 * @return
	 */
	public static Map<String, Object> combine(Map<String, Object> map1, Map<String, Object> map2) {
		if (map1==null||map1.size()==0) {
			return map2;
		}
		if (map2==null||map2.size()==0) {
			return map1;
		}
		Set<String> keySet2 = map2.keySet();
		for (Iterator iterator = keySet2.iterator(); iterator
				.hasNext();) {
			String str = (String) iterator.next();
			if(keyPathMap.containsKey(str)){
				try {
					String[] split = keyPathMap.get(str).split(",");
					Map<String, Object> mapByKeys = getMapByKeys(map1, split);
					Map<String, Object> temp = (Map<String, Object>) map2.get(str);
					Set<String> tempSet = temp.keySet();
					for (Iterator iterator1 = tempSet.iterator(); iterator1
							.hasNext();) {
						String string = (String) iterator1.next();
						if(mapByKeys.containsKey(string)){
							combineForeach(mapByKeys, temp);
						}else{
							mapByKeys.put(string, temp.get(string));
						}
					}
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}else{
				map1.put(str, (Map<String, Object>)map2.get(str));
			}
		}
		return map1;
	}
	
	/**
	 * 将两个map中key相同的value合并起来
	 * 
	 * @param map1
	 * @param map2
	 */
	public static void combineForeach(Map<String, Object> map1, Map<String, Object> map2) {
		if (map1==null||map1.size()==0) {
			map1= map2;
			return;
		}
		if (map2==null||map2.size()==0) {
			return;
		}
		Set<String> keySet2 = map2.keySet();
		for (Iterator iterator = keySet2.iterator(); iterator
				.hasNext();) {
			String str = (String) iterator.next();
			if(keyPathMap.containsKey(str)){
				try {
					String[] split = keyPathMap.get(str).split(",");
					Map<String, Object> mapByKeys = getMapByKeys(map1, split);
					Map<String, Object> temp = (Map<String, Object>) map2.get(str);
					Set<String> tempSet = temp.keySet();
					for (Iterator iterator1 = tempSet.iterator(); iterator1
							.hasNext();) {
						String string = (String) iterator1.next();
						if(mapByKeys.containsKey(string)){
							combine(mapByKeys, temp);
						}else{
							mapByKeys.put(string, temp.get(string));
						}
					}
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}else{
				map1.put(str, (Map<String, Object>)map2.get(str));
			}
		}
	}
	
	public static void main(String[] args) {
		String[] strs=new String[]{"a","b","c","d"};
		Map<String, String[]> tempMap=new HashMap<String, String[]>();
		tempMap.put("a[a1][a11]", strs);
		tempMap.put("a[a1][a12][a121]", strs);
		tempMap.put("b[b1]", strs);
		tempMap.put("b[b2][b21]", strs);
		tempMap.put("b[b2][b22][b221][b2211]", strs);
		tempMap.put("b[b3][b31]", strs);
		tempMap.put("b[b3][b32][b321][b3211][b32111]", strs);
		Map<String, Object> checkMap = changeMapToMapTree(tempMap);
		String[] mapByKeys = getMapValue(checkMap, "b","b3","b32","b321","b3211","b32111");
		for (String string : mapByKeys) {
			System.out.println(string);
		}
	}
[/quote] 谢谢 解决了已经
  • 打赏
  • 举报
回复
引用 14 楼 jiangbai333 的回复:
我尽力了,能不能用的上就不知道了

private static final Map<String,String> keyPathMap=new LinkedHashMap<String, String>();
	
	/**
	 * 入口 传入map
	 * @param tempMap
	 * @return
	 */
	private static Map<String, Object> changeMapToMapTree(Map<String, String[]> tempMap){
		Map<String, Object> checkMap=new HashMap<String, Object>();
		Set<String> keySet = tempMap.keySet();
		for (Iterator iterator = keySet.iterator(); iterator
				.hasNext();) {
			String str = (String) iterator.next();
			Map<String, Object> createMap = createMap(str, tempMap.get(str));
			checkMap = combine(checkMap, createMap);
			String[] split = str.replaceAll("]", "").split("\\[");
			Map<String, Object> map=new HashMap<String, Object>();
			for (int i = 0; i < split.length; i++) {
				if(i==0){
					keyPathMap.put(split[i], split[i]);
				}else{
					keyPathMap.put(split[i], keyPathMap.get(split[i-1])+","+split[i]);
				}
			}
		}
		return checkMap;
	}
	
	/**
	 * 格式化map
	 * @param mapKey map的key
	 * @param value
	 * @return
	 */
	private static Map<String, Object> createMap(String mapKey,String[] value){
		String[] split = mapKey.replaceAll("]", "").split("\\[");
		Map<String, Object> map=new HashMap<String, Object>();
		map.put(split[split.length-1], value);
		if(split.length-1==0){
			return map;
		}
		
		Map<String, Object> ownMap=new HashMap<String, Object>();
		ownMap.put(split[split.length-2], map);
		
		if(split.length-2==0){
			return ownMap;
		}
		Map<String, Object> allMap=new HashMap<String, Object>();
		
		for (int i = split.length-3; i >= 0; i--) {
			Map<String, Object> tempMap=new HashMap<String, Object>();
			tempMap.put(split[i], ownMap);
			ownMap=tempMap;
			allMap.putAll(ownMap);
		}
		Map<String, Object> temp = (Map<String, Object>) allMap.get(split[0]);
		allMap.clear();
		allMap.put(split[0], temp);
		return allMap;
	}
	
	/**
	 * 获取map的值
	 * @param infoMap map
	 * @param mapKey 按顺序排列的key值(变长数组)
	 * @return
	 */
	private static String[] getMapValue(Map<String, Object> infoMap,String... mapKey){
		Map<String, Object> tempMap=infoMap;
		for (int i = 0; i < mapKey.length; i++) {
			if(i==mapKey.length-1){
				return (String[])tempMap.get(mapKey[i]);
			}else{
				tempMap=(Map<String, Object>)tempMap.get(mapKey[i]);
			}
		}
		return null;
	}
	
	/**
	 * 获取map的深层次对象
	 * @param infoMap map
	 * @param mapKey 按顺序排列的key值(变长数组)
	 * @return
	 */
	private static Map<String, Object> getMapByKeys(Map<String, Object> infoMap,String... mapKey){
		Map<String, Object> tempMap=infoMap;
		for (int i = 0; i < mapKey.length; i++) {
			Object object = tempMap.get(mapKey[i]);
			if(object!=null){
				if(object.getClass() != String[].class){
					tempMap=(Map<String, Object>)object;
				}
			}
		}
		return tempMap;
	}
	

	/**
	 * 将两个map中key相同的value合并起来
	 * 
	 * @param map1
	 * @param map2
	 * @return
	 */
	public static Map<String, Object> combine(Map<String, Object> map1, Map<String, Object> map2) {
		if (map1==null||map1.size()==0) {
			return map2;
		}
		if (map2==null||map2.size()==0) {
			return map1;
		}
		Set<String> keySet2 = map2.keySet();
		for (Iterator iterator = keySet2.iterator(); iterator
				.hasNext();) {
			String str = (String) iterator.next();
			if(keyPathMap.containsKey(str)){
				try {
					String[] split = keyPathMap.get(str).split(",");
					Map<String, Object> mapByKeys = getMapByKeys(map1, split);
					Map<String, Object> temp = (Map<String, Object>) map2.get(str);
					Set<String> tempSet = temp.keySet();
					for (Iterator iterator1 = tempSet.iterator(); iterator1
							.hasNext();) {
						String string = (String) iterator1.next();
						if(mapByKeys.containsKey(string)){
							combineForeach(mapByKeys, temp);
						}else{
							mapByKeys.put(string, temp.get(string));
						}
					}
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}else{
				map1.put(str, (Map<String, Object>)map2.get(str));
			}
		}
		return map1;
	}
	
	/**
	 * 将两个map中key相同的value合并起来
	 * 
	 * @param map1
	 * @param map2
	 */
	public static void combineForeach(Map<String, Object> map1, Map<String, Object> map2) {
		if (map1==null||map1.size()==0) {
			map1= map2;
			return;
		}
		if (map2==null||map2.size()==0) {
			return;
		}
		Set<String> keySet2 = map2.keySet();
		for (Iterator iterator = keySet2.iterator(); iterator
				.hasNext();) {
			String str = (String) iterator.next();
			if(keyPathMap.containsKey(str)){
				try {
					String[] split = keyPathMap.get(str).split(",");
					Map<String, Object> mapByKeys = getMapByKeys(map1, split);
					Map<String, Object> temp = (Map<String, Object>) map2.get(str);
					Set<String> tempSet = temp.keySet();
					for (Iterator iterator1 = tempSet.iterator(); iterator1
							.hasNext();) {
						String string = (String) iterator1.next();
						if(mapByKeys.containsKey(string)){
							combine(mapByKeys, temp);
						}else{
							mapByKeys.put(string, temp.get(string));
						}
					}
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}else{
				map1.put(str, (Map<String, Object>)map2.get(str));
			}
		}
	}
	
	public static void main(String[] args) {
		String[] strs=new String[]{"a","b","c","d"};
		Map<String, String[]> tempMap=new HashMap<String, String[]>();
		tempMap.put("a[a1][a11]", strs);
		tempMap.put("a[a1][a12][a121]", strs);
		tempMap.put("b[b1]", strs);
		tempMap.put("b[b2][b21]", strs);
		tempMap.put("b[b2][b22][b221][b2211]", strs);
		tempMap.put("b[b3][b31]", strs);
		tempMap.put("b[b3][b32][b321][b3211][b32111]", strs);
		Map<String, Object> checkMap = changeMapToMapTree(tempMap);
		String[] mapByKeys = getMapValue(checkMap, "b","b3","b32","b321","b3211","b32111");
		for (String string : mapByKeys) {
			System.out.println(string);
		}
	}
jiangbai333 2016-01-20
  • 打赏
  • 举报
回复
没人会么? 求帮助
tony4geek 2016-01-20
  • 打赏
  • 举报
回复
不知道为什么搞的这么复杂。都没怎么看懂。
jiangbai333 2016-01-20
  • 打赏
  • 举报
回复
引用 13 楼 u011376884 的回复:
[quote=引用 12 楼 jiangbai333 的回复:] [quote=引用 4 楼 u011376884 的回复:] 你的key是有规律的吗? 需要把这个key拆分成多个map嵌套,没有规律的话很难做
规律就跟我问题里写的一样! String 待处理的字符串 = "一个字符串[一个字符串][一个字符串].......[一个字符串]"; 下面是符合这个规则的一些例子

"asd[qwe][gasdgasd][vzxcvas]";
"asd";
"asd[ytry123][dsad]";
//上面这些都是允许的
我刚开始想过正则!但是循环不出来![/quote] 单个转能转 但是要把相同key的值合在一起就比较麻烦了[/quote] 单个转的例子 可一给一个么?
  • 打赏
  • 举报
回复
引用 12 楼 jiangbai333 的回复:
[quote=引用 4 楼 u011376884 的回复:] 你的key是有规律的吗? 需要把这个key拆分成多个map嵌套,没有规律的话很难做
规律就跟我问题里写的一样! String 待处理的字符串 = "一个字符串[一个字符串][一个字符串].......[一个字符串]"; 下面是符合这个规则的一些例子

"asd[qwe][gasdgasd][vzxcvas]";
"asd";
"asd[ytry123][dsad]";
//上面这些都是允许的
我刚开始想过正则!但是循环不出来![/quote] 单个转能转 但是要把相同key的值合在一起就比较麻烦了
jiangbai333 2016-01-20
  • 打赏
  • 举报
回复
引用 4 楼 u011376884 的回复:
你的key是有规律的吗? 需要把这个key拆分成多个map嵌套,没有规律的话很难做
规律就跟我问题里写的一样! String 待处理的字符串 = "一个字符串[一个字符串][一个字符串].......[一个字符串]"; 下面是符合这个规则的一些例子

"asd[qwe][gasdgasd][vzxcvas]";
"asd";
"asd[ytry123][dsad]";
//上面这些都是允许的
我刚开始想过正则!但是循环不出来!
  • 打赏
  • 举报
回复
引用 7 楼 jiangbai333 的回复:
[quote=引用 4 楼 u011376884 的回复:] 你的key是有规律的吗? 需要把这个key拆分成多个map嵌套,没有规律的话很难做
没有规律! 再说的简单点儿! 就是这么两个字符串 a[a1][a11] 、a[a1][a12],对应两个值,一个是111111,一个是22222然后转换,现在不用转换成map,转成什么都行! 但是必须是通过a能引用到a1、通过a1能引用到a11、a12 。 然后通过这个链 a->a1->a11 对应里面的值是 111111 a->a1->a12 对应里面的值是 22222[/quote] 我说的规律是单个key字符串的规律 a|a1|a11、a,a1,a11、a;a1;a11之类的有固定的分隔符
jiangbai333 2016-01-20
  • 打赏
  • 举报
回复
引用 8 楼 rui888 的回复:
[quote=引用 7 楼 jiangbai333 的回复:] [quote=引用 4 楼 u011376884 的回复:] 你的key是有规律的吗? 需要把这个key拆分成多个map嵌套,没有规律的话很难做
没有规律! 再说的简单点儿! 就是这么两个字符串 a[a1][a11] 、a[a1][a12],对应两个值,一个是111111,一个是22222然后转换,现在不用转换成map,转成什么都行! 但是必须是通过a能引用到a1、通过a1能引用到a11、a12 。 然后通过这个链 a->a1->a11 对应里面的值是 111111 a->a1->a12 对应里面的值是 22222[/quote] 你的意思是模拟一棵树? 通过树来解决?[/quote] 啊 对呀 有道理啊 ,可以用树! 谢谢你的思路! 另外 还有个问题 这个层数是不确定的 比如 a[a1][a11]、a[a1][a12],还可能 b[b1][b11]、b[b1][b12]、b[b2][b21]、b[b2][b21][b211]....... 大概就是这个意思 总之 就是想 把str[strx][strxx].......[strxxxxxx] 里面[]内字符串都取出来 然后按顺序塞到对象里 然后 通过上一层调用
jiangbai333 2016-01-20
  • 打赏
  • 举报
回复
引用 6 楼 xiesq5112 的回复:

Map<String, String[]> tempMap = new HashMap<String, String[]>();

key                                               value
a[a1][a11]                                  一个字符串数组

Map.get("a").get("a1").get("a11");
这三个联合起来看是行不通的。 tempMap的value为String[] ,你通过Map.get("a");得到就是一个Stirng[] ,它不可能再有get方法了。 而就算第三种取值有问题,你第二种的key为value应该是Map<String, String[String[]]> 终上所述, 你 说 的 究 竟 是 什 么 鬼 ?
不是我没说明白,是你没遇到这个具体问题 你不理解我的意思!

String str = "a[a1][a11]"; //假设对应的值是11111
String str = "a[a1][a12]"; //假设对应的值是22222
 
/**
 * 下面这种情况 是针对 n[nx][nxx] 这种类型的 需要三层map   但是n[nx][nxx][nxxx][nxxxx][nxxxxx][nxxxxxx][nxxxxxxx]...... 这种也坑能会出现! 所以不会怎么循环了!
 */
Map<String, Map> map = new HashMap<String, Map>();
Map<String, Map> map1 = new HashMap<String, Map>();
Map<String, String> map2 = new HashMap<String, String>();

map2.put("a11", "11111");
map2.put("a12", "22222");

map1.put("a1", map2);

map.put("a", map1);

tony4geek 2016-01-20
  • 打赏
  • 举报
回复
引用 7 楼 jiangbai333 的回复:
[quote=引用 4 楼 u011376884 的回复:] 你的key是有规律的吗? 需要把这个key拆分成多个map嵌套,没有规律的话很难做
没有规律! 再说的简单点儿! 就是这么两个字符串 a[a1][a11] 、a[a1][a12],对应两个值,一个是111111,一个是22222然后转换,现在不用转换成map,转成什么都行! 但是必须是通过a能引用到a1、通过a1能引用到a11、a12 。 然后通过这个链 a->a1->a11 对应里面的值是 111111 a->a1->a12 对应里面的值是 22222[/quote] 你的意思是模拟一棵树? 通过树来解决?
jiangbai333 2016-01-20
  • 打赏
  • 举报
回复
引用 4 楼 u011376884 的回复:
你的key是有规律的吗? 需要把这个key拆分成多个map嵌套,没有规律的话很难做
没有规律! 再说的简单点儿! 就是这么两个字符串 a[a1][a11] 、a[a1][a12],对应两个值,一个是111111,一个是22222然后转换,现在不用转换成map,转成什么都行! 但是必须是通过a能引用到a1、通过a1能引用到a11、a12 。 然后通过这个链 a->a1->a11 对应里面的值是 111111 a->a1->a12 对应里面的值是 22222
心随自在飞 2016-01-20
  • 打赏
  • 举报
回复

Map<String, String[]> tempMap = new HashMap<String, String[]>();

key                                               value
a[a1][a11]                                  一个字符串数组

Map.get("a").get("a1").get("a11");
这三个联合起来看是行不通的。 tempMap的value为String[] ,你通过Map.get("a");得到就是一个Stirng[] ,它不可能再有get方法了。 而就算第三种取值有问题,你第二种的key为value应该是Map<String, String[String[]]> 终上所述, 你 说 的 究 竟 是 什 么 鬼 ?
心随自在飞 2016-01-20
  • 打赏
  • 举报
回复
描述好多错误。看得云里雾里!
  • 打赏
  • 举报
回复
你的key是有规律的吗? 需要把这个key拆分成多个map嵌套,没有规律的话很难做
piaopiao11 2016-01-20
  • 打赏
  • 举报
回复
问题描述的不清楚,不太明白是什么意思,或者可以贴一些数据出来看看。

50,504

社区成员

发帖
与我相关
我的任务
社区描述
Java相关技术讨论
javaspring bootspring cloud 技术论坛(原bbs)
社区管理员
  • Java相关社区
  • 小虚竹
  • 谙忆
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧