语法使用

Java HashMap

HashMap 是 Map 族中最为常用的一种，也是 Java Collection Framework 的重要成员。

创建

Collections.singletonMap("server.port", "8083")

增删操作

访问遍历

我们常用的遍历 HashMap 的方式有以下几种：

使用 Map 的 forEach 方法加上 Java8 的 lambda 表达式:

aMap.forEach( (k,v)->{System.out.println(k+" "+v);} );

使用 Map.Entry 来遍历 Map 的条目:

for(Map.Entry<String, String> it : aMap.entrySet()){
	System.out.println(it.getKey()+"="+it.getValue());
	System.out.println(it);
}

使用 for 结合 Map 的 keySet 和 values 方法来遍历:

for(String a : aMap.keySet()){
	System.out.println(a);
}

for(String a : aMap.values()){
	System.out.println(a);
}

使用迭代器, 这种是看起来比较熟悉而且效率挺高的, 但是要注意, 不能在使用 for 循环访问迭代器的同时使用 remove 操作, javadoc 说这样会发生不可预期的错误, 如果希望迭代的同时删除元素, 可以使用 while 来遍历:

for(Iterator<Map.Entry<String, String>> it = aMap.entrySet().iterator();it.hasNext();){
	Map.Entry<String, String> itt = it.next();
	System.out.println(itt.getKey()+"="+itt.getValue());
	System.out.println(itt);
}

统计操作

Sort | 排序

按键排序

public Map<String, String> sortMapByKey(Map<String, String> oriMap) {
    if (oriMap == null || oriMap.isEmpty()) {
        return null;
    }
    Map<String, String> sortedMap = new TreeMap<String, String>(new Comparator<String>() {
        public int compare(String key1, String key2) {
            int intKey1 = 0, intKey2 = 0;
            try {
                intKey1 = getInt(key1);
                intKey2 = getInt(key2);
            } catch (Exception e) {
                intKey1 = 0;
                intKey2 = 0;
            }
            return intKey1 - intKey2;
        }});
    sortedMap.putAll(oriMap);
    return sortedMap;
}

private int getInt(String str) {
    int i = 0;
    try {
        Pattern p = Pattern.compile("^\\d+");
        Matcher m = p.matcher(str);
        if (m.find()) {
            i = Integer.valueOf(m.group());
        }
    } catch (NumberFormatException e) {
        e.printStackTrace();
    }
    return i;
}

按值排序

public Map<String, String> sortMapByValue(Map<String, String> oriMap) {
    Map<String, String> sortedMap = new LinkedHashMap<String, String>();
    if (oriMap != null && !oriMap.isEmpty()) {
        List<Map.Entry<String, String>> entryList = new ArrayList<Map.Entry<String, String>>(oriMap.entrySet());
        Collections.sort(entryList,
                new Comparator<Map.Entry<String, String>>() {
                    public int compare(Entry<String, String> entry1,
                            Entry<String, String> entry2) {
                        int value1 = 0, value2 = 0;
                        try {
                            value1 = getInt(entry1.getValue());
                            value2 = getInt(entry2.getValue());
                        } catch (NumberFormatException e) {
                            value1 = 0;
                            value2 = 0;
                        }
                        return value2 - value1;
                    }
                });
        Iterator<Map.Entry<String, String>> iter = entryList.iterator();
        Map.Entry<String, String> tmpEntry = null;
        while (iter.hasNext()) {
            tmpEntry = iter.next();
            sortedMap.put(tmpEntry.getKey(), tmpEntry.getValue());
        }
    }
    return sortedMap;
}

应用示例

数组转化为树

/** 菜单DO类 */
@Setter
@Getter
@ToString
public static class MenuDO {
    /** 菜单标识 */
    private Long id;
    /** 菜单父标识 */
    private Long parentId;
    /** 菜单名称 */
    private String name;
    /** 菜单链接 */
    private String url;
}

/** 菜单VO类 */
@Setter
@Getter
@ToString
public static class MenuVO {
    /** 菜单标识 */
    private Long id;
    /** 菜单名称 */
    private String name;
    /** 菜单链接 */
    private String url;
    /** 子菜单列表 */
    private List<MenuVO> childList;
}

/** 构建菜单树函数 */
public static List<MenuVO> buildMenuTree(List<MenuDO> menuList) {
    // 检查列表为空
    if (CollectionUtils.isEmpty(menuList)) {
        return Collections.emptyList();
    }

    // 依次处理菜单
    int menuSize = menuList.size();
    List<MenuVO> rootList = new ArrayList<>(menuSize);
    Map<Long, MenuVO> menuMap = new HashMap<>(menuSize);
    for (MenuDO menuDO : menuList) {
        // 赋值菜单对象
        Long menuId = menuDO.getId();
        MenuVO menu = menuMap.get(menuId);
        if (Objects.isNull(menu)) {
            menu = new MenuVO();
            menu.setChildList(new ArrayList<>());
            menuMap.put(menuId, menu);
        }
        menu.setId(menuDO.getId());
        menu.setName(menuDO.getName());
        menu.setUrl(menuDO.getUrl());

        // 根据父标识处理
        Long parentId = menuDO.getParentId();
        if (Objects.nonNull(parentId)) {
            // 构建父菜单对象
            MenuVO parentMenu = menuMap.get(parentId);
            if (Objects.isNull(parentMenu)) {
                parentMenu = new MenuVO();
                parentMenu.setId(parentId);
                parentMenu.setChildList(new ArrayList<>());
                menuMap.put(parentId, parentMenu);
            }

            // 添加子菜单对象
            parentMenu.getChildList().add(menu);
        } else {
            // 添加根菜单对象
            rootList.add(menu);
        }
    }

    // 返回根菜单列表
    return rootList;
}

最近更新于 0001-01-01