Map clone:

Given a simpleMap defined as follow:

Map<String, List<String>> map = new HashMap<>();map.put("key", List.of("value1", "value2"));

it can be cloned using the following command:

Map<String, List<String>> newMap = new MapUtils().getTransformer().transform(map);

Map a Key value into a different Key in the destination Map:

Given a simpleMap defined as follow:

Map<String, String> map = new HashMap<>();map.put("key1", "Hello");map.put("key2", "Dude");

And assuming that we want that thekey2 value, in the destination map, has to be thekey1 one,the only thing we need to do is to define the field mapping:

FieldMapping<String, String> keyMapping = new FieldMapping<>("key1", "key2");Map<String, List<String>> newMap = new MapUtils().getTransformer()                                        .withFieldMapping(keyMapping)                                        .transform(map);

Then if we run the following command:

System.out.println(newMap.get("key2"));

the output will be:

Hello

Apply a transformation function on a Map key:

Given a simpleMap defined as follow:

Map<String, String> map = new HashMap<>();map.put("name", "John");map.put("surname", "Smith");

And assuming that we want that thename correspondent key is made upper case,the only thing we need to do is to apply aFieldTransformer to thekey defined as following:

FieldTransformer<String, String> keyTransformer = new FieldTransformer<>("name", String::toUpperCase);Map<String, List<String>> newMap = new MapUtils().getTransformer()                                        .withKeyTransformer(keyTransformer)                                        .transform(map);

Then the key: “name” in thenewMapwill be:NAME

Apply a transformation function on a Map value:

Given a simpleMap defined as follow:

Map<String, Integer> map = new HashMap<>();map.put("key1", 30);map.put("key2", 200);

And assuming that we want that thekey1 correspondent value is raised to the power of 2,the only thing we need to do is to define aFieldTransformer as following:

FieldTransformer<Integer, Integer> keyPow = new FieldTransformer<>("key1", val -> Math.pow(val, 2));Map<String, List<String>> newMap = new MapUtils().getTransformer()                                        .withFieldTransformer(keyPow)                                        .transform(map);

Then if we run the following command:

System.out.println(newMap.get("key1"));

the output will be:

900

Transform Map key or value object into a different object

Assuming that we have a map defined as follow:

Map<FromBean, FromSubBean> sourceMap = new HashMap<>();

and we want to transform it in:

Map<ToBean, ToSubBean> map = new HashMap<>();

whereFromBean andToBean are:

public class FromBean {                                     public class ToBean {                              private final String name;                                  @NotNull                      private final BigInteger id;                                public BigInteger id;                         private final List<FromSubBean> subBeanList;                private final String name;                    private List<String> list;                                  private final List<String> list;                       private final FromSubBean subObject;                        private final List<ToSubBean> subBeanList;                                                                                   private ToSubBean subObject;      // all constructors                                         // all args constructor   // getters and setters...                                   // getters and setters... }

andFromSubBean andToSubBean are:

public class FromBean {                                     public class ToBean {                              private final String index;                                 private final String index;      // all constructor                                         // all args constructor   // getters...                                              // getters... }

what we need to do is to specify the MapKey andElement class in the destination Map.

In our case it will be:

Map<ToBean, ToSubBean> map = new MapUtils().getTransformer()                                           .transform(sourceMap, ToBean.class, ToSubBean.class);

Configure a BeanTransformer and use it fo the Map transformation

Assuming that we have two classes with different field names defined as follow:

public class FromBean {                                     public class ToBean {                                                                                                                     private final String name;                                  private final String differentName;                      private final int id;                                       private final int id;                         private final List<FromSubBean> subBeanList;                private final List<ToSubBean> subBeanList;                    private final List<String> list;                            private final List<String> list;                       private final FromSubBean subObject;                        private final ToSubBean subObject;                           // all constructor                                         // all args constructor   // getters...                                              // getters... }

and our sourceMap is:

Map<FromBean, List<String>> sourceMap = new HashMap<>();

and we want to transform it in:

Map<ToBean, List<String>> map = new HashMap<>();

we first need to define aBeanTransformer that maps the different field names:

BeanTransformer beanTransformer = new BeanUtils().getTransformer()                                                 .withFieldMapping(new FieldMapping<>("name", "differentName"));

and then pass it as argument of our Map transformation method:

Map<ToBean, List<String>> map = new MapUtils().getTransformer()                                           .transform(sourceMap, beanTransformer, ToBean.class, List.class);