This is how you'd do it:

import java.util.Map;
import java.util.HashMap;
import java.util.Map.Entry;
import java.lang.reflect.Field;

public class Main {
    public int a = 3;
    public String b = "Hello";

    public static void main(String[] args) {
        Map<String, Object> map = parameters(new Main());
        for (Entry<String, Object> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }

    public static Map<String, Object> parameters(Object obj) {
        Map<String, Object> map = new HashMap<>();
        for (Field field : obj.getClass().getDeclaredFields()) {
            field.setAccessible(true);
            try { map.put(field.getName(), field.get(obj)); } catch (Exception e) { }
        }
        return map;
    }
}

Basically, you use reflection to get all of the fields in the class. Then, you access all of those fields of the object. Keep in mind that this only works for fields accessible from the method that gets the fields.

A solution with Gson:

Gson gson = new Gson();
JsonElement jsonElement = gson.toJsonTree(map);
MyPojo pojo = gson.fromJson(jsonElement, MyPojo.class);

There is no "better". There are practical differences. But first, both options use type casting, and this raises the question "how are these two considered alternatives at all?"

Casting will only work if some object passes the instanceof Map test (first option), or if o passes the instanceof String test (second option).

In other words, the answer depends on the runtime class of some object.

So either this will fail with a class cast exception:

(Map<String, Object>) o;

Or this will fail with the same exception:

(String) o 

Assuming the type checks will pass one way or the other, there are differences to be considered:

• If some object is compatible with Map<String, Object>, then casting should be preferred as it offers a performance advantage (considering objectMapper.convertValue as the alternative). In fact, readValue isn't even an option as the cast to string will fail.
• If some object is a String, then you have no choice but to call readValue, as you need to parse JSON.

As noted above, there's also objectMapper.convertValue, which in a smart way checks first instanceof before performing the conversion through JSON parsing. It's meant to convert objects from one type to another, if the two types have the same fields.