一个非常难的问题，高分

2016-01-20 11:08:59 482 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

FreeRTOS面试题汇总如果一个低优先级的任务持有一个信号量，高优先级的任务想要用这个信号量，造成的死锁怎么解决。12.FreeRTOS的多任务之间如何去进行通信的，什么方法，它实现原理是什么。任务间数据传输一共有三种形式，用的最多的是消息队列，其次是全局变量和信号量。简历上写了了解RTOS，问了rtos的问题，用过哪些函数。讲解FreeRtos原理，调度机制，底层原理，代码调用。FreeRTOS，你的三个任务控制，请问你是怎么实现的。freertos中EventBits_t是干啥的？freertos使任务切换的方式有哪些？阅读详情

一个下面类型的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转换出来！弄了两天了没整明白

...全文

混合部署操作系统混合部署在openEuler Embedded 22.03中，已经集成了OpenAMP相关支持，并与openEuler的SIG Zephyr合作实现了openEuler Embedded与实时操作系统Zephyr在QEMU平台上的混合部署。具体的混合部署方式取决于设备的硬件和软件支持。例如，可以使用虚拟机软件（如VirtualBox）在Linux操作系统上运行Android虚拟机，从而实现Linux和Android的混合部署。需要注意的是，混合部署涉及到设备的硬件和软件兼容性，以及操作系统的配置和管理。阅读详情

jiangbai333

Java 51,407 成员 86,126 内容

+ 关注 + 加入社区

切换为时间正序

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] 谢谢解决了已经

逝_去_的_光_阴 2016-01-21

打赏
举报

引用 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] 单个转的例子可一给一个么？

逝_去_的_光_阴 2016-01-20

打赏
举报

引用 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]";
//上面这些都是允许的

我刚开始想过正则！但是循环不出来！

逝_去_的_光_阴 2016-01-20

打赏
举报

引用 7 楼 jiangbai333 的回复:

[quote=引用 4 楼 u011376884 的回复:] 你的key是有规律的吗？需要把这个key拆分成多个map嵌套，没有规律的话很难做

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嵌套，没有规律的话很难做

jiangbai333 2016-01-20

打赏
举报

引用 4 楼 u011376884 的回复:

你的key是有规律的吗？需要把这个key拆分成多个map嵌套，没有规律的话很难做

心随自在飞 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

打赏
举报

描述好多错误。看得云里雾里！

逝_去_的_光_阴 2016-01-20

打赏
举报

你的key是有规律的吗？需要把这个key拆分成多个map嵌套，没有规律的话很难做

piaopiao11 2016-01-20

打赏
举报

问题描述的不清楚，不太明白是什么意思，或者可以贴一些数据出来看看。

一个非常难的问题，高分

相关推荐