根据key取其value

Map<String, String> map = new HashMap<String, String>();
        map.put("b", "4");
        map.put("a", "5");
        map.put("c", "3");
        map.put("d", "5");
     // 根据key获取 其value
        System.out.println("通过key获取 其value");
        System.out.println("key 'what'的value为："+map.get("a")+"\n");

不知key取map里的value值——用map.keySet()

 //map.keySet() 先获取map对象的所有key值，再循环遍历获取各个key对应的value;
        System.out.print("通过 map.keySet() 得到key，然后获取value\n");
        for(String key : map.keySet()){
            String value = map.get(key);
            System.out.println(key+"  "+value);
        }

不知key取map里的value值——用Iterator 迭代

//使用迭代器，获取key;
        System.out.print("通过迭代器，获取key，然后获取value\n");
        Iterator<String> iter = map.keySet().iterator();
        while(iter.hasNext()){
            String key=iter.next();
            String value = map.get(key);
            System.out.println(key+" "+value);
        }

不知key取map里的value值——用map.entrySet()

        //通过map.entrySet()方法
        System.out.print("通过map.entrySet()循环map里面的每一对键值对，然后获取key和value\n");
        for(Map.Entry<String, String> vo : map.entrySet()){
            vo.getKey();
            vo.getValue();
            System.out.println(vo.getKey()+"  "+vo.getValue());
        }

源码

public class Maptest {

    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("b", "4");
        map.put("a", "5");
        map.put("c", "3");
        map.put("d", "5");

        //  获取指定 key 的value
        System.out.println("通过key获取 其value");
        System.out.println("key 'what'的value为："+map.get("a")+"\n");
        // 获取map的所有key
        System.out.print("获取map的所有key\n");
        System.out.print("map.keySet():"+map.keySet()+"\n");
        //获取map中所有 value
        System.out.print("获取map中所有 value\n");
        System.out.print("map.values():"+  map.values()+"\n");

        //通过 map.keySet() 得到key的值，然后获取value;
        System.out.print("通过 map.keySet() 得到key，然后获取value\n");
        for(String key : map.keySet()){
            String value = map.get(key);
            System.out.println(key+"  "+value);
        }
        //使用迭代器，获取key;
        System.out.print("通过迭代器，获取key，然后获取value\n");
        Iterator<String> iter = map.keySet().iterator();
        while(iter.hasNext()){
            String key=iter.next();
            String value = map.get(key);
            System.out.println(key+" "+value);
        }
        //通过map.entrySet()方法
        System.out.print("通过map.entrySet()循环map里面的每一对键值对，然后获取key和value\n");
        for(Map.Entry<String, String> vo : map.entrySet()){
            vo.getKey();
            vo.getValue();
            System.out.println(vo.getKey()+"  "+vo.getValue());
        }

}
}

运行结果

通过key获取 其value
key 'a'的value为：5

获取map的所有key
map.keySet():[a, b, c, d]
获取map中所有 value
map.values():[5, 4, 3, 5]
通过 map.keySet() 得到key，然后获取value
a  5
b  4
c  3
d  5
通过迭代器，获取key，然后获取value
a 5
b 4
c 3
d 5
通过map.entrySet()循环map里面的每一对键值对，然后获取key和value
a  5
b  4
c  3
d  5

总结

待续

        适用场景： vaue值不重复场景

        在一次项目中要用到根据当前对象的id查询出当前对象的信息，以及当前对象所在数据库表中根据名称排序后的上一个对象以及下一个对象的id值，即：上一个对象id+当前对象信息+下一个对象id  值

结构如图：

    首根据id查询当前对象的信息直接就能查询出来，之后就是根据当前id查询根据名称排序后之后当前id的前后对象id.

第二步查询对象所在表的全部id形成一个list

然后将遍历list，将每个list的值作为value值存进linkedHashMap中

        // 获取对象id
       list中的数据是从数据库中根据名称排序查询出来的
		List<Long> list = rgDevLightExtMapper.selectAllCrossId();
		int num = 1;
		Map<Integer, Long> map = new LinkedHashMap<>();
		for (int i = 0; i < list.size(); i++) {
			map.put(num, llist.get(i));
			num++;
		}
		// 根据value取key值
		Integer key = null;
		for (Map.Entry<Integer, Long> m : map.entrySet()) {
			if (m.getValue().equals(当前对象Id)) {
				key = m.getKey();
			}
		}
//根据key值取value值 上一个对象id
Long lastId = map.get(key-1);
//根据key值取value值 下一个对象id
Long nextId = map.get(key+1)

最后再将这两个值一起set进含有当前对象的信息的总对象，然后返回总对象

另外一种方法根据value值取key值

//根据value取key值
public static int getKey(char value)//根据字符得到对应的编码
{
int key = 0;
 Set<Map.Entry<Integer, Character>> set = map.entrySet();  
        for(Entry<Integer, Character> entry : set){  
            if(entry.getValue().equals(value)){  
                key = entry.getKey();  
                break;  
            }  
        }   

return key;
}

  Map是通过键值对来储存数据的（key和value），数据可以根据key映射到它的value；

Map<Integer,String> keyAndValue = new LinkedHashMap<>();
            keyAndValue.put(1,"重复数据");
            keyAndValue.put(2,"重复数据");
            keyAndValue.put(3,"重复数据");
            keyAndValue.put(4,"特有数据");

•   当要取key对应的值时是比较简单的，通过 get（key）方法就可以取到值，如通过

  String value = keyAndValue.get(1)

  即可得到key为1时，Map对应的数据，即此时 value的值为  重复数据；

• 当要根据值取key时，就没有上面的直接的方法，而是要经过遍历获取

  String valueWanted = "重复数据";
  List<Integer> keyList = new ArrayList<>();
  for (Map.Entry<Integer,String> keyEntry : keyAndValue.entrySet()) {
        Integer keyWanted = 0;
        String getValue = keyEntry.getValue();
        if (valueWanted.equals(getValue)){
                keyWanted = keyEntry.getKey();
                keyList.add(keyWanted);
                }
      }

  根据此方法则可得到满足条件的key的一个List；

• 当需要满足一定条件的key时，可以在上一方法遍历时的 if 里条件判断加上相应的约束；也可以查找到一个符合条件的key的时候 break 跳出循环，即可限制只返回一个key；

• 思路：当涉及先后操作的时候，可以取不同记录的开始时间来进行比较，以获得想要的数据。

  if (nextId.equals(Id)&& actHiActinstStartTime >= hisStartTime){
       key = actHiActinstEntry.getKey();
       break;
     }

   

• 另外，当返回所有满足条件的key的一个集合的时候，也可以调用集合原有的方法来筛选自己想要的数据

  Collections.max(keyList);
  Collections.min(keyList);

  如以上两个方法，分别可以获得返回集合的最大值、最小值。