MapUtils常用方法

qq_41482600

已于 2024-08-01 17:48:39 修改

阅读量555

点赞数 22

分类专栏： java基础文章标签：开发语言

于 2024-08-01 16:53:57 首次发布

本文链接：https://blog.csdn.net/qq_41482600/article/details/140851683

版权

java基础专栏收录该内容

20 篇文章 0 订阅

订阅专栏

1、摘要

MapUtils是一个用于处理Map对象的实用工具类，它提供了许多方便的方法来执行常见的操作，如获取值、设置默认值、合并Map等。本文将介绍MapUtils的常见用法，以帮助你更轻松地处理Map数据。

2、前言

在Java编程中，Map是一种常用的数据结构，用于存储键值对。然而，处理Map数据时，经常需要进行一些繁琐的操作，例如检查键是否存在，获取键对应的值，或者在键不存在时设置默认值。为了简化这些任务，Apache Commons Lang库提供了一个实用工具类MapUtils。

3、配置方法

要使用MapUtils，首先需要导入Apache Commons Lang库。你可以通过以下方式配置你的Java项目来使用MapUtils：

下载Apache Commons Lang库，并将其添加到你的项目中。
使用构建工具如Maven或Gradle，在项目的依赖中添加Apache Commons Lang库。

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.1</version>
</dependency>

4、方法

可以从指定map中获取常用基础类型的值，都会判断map，map为null返回null,get结果为null返回null：

修饰符和返回类型	方法	描述
static Boolean	getBoolean(Map<? super K,?> map, K key)	从Map获取Boolean
static Boolean	getBoolean(Map<? super K,?> map, K key, Boolean defaultValue)	将结果转换为Boolean，如果转换失败则使用默认值
static boolean	getBooleanValue(Map<? super K,?> map, K key)	从Map获取boolean。
static boolean	getBooleanValue(Map<? super K,?> map, K key, boolean defaultValue)	如果转换失败，则使用默认值
static Double	getDouble(Map<? super K,?> map, K key)	从Map获取Double
static Double	getDouble(Map<? super K,?> map, K key, Double defaultValue)	将结果转换为Double，如果转换失败则使用默认值
static double	getDoubleValue(Map<? super K,?> map, K key)	从Map获取double
static double	getDoubleValue(Map<? super K,?> map, K key, double defaultValue)	如果转换失败，则使用默认值
static Float	getFloat(Map<? super K,?> map, K key)	从Map获取Float
static Float	getFloat(Map<? super K,?> map, K key, Float defaultValue)	将结果转换为Float，如果转换失败则使用默认值
static float	getFloatValue(Map<? super K,?> map, K key)	从Map获取float
static float	getFloatValue(Map<? super K,?> map, K key, float defaultValue)	如果转换失败，则使用默认值
static Integer	getInteger(Map<? super K,?> map, K key)	从Map获取Integer
static Integer	getInteger(Map<? super K,?> map, K key, Integer defaultValue)	将结果转换为Integer，如果转换失败则使用默认值
static int	getIntegerValue(Map<? super K,?> map, K key)	从Map获取int
static int	getIntegerValue(Map<? super K,?> map, K key, int defaultValue)	如果转换失败，则使用默认值
static Long	getLong(Map<? super K,?> map, K key)	从Map获取Long
static Long	getLong(Map<? super K,?> map, K key, Long defaultValue)	将结果转换为Long，如果转换失败则使用默认值
static long	getLongValue(Map<? super K,?> map, K key)	从Map获取long
static long	getLongValue(Map<? super K,?> map, K key, long defaultValue)	如果转换失败，则使用默认值
static String	getString(Map<? super K,?> map, K key)	从Map获取String
static String	getString(Map<? super K,?> map, K key, String defaultValue)	将结果转换为String，如果转换失败则使用默认值

5、常用方法

5.1、`isNotEmpty()`: 是否不为空

用于检查Map是否不为空，即包含至少一个键值对。

import org.apache.commons.lang3.MapUtils;
import java.util.HashMap;
import java.util.Map;

public class MapUtilsDemo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("key1", "value1");
        
        boolean isNotEmpty = MapUtils.isNotEmpty(map);
        System.out.println("Map is not empty: " + isNotEmpty);
    }
}

5.2、`isEmpty()`: 是否为空

用于检查Map是否为空，即不包含任何键值对。

import org.apache.commons.lang3.MapUtils;
import java.util.HashMap;
import java.util.Map;

public class MapUtilsDemo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        
        boolean isEmpty = MapUtils.isEmpty(map);
        System.out.println("Map is empty: " + isEmpty);
    }
}

5.3、`putAll()`: 添加所有元素

将另一个Map的所有键值对添加到目标Map中。

import org.apache.commons.lang3.MapUtils;
import java.util.HashMap;
import java.util.Map;

public class MapUtilsDemo {
    public static void main(String[] args) {
        Map<String, String> sourceMap = new HashMap<>();
        sourceMap.put("key1", "value1");
        sourceMap.put("key2", "value2");
        
        Map<String, String> targetMap = new HashMap<>();
        MapUtils.putAll(targetMap, sourceMap);
        
        System.out.println("Target Map: " + targetMap);
    }
}

5.4、`getString()`: 获取String类型的值

从Map中获取String类型的值，可以指定默认值。

import org.apache.commons.lang3.MapUtils;
import java.util.HashMap;
import java.util.Map;

public class MapUtilsDemo {
    public static void main(String[] args) {
        Map<String, Object> map = new HashMap<>();
        map.put("name", "John");
        
        String value = MapUtils.getString(map, "name", "Unknown");
        System.out.println("Name: " + value);
    }
}

5.5、`getObject()`: 获取Object类型的值

从Map中获取Object类型的值，可以指定默认值。

import org.apache.commons.lang3.MapUtils;
import java.util.HashMap;
import java.util.Map;

public class MapUtilsDemo {
    public static void main(String[] args) {
        Map<String, Object> map = new HashMap<>();
        map.put("age", 30);
        
        Object value = MapUtils.getObject(map, "age", null);
        System.out.println("Age: " + value);
    }
}

5.6、`getInteger()`: 获取Integer类型的值

从Map中获取Integer类型的值，可以指定默认值。

import org.apache.commons.lang3.MapUtils;
import java.util.HashMap;
import java.util.Map;

public class MapUtilsDemo {
    public static void main(String[] args) {
        Map<String, Object> map = new HashMap<>();
        map.put("count", 42);
        
        Integer value = MapUtils.getInteger(map, "count", 0);
        System.out.println("Count: " + value);
    }
}

5.7、`EMPTY_MAP`: 获取一个不可修改的空类型Map

获取一个不可修改的空Map，通常用于表示空数据。

import org.apache.commons.lang3.MapUtils;

public class MapUtilsDemo {
    public static void main(String[] args) {
        Map<String, String> emptyMap = MapUtils.EMPTY_MAP;
        System.out.println("Empty Map: " + emptyMap);
    }
}

5.8、`unmodifiableMap`: 获取一个不可修改的Map

获取一个不可修改的Map，不能新增或删除键值对。

import org.apache.commons.lang3.MapUtils;
import java.util.HashMap;
import java.util.Map;

public class MapUtilsDemo {
    public static void main(String[] args) {
        Map<String, String> mutableMap = new HashMap<>();
        mutableMap.put("key1", "value1");
        
        Map<String, String> unmodifiableMap = MapUtils.unmodifiableMap(mutableMap);
        // This will throw an UnsupportedOperationException
        unmodifiableMap.put("key2", "value2");
    }
}

5.9、`unmodifiableSortedMap`: 获取一个不可修改的有序的Map

获取一个不可修改的有序Map，同样不能新增或删除键值对。

import org.apache.commons.lang3.MapUtils;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class MapUtilsDemo {
    public static void main(String[] args) {
        Map<String, String> mutableMap = new TreeMap<>();
        mutableMap.put("key1", "value1");
        
        Map<String, String> unmodifiableMap = MapUtils.unmodifiableSortedMap(mutableMap);
        // This will throw an UnsupportedOperationException
        unmodifiableMap.put("key2", "value2");
    }
}

5.10、`fixedSizeMap`: 获取一个固定长度的Map

获取一个固定长度的Map，不能新增或删除键值对，也不能修改已存在的键值对数量。

import org.apache.commons.lang3.MapUtils;
import java.util.Map;

public class MapUtilsDemo {
    public static void main(String[] args) {
        Map<String, String> fixedSizeMap = MapUtils.fixedSizeMap(new HashMap<>());
        fixedSizeMap.put("key1", "value1"); // This will throw an UnsupportedOperationException
    }
}

5.11、`multiValueMap`: 获取一个多值的Map

获取一个多值的Map，即一个键可以对应多个值。

import org.apache.commons.lang3.MapUtils;
import org.apache.commons.collections4.MultiMap;
import org.apache.commons.collections4.map.MultiValueMap;

public class MapUtilsDemo {
    public static void main(String[] args) {
        MultiMap<String, String> multiValueMap = new MultiValueMap<>();
        multiValueMap.put("key1", "value1");
        multiValueMap.put("key1", "value2");
        
        System.out.println("Multi-Value Map: " + multiValueMap);
    }
}

5.12、`invertMap`: 返回一个键值对调的Map

返回一个新的Map，其中键和值互换。

import org.apache.commons.lang3.MapUtils;
import java.util.HashMap;
import java.util.Map;

public class MapUtilsDemo {
    public static void main(String[] args) {
        Map<String, Integer> originalMap = new HashMap<>();
        originalMap.put("one", 1);
        originalMap.put("two", 2);
        
        Map<Integer, String> invertedMap = MapUtils.invertMap(originalMap);
        System.out.println("Inverted Map: " + invertedMap);
    }
}

5.13、`predicatedMap()`: 返回一个满足predicate条件的Map

返回一个新的Map，其中的键值对满足指定条件。

import org.apache.commons.collections4.Predicate;
import org.apache.commons.collections4.map.PredicatedMap;
import org.apache.commons.lang3.MapUtils;

import java.util.HashMap;
import java.util.Map;

public class MapUtilsDemo {
    public static void main(String[] args) {
        Map<String, Integer> originalMap = new HashMap<>();
        originalMap.put("one", 1);
        originalMap.put("two", 2);
        
        Predicate<String> keyPredicate = key -> key.startsWith("t");
        
        Map<String, Integer> predicatedMap = MapUtils.predicatedMap(originalMap, keyPredicate, null);
        System.out.println("Predicated Map: " + predicatedMap);
    }
}

5.14、 `lazyMap`: 返回一个lazy的Map

返回一个延迟加载的Map，在需要时才创建值。

import org.apache.commons.collections4.Factory;
import org.apache.commons.collections4.map.LazyMap;
import org.apache.commons.lang3.MapUtils;

import java.util.HashMap;
import java.util.Map;

public class MapUtilsDemo {
    public static void main(String[] args) {
        Factory<String> valueFactory = () -> "Lazy Value";
        Map<String, String> lazyMap = LazyMap.lazyMap(new HashMap<>(), valueFactory);
        
        // Lazy value is only created when accessed
        String value = lazyMap.get("key");
        
        System.out.println("Lazy Map Value: " + value);
    }
}

import org.apache.commons.lang3.MapUtils;
import org.junit.Assert;

import java.util.HashMap;
import java.util.Map;

public class MapUtilsDemo {

    public static void main(String[] args) {
        // 定义一个空的Map和一个包含一些键值对的Map
        Map<String, Object> nullMap = null;
        Map<String, Object> map = new HashMap<>();
        map.put("user", new User());
        map.put("boolean", true);
        map.put("integer", 5);

        // 使用MapUtils.getBoolean
        // 预期：从Map中获取"boolean"键对应的布尔值，应返回true
        Assert.assertTrue(MapUtils.getBoolean(map, "boolean"));
        // 预期：从Map中获取"user"键对应的布尔值，但转换失败，应返回默认值false
        Assert.assertFalse(MapUtils.getBoolean(map, "user", false));
        // 预期：目标map为null，无法获取值，应返回null
        Assert.assertNull(MapUtils.getBoolean(nullMap, "boolean"));
        // 预期：目标map为null，无法获取值，应返回默认值false
        Assert.assertFalse(MapUtils.getBoolean(nullMap, "boolean", false));

        // 使用MapUtils.getBooleanValue
        // 预期：从Map中获取"boolean"键对应的布尔值，应返回true
        Assert.assertTrue(MapUtils.getBooleanValue(map, "boolean"));
        // 预期：从Map中获取"user"键对应的布尔值，但转换失败，应返回默认值false
        Assert.assertFalse(MapUtils.getBooleanValue(map, "user", false));
        // 预期：目标map为null，无法获取值，应返回false
        Assert.assertFalse(MapUtils.getBooleanValue(nullMap, "boolean"));
        // 预期：目标map为null，无法获取值，应返回默认值false
        Assert.assertFalse(MapUtils.getBooleanValue(nullMap, "boolean", false));

        // 使用MapUtils.getInteger
        // 预期：从Map中获取"integer"键对应的整数值，应返回Integer类型的值5
        Assert.assertEquals(Integer.valueOf(5), MapUtils.getInteger(map, "integer"));
        // 预期：从Map中获取"integer"键对应的整数值，但转换失败，应返回默认值5
        Assert.assertEquals(Integer.valueOf(5), MapUtils.getInteger(map, "integer", 5));
        // 预期：目标map为null，无法获取值，应返回null
        Assert.assertNull(MapUtils.getInteger(nullMap, "integer"));
        // 预期：目标map为null，无法获取值，应返回默认值5
        Assert.assertEquals(Integer.valueOf(5), MapUtils.getInteger(nullMap, "integer", 5));

        // 使用MapUtils.getIntValue
        // 预期：从Map中获取"integer"键对应的整数值，应返回int类型的值5
        Assert.assertEquals(5, MapUtils.getIntValue(map, "integer"));
        // 预期：从Map中获取"user"键对应的整数值，但转换失败，应返回默认值5
        Assert.assertEquals(5, MapUtils.getIntValue(map, "user", 5));
        // 预期：目标map为null，无法获取值，应返回0（int的默认值）
        Assert.assertEquals(0, MapUtils.getIntValue(nullMap, "integer"));
        // 预期：目标map为null，无法获取值，应返回默认值5
        Assert.assertEquals(5, MapUtils.getIntValue(nullMap, "integer", 5));
    }

    // 一个示例的用户类，用于模拟Map中的对象
    static class User {
        // 你可以在这里添加用户属性和行为
    }
}

qq_41482600

关注

22
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
MapUtils常用方法

MapUtils是一个用于处理Map对象的实用工具类，它提供了许多方便的方法来执行常见的操作，如获取值、设置默认值、合并Map等。本文将介绍MapUtils的常见用法，以帮助你更轻松地处理Map数据。在Java编程中，Map是一种常用的数据结构，用于存储键值对。然而，处理Map数据时，经常需要进行一些繁琐的操作，例如检查键是否存在，获取键对应的值，或者在键不存在时设置默认值。为了简化这些任务，Apache Commons Lang库提供了一个实用工具类MapUtils。
复制链接

扫一扫