Object's in memory Field and value traversal in Java

I have a scenario where I need to traverse a complex object in memory.I need to traverse the entire tree's key and value and to the desired stuff. Is there any way to do it ? It cant be serialized to JSON ,which is the big issue. So only way is to traverse the object when its loaded into the memory.

Object actually looks like this.It has may deep nesting and GSON or any other library cant serialize it to JSON.

Very, very complicated.

Given any object, get all its fields:

Class<?> c = obj.getClass();
var fields = new ArrayList<Field>();
while (c != null) {
   for (Field f : c.getDeclaredFields()) {
       if (Modifier.isStatic(f.getModifiers())) continue;
       f.setAccessible(true);
       fields.add(f);
    }
    c = c.getSuperclass();
}

Seems like a lot of work, but you have to use the declaredFields variant to get at private fields as well, and it does not automatically walk the supertype hierarchy for you. Once you have that list, you can just get the object set for that field using the usual field.get(obj). Then.. apply the same algorithm recursively to THOSE objects to build such a hierarchy.

Problem: Arrays

arrays require special care. You can't just ask it for its fields; it will have none. Therefore, you need this, after using field.get(obj):

if (a.getClass().isArray()) {
    int len = Array.getLength(a);
    for (int i = 0; i < len; i++) {
        Object actualContent = Array.get(a, i);
    }
}

and then treat each value of 'actualContent' as normal (i.e. recursively run this algorithm on it).

Problem: That's a ton of stuff to print!

Yes, it is – a string alone has a char[] inside. You may want to do some instanceof checks and 'hardcode' custom printers for known types, such as String.

Problem: JDK11+ warns about something.

Yes, eventually this is no longer allowed and there will be no way to do this without involving hooking up debugger agents, which is a much more complicated can of worms. As of JDK14 this still works though, even if it prints a warning.

Problem: Loops/self-referencing

It is possible for objects to refer to themselves in a loop. For example:

List<Object> list = new ArrayList<Object>();
list.add(list);

// or a cycle:

List<Object> list1 = new ArrayList<Object>();
List<Object> list2 = new ArrayList<Object>();
list1.add(list2);
list2.add(list1);

which would cause your print code to loop forever. The solution to this is to track object identity, and if you find an object you've already 'seen', don't print it at all, just print some reference. This then also requires that you print the reference of each object. To get a number that identifies an object, use System.identityHashCode, which is guaranteed to do a really good attempt at giving you a unique id (but it is not 100% guaranteed that each object will necessarily get a unique ID). To check if you already saw an object, use an IdentityHashMap, where the map's value part doesn't matter (if there was an IdentityHashSet I'd have told you to use that, but there isn't. just map to "" and check for the existence of the key, instead).

Consider all these things and you too can write a deep-diving object printer.

Or just rely on your IDE to do this, there probably are way better solutions to whatever problem made you go: I know! I'll print the entire raw content of this object, recursively! – but your question doesn't include why you'd want this.