Convert Map to Map

Question

How can I convert Map<String,Object> to Map<String,String> ?

This does not work:

Map<String,Object> map = new HashMap<String,Object>(); //Object is containing String
Map<String,String> newMap =new HashMap<String,String>(map);

What do you expect/want to happen in this case: ` Map map = new Map() map.put("key", new Integer(42));` — Shreyos Adikari, May 29 '13 at 06:29
Iterate the map1 (map) in side the iteration cast Object to a string and create a newMap with oldString and newly casted String — Sanath, May 29 '13 at 06:30
Since not every `Object` is a `String`, you could call `toString()` on every value of the `Map`. But is this what you bean by "convert"? — , May 29 '13 at 06:43

score 74 · Answer 1 · answered Dec 28 '15 at 16:56

74

Now that we have Java 8/streams, we can add one more possible answer to the list:

Assuming that each of the values actually are String objects, the cast to String should be safe. Otherwise some other mechanism for mapping the Objects to Strings may be used.

Map<String,Object> map = new HashMap<>();
Map<String,String> newMap = map.entrySet().stream()
     .collect(Collectors.toMap(Map.Entry::getKey, e -> (String)e.getValue()));

answered Dec 28 '15 at 16:56

skeryl

5,225
4
26
28

2

With some extra care: Map newMap = map.entrySet().stream() .filter(entry -> entry.getValue() instanceof String) .collect(Collectors.toMap(Map.Entry::getKey, e -> (String)e.getValue())); – Balázs Németh Apr 20 '16 at 13:08
2

why not `e.getValue().toString()` why explicit cast? – Anton Balaniuc May 31 '18 at 10:48
1

@AntonBalaniuc we're assuming that the OP *knows* that the values are all Strings so here we're using a more strict cast instead of coercing a String value from the object. Of course, as mentioned in the answer, if there's some other mechanism more appropriate for creating a string from the value Objects, that should be used instead of a cast. – skeryl May 31 '18 at 20:58
2

@AntonBalaniuc old question, but calling `toString()` can be dangerouse... Let me explain. If for any reason the object you want to convert to String is not actually a String you are expecting generalized as an object, but something else, the `toString()` method might give you tokenized value of that object, thus introducing hard to detect bug in your code. Casting will at least throw the `RuntimeException` in such case. – Przemysław Gęsieniec Dec 15 '21 at 09:34

Shreyos Adikari · Accepted Answer · 2016-04-20T18:03:53.713

35

If your Objects are containing of Strings only, then you can do it like this:

Map<String,Object> map = new HashMap<String,Object>(); //Object is containing String
Map<String,String> newMap =new HashMap<String,String>();
for (Map.Entry<String, Object> entry : map.entrySet()) {
       if(entry.getValue() instanceof String){
            newMap.put(entry.getKey(), (String) entry.getValue());
          }
 }

If every Objects are not String then you can replace (String) entry.getValue() into entry.getValue().toString().

edited Apr 20 '16 at 18:03

answered May 29 '13 at 06:34

Shreyos Adikari

12,348
19
73
82

3

Better `String.valueOf` to prevent NullPointerException – Patrick Parker Dec 07 '16 at 09:02

Mikhail · Answer 3 · 2013-05-29T07:52:10.347

26

Generic types is a compile time abstraction. At runtime all maps will have the same type Map<Object, Object>. So if you are sure that values are strings, you can cheat on java compiler:

Map<String, Object> m1 = new HashMap<String, Object>();
Map<String, String> m2 = (Map) m1;

Copying keys and values from one collection to another is redundant. But this approach is still not good, because it violates generics type safety. May be you should reconsider your code to avoid such things.

edited May 29 '13 at 07:52

answered May 29 '13 at 07:28

Mikhail

4,175
15
31

This should be accepted answer! This is definitely the fastest option. – mrek Jun 23 '23 at 14:41

cambecc · Answer 4 · 2013-05-29T06:53:50.973

There are two ways to do this. One is very simple but unsafe:

Map<String, Object> map = new HashMap<String, Object>();
Map<String, String> newMap = new HashMap<String, String>((Map)map);  // unchecked warning

The other way has no compiler warnings and ensures type safety at runtime, which is more robust. (After all, you can't guarantee the original map contains only String values, otherwise why wouldn't it be Map<String, String> in the first place?)

Map<String, Object> map = new HashMap<String, Object>();
Map<String, String> newMap = new HashMap<String, String>();
@SuppressWarnings("unchecked") Map<String, Object> intermediate =
    (Map)Collections.checkedMap(newMap, String.class, String.class);
intermediate.putAll(map);

score 4 · Answer 5 · answered Jul 10 '19 at 18:32

Use the Java 8 way of converting a Map<String, Object> to Map<String, String>. This solution handles null values.

Map<String, String> keysValuesStrings = keysValues.entrySet().stream()
    .filter(entry -> entry.getValue() != null)
    .collect(Collectors.toMap(Entry::getKey, entry -> entry.getValue().toString()));

score 3 · Answer 6 · answered May 29 '13 at 06:37

3

Not possible.

This a little counter-intuitive.

You're encountering the "Apple is-a fruit" but "Every Fruit is not an Apple"

Go for creating a new map and checking with instance of with String

answered May 29 '13 at 06:37

Suresh Atta

120,458
37
198
307

score 3 · Answer 7 · answered May 29 '13 at 06:39

As you are casting from Object to String I recommend you catch and report (in some way, here I just print a message, which is generally bad) the exception.

    Map<String,Object> map = new HashMap<String,Object>(); //Object is containing String
    Map<String,String> newMap =new HashMap<String,String>();

    for (Map.Entry<String, Object> entry : map.entrySet()) {
        try{
            newMap.put(entry.getKey(), (String) entry.getValue());
        }
        catch(ClassCastException e){
            System.out.println("ERROR: "+entry.getKey()+" -> "+entry.getValue()+
                               " not added, as "+entry.getValue()+" is not a String");
        }
    }

score 2 · Answer 8 · answered Mar 20 '14 at 07:27

2

The following will transform your existing entries.

TransformedMap.decorateTransform(params, keyTransformer, valueTransformer)

Where as

MapUtils.transformedMap(java.util.Map map, keyTransformer, valueTransformer)

only transforms new entries into your map

answered Mar 20 '14 at 07:27

yunspace

2,532
20
20

1

TransformedMap and MapUtils in Apache Common Collections http://commons.apache.org/proper/commons-collections/ – arulraj.net Sep 02 '14 at 14:09

score 2 · Answer 9 · answered Jun 18 '15 at 15:01

2

private Map<String, String> convertAttributes(final Map<String, Object> attributes) {
    final Map<String, String> result = new HashMap<String, String>();
    for (final Map.Entry<String, Object> entry : attributes.entrySet()) {
        result.put(entry.getKey(), String.valueOf(entry.getValue()));
    }
    return result;
}

answered Jun 18 '15 at 15:01

Sky Tronics

21
1

2

While adding code sure does solve the problem, it'd be great to add some explanation to the code so future visitors and people new to the language can understand and learn from it better. and Welcome to Stack Overflow! – DeadChex Jun 18 '15 at 15:22

score 2 · Answer 10 · answered May 07 '18 at 12:44

Great solutions here, just one more option that taking into consideration handling of null values:

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

Map<String,String> stringifiedMap = map.entrySet().stream()
             .filter(m -> m.getKey() != null && m.getValue() !=null)
             .collect(Collectors.toMap(Map.Entry::getKey, e -> (String)e.getValue()));

score 2 · Answer 11 · answered Jul 23 '21 at 06:39

I find the easiest way by use guava:

    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>30.1-jre</version>
    </dependency>

then you can do this:

Map<String,Object> map = new HashMap<String,Object>(); 
Map<String,String> newMap = Maps.transformValues(map, Functions.toStringFunction());

score 1 · Answer 12 · answered May 29 '13 at 08:57

While you can do this with brute casting and suppressed warnings

Map<String,Object> map = new HashMap<String,Object>();
// Two casts in a row.  Note no "new"!
@SuppressWarnings("unchecked")
Map<String,String> newMap = (HashMap<String,String>)(Map)map;

that's really missing the whole point. :)

An attempt to convert a narrow generic type to a broader generic type means you're using the wrong type in the first place.

As an analogy: Imagine you have a program that does volumous text processing. Imagine that you do first half of the processing using Objects (!!) and then decide to do the second half with correct-typing as a String, so you narrow-cast from Object to String. Fortunately, you can do this is java (easily in this case) - but it's just masking the fact you're using weak-typing in the first half. Bad practice, no argument.

No difference here (just harder to cast). You should always use strong typing. At minimum use some base type - then generics wildcards can be used ("? extends BaseType" or "? super BaseType") to give type-compatability and automatic casting. Even better, use the correct known type. Never use Object unless you have 100% generalised code that can really be used with any type.

Hope that helps! :) :)

Note: The generic strong typing and type-casting will only exist in .java code. After compilation to .class we are left with raw types (Map and HashMap) with no generic type parameters plus automatic type casting of keys and values. But it greatly helps because the .java code itself is strongly-typed and concise.

Convert Map to Map

12 Answers12

Linked