Hutool工具集之常用工具类详解使用（三）

1.序言

持续更新（给自己打气），有了前面写的（一）、（二），慢慢的学了不少，现在写需求的时候不自觉会先想到Hutool，挺好用的，也希望可以给大家带来方便！

2.常用工具类

7）Map工具-MapUtil

public static void main(String[] args) {

        //isEmpty、isNotEmpty 判断Map为空和非空方法，空的定义为null或没有值（常用也常见，这个就不举例了）

        //快速创建多种类型的HashMap实例
        //@param boolean Map的Key是否有序，有序返回 {@link LinkedHashMap}，否则返回 {@link HashMap}
        Map<String, Integer> map1 = MapUtil.newHashMap();
        map1.put("a",1);
        map1.put("b",1);
        map1.put("c",1);

        Map<String, Integer> map2 = MapUtil.newHashMap(false);
        map2.put("a",2);
        map2.put("b",2);

        //创建自定义的Map类型的Map
        Map<String, Integer> map3 = MapUtil.newHashMap(3);
        map3.put("a",3);

        Map<String, Integer> map4 = MapUtil.createMap(map3.getClass());
        map4.put("Abc",100);
        map4.put("Bbc",200);
        map4.put("Cbc",300);

        //将一个或多个键值对加入到一个新建的Map中
        Map<Object, Object> colorMap = MapUtil.of(new String[][] {
                {"RED", "#FF0000"},
                {"GREEN", "#00FF00"},
                {"BLUE", "#0000FF"}
        });

        //toListMap 行转列，合并相同的键，值合并为列表，将Map列表中相同key的值组成列表做为Map的value
        List<Map<String, Integer>> list = new ArrayList<Map<String, Integer>>();
        //map1 = {a=1, b=1, c=1}
        list.add(map1);
        //map2 = {a=2, b=2}
        list.add(map2);
        //map3 = {a=3}
        list.add(map3);
        //map5 = {a=[1, 2, 3], b=[1, 2], c=[1]}
        Map<String, List<Integer>> map5 = MapUtil.toListMap(list);

        //toMapList 列转行。将Map中值列表分别按照其位置与key组成新的map
        Map<String, List<Integer>> map6 = MapUtil.createMap(map5.getClass());
        map6.put("a", Arrays.asList(1,2,3));
        map6.put("b", Arrays.asList(1,2));
        map6.put("c", Arrays.asList(1));
        //map6 = {a=[1, 2, 3], b=[1, 2], c=[1]}
        //map7 = [{a=1, b=1, c=1}, {a=2, b=2}, {a=3}]
        List<Map<String, Integer>> map7 = MapUtil.toMapList(map6);

        //将Map按照给定的分隔符转换为字符串,entry之间的连接符和kv之间的连接符都可以自定义
        //map6 = {a=[1, 2, 3], b=[1, 2], c=[1]}
        //joinMap6 = a:[1, 2, 3];b:[1, 2];c:[1]
        String joinMap6 = MapUtil.join(map6, ";", ":");

        //Map的键和值互换(键值类型必须一致)
        Map<Integer, Integer> map8 = MapUtil.createMap(map6.getClass());
        map8.put(520,1314);
        map8.put(456,123);
        //map8 = {520=1314, 456=123}
        //reverse = {1314=520, 123=456}
        Map<Integer, Integer> reverse = MapUtil.reverse(map8);

    }

8）Bean工具-BeanUtil

是否为Bean对象

BeanUtil.isBean方法根据是否存在只有一个参数的setXXX方法来判定是否是一个Bean对象。这样的判定方法主要目的是保证至少有一个setXXX方法用于属性注入。

		//isBean = false
        boolean isBean1 = BeanUtil.isBean(HashMap.class);
        //isBean2 = true
        boolean isBean2 = BeanUtil.isBean(Person.class);

内省 Introspector

把一类中需要进行设置和获得的属性访问权限设置为private（私有的）让外部的使用者看不见摸不着，而通过public（共有的）set和get方法来对其属性的值来进行设置和获得，而内部的操作具体是怎样的？外界使用的人不用不知道，这就称为内省。

Hutool中对内省的封装包括：

1. BeanUtil.getPropertyDescriptors 获得Bean字段描述数组

2. BeanUtil.getFieldNamePropertyDescriptorMap 获得字段名和字段描述Map

3. BeanUtil.getPropertyDescriptor 获得Bean类指定属性描述

//获得Bean字段描述数组
        PropertyDescriptor[] descriptors = BeanUtil.getPropertyDescriptors(Person.class);

        //获得Bean类指定属性描述
        //name = java.beans.PropertyDescriptor[name=name; propertyType=class java.lang.String;
        // readMethod=public java.lang.String com.jy.study.entity.Person.getName();
        // writeMethod=public void com.jy.study.entity.Person.setName(java.lang.String)]
        PropertyDescriptor name = BeanUtil.getPropertyDescriptor(Person.class, "name");

Bean属性注入

BeanUtil.fillBean方法是bean注入的核心方法，此方法传入一个ValueProvider接口，通过实现此接口来获得key对应的值。CopyOptions参数则提供一些注入属性的选项。

CopyOptions的配置项包括：

1. editable 限制的类或接口，必须为目标对象的实现接口或父类，用于限制拷贝的属性，例如一个类我只想复制其父类的一些属性，就可以将editable设置为父类。

2. ignoreNullValue 是否忽略空值，当源对象的值为null时，true: 忽略而不注入此值，false: 注入null

3. ignoreProperties 忽略的属性列表，设置一个属性列表，不拷贝这些属性值

4. ignoreError 是否忽略字段注入错误

可以通过CopyOptions.create()方法创建一个默认的配置项，通过setXXX方法设置每个配置项。

ValueProvider接口需要实现两个方法：

1. value方法是通过key和目标类型来从任何地方获取一个值，并转换为目标类型，如果返回值不和目标类型匹配，将会自动调用Convert.convert方法转换。

2. containsKey方法主要是检测是否包含指定的key，如果不包含这个key，其对应的属性将会忽略注入。

首先定义一个bean：

public class Person{
    private String name;
    private int age;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

然后注入这个bean：

Person person = BeanUtil.fillBean(new Person(), new ValueProvider<String>(){

    @Override
    public Object value(String key, Class<?> valueType) {
        switch (key) {
            case "name":
                return "张三";
            case "age":
                return 18;
        }
        return null;
    }

    @Override
    public boolean containsKey(String key) {
        //总是存在key
        return true;
    }

}, CopyOptions.create());

Assert.assertEquals(person.getName(), "张三");
Assert.assertEquals(person.getAge(), 18);

同时，Hutool还提供了BeanUtil.toBean方法，此处并不是传Bean对象，而是Bean类，Hutool会自动调用默认构造方法创建对象。

基于BeanUtil.fillBean方法Hutool还提供了Map对象键值对注入Bean，其方法有：

1. BeanUtil.fillBeanWithMap

2. BeanUtil.fillBeanWithMapIgnoreCase

同时提供了map转bean的方法，与fillBean不同的是，此处并不是传Bean对象，而是Bean类，Hutool会自动调用默认构造方法创建对象。当然，前提是Bean类有默认构造方法（空构造），这些方法有：

1. BeanUtil.mapToBean

2. BeanUtil.mapToBeanIgnoreCase

在Java Web应用中，我们经常需要将ServletRequest对象中的参数注入bean（http表单数据），BeanUtil类提供了两个便捷方法：

1. BeanUtil.fillBeanWithRequestParam 将http表单数据注入Bean对象

2. BeanUtil.requestParamToBean 将http表单数据注入新建的Bean对象

9）JSONUtil

JSON在现在的开发中做为跨平台的数据交换格式已经慢慢有替代XML的趋势（比如RestFul规范），我想大家在开发中对外提供接口也越来越多的使用JSON格式。
在JSON中，Hutool封装了getXXX方法，支持大部分内置类型的值获取操作。比如：

JSONObject json1 = JSONUtil.createObj();
json1.getStr("key");
json1.getInt("key");
json1.getLong("key");
json1.getDouble("key");
json1.getBigDecimal("key");

这些成员方法的加入，可以省掉大量的类型转换代码，大大提高JSON的操作简便性。

JSONObject代表一个JSON中的键值对象，这个对象以大括号包围，每个键值对使用,隔开，键与值使用:隔开，一个JSONObject类似于这样：

{
  "key1":"value1",
  "key2":"value2"
}

创建

JSONObject json1 = JSONUtil.createObj();
json1.put("a", "value1");
json1.put("b", "value2");
json1.put("c", "value3");

JSONUtil.createObj()是快捷新建JSONObject的工具方法，同样我们可以直接new：

JSONObject json1 = new JSONObject();

转换

String jsonStr = "{\"b\":\"value2\",\"c\":\"value3\",\"a\":\"value1\"}";
//方法一：使用工具类转换
JSONObject jsonObject = JSONUtil.parseObj(jsonStr);
//方法二：new的方式转换
JSONObject jsonObject2 = new JSONObject(jsonStr);

//JSON对象转字符串
jsonObject.toString();

同样，JSONUtil还可以支持以下对象转为JSONObject对象：

String对象
Java Bean对象
Map对象
XML字符串（使用JSONUtil.parseFromXml方法）
ResourceBundle(使用JSONUtil.parseFromResourceBundle)
JSONUtil还提供了JSONObject对象转换为其它对象的方法：

toJsonStr 转换为JSON字符串
toXmlStr 转换为XML字符串
toBean 转换为JavaBean

在JSON中，JSONArray代表一个数组，使用中括号包围，每个元素使用逗号隔开。一个JSONArray类似于这样：

["value1","value2","value3"]

创建

//方法1
JSONArray array = JSONUtil.createArray();
//方法2
JSONArray array = new JSONArray();

array.add("value1");
array.add("value2");
array.add("value3");

//转为JSONArray字符串
array.toString();

转换

String jsonStr = "[\"value1\", \"value2\", \"value3\"]";
JSONArray array = JSONUtil.parseArray(jsonStr);

JSONUtil是针对JSONObject和JSONArray的静态快捷方法集合，在之前的章节我们已经介绍了一些工具方法，在本章节我们将做一些补充。

parseXXX和toXXX
这两种方法主要是针对JSON和其它对象之间的转换。

readXXX
这类方法主要是从JSON文件中读取JSON对象的快捷方法。包括：

readJSON
readJSONObject
readJSONArray
其它方法
除了上面中常用的一些方法，JSONUtil还提供了一些JSON辅助方法：

quote 对所有双引号做转义处理（使用双反斜杠做转义）
wrap 包装对象，可以将普通任意对象转为JSON对象
formatJsonStr 格式化JSON字符串，此方法并不严格检查JSON的格式正确与否