There are various ways to achieve this. Here are three.

    Map<String, String> map = new HashMap<String, String>();
    map.put("key1", "value1");
    map.put("key2", "value2");
    map.put("key3", "value3");

    System.out.println("using entrySet and toString");
    for (Entry<String, String> entry : map.entrySet()) {
        System.out.println(entry);
    }
    System.out.println();

    System.out.println("using entrySet and manual string creation");
    for (Entry<String, String> entry : map.entrySet()) {
        System.out.println(entry.getKey() + "=" + entry.getValue());
    }
    System.out.println();

    System.out.println("using keySet");
    for (String key : map.keySet()) {
        System.out.println(key + "=" + map.get(key));
    }
    System.out.println();

Output

using entrySet and toString
key1=value1
key2=value2
key3=value3

using entrySet and manual string creation
key1=value1
key2=value2
key3=value3

using keySet
key1=value1
key2=value2
key3=value3

Use Object#toString().

String string = map.toString();

That's after all also what System.out.println(object) does under the hoods. The format for maps is described in AbstractMap#toString().

Returns a string representation of this map. The string representation consists of a list of key-value mappings in the order returned by the map's entrySet view's iterator, enclosed in braces ("{}"). Adjacent mappings are separated by the characters ", " (comma and space). Each key-value mapping is rendered as the key followed by an equals sign ("=") followed by the associated value. Keys and values are converted to strings as by String.valueOf(Object).

The keyword you want is additionalProperties.

{
  "type": "object",
  "additionalProperties": {
    "type": "string"
  }
}

This keyword will validate any properties that don't appear in properties or patternProperties.

    Map<String, List<String>> myMaps = new HashMap<String, List<String>>();
    for (DataObject item : myList) {
        if (!myMaps.containsKey(item.getKey())) {
            myMaps.put(item.getKey(), new ArrayList<String>());
        }
        myMaps.get(item.getKey()).add(item.getValue());
    }

if(curr > keys.length -1) return;

// ... 

Object currVal = target.get(currKey);

Don't shorten variable names just because you can. It makes the code harder to read and harder to maintain.

if(curr > keys.length -1) return;

Ideally you're always use a "full block if" for statements, as it makes it easier to see the return condition.

if (curr > keys.length - 1) {
    return;
}

Also, your formatting seems to be off in a few cases. I'd suggest to always use an automatic formatter in your workflow so that you never need to worry about the formatting of your code ever again.

target.put(currKey, 1);

int and Integer are requiring conversion between each other, that's called "boxing" and might or might not be a problem when doing it implicit.

You ain't got any sort of error handling, if I see this right.

So, let's get to the design. If I understand your example right, what you want to do is to have a list of keys, which represent the path through the tree structure, and the last key keeps a counter how often it was added.

There are several ways to achieve that, and the question is what exactly you're trying to achieve to know which one applies.

For every further implementation, we'll assume the following interface:

public class CounterTreeMap {
    public int getValue(String... keys);
    public void putValue(String... keys);
}

You notice that we've already simplified how to use this class, the rest are implementation details. Additionally, I'll skip tests on the input parameters for brevity.

The cheap one

The cheapest solution is to "fake" depth by hashing the input array and having a single Map. However, this implementation would be able to store a value for the path "A, B" as well as for "A, B, C".

protected Map<Integer, Integer> values = new HashMap<>();

public int getValue(String... keys) {
    int keysHash = Arrays.hashCode(keys);
    // TODO We are missing logic here to handle possible hash collisions.
    Integer value = values.get(Integer.valueOf(keysHash));
    
    if (value != null) {
        return value.intValue();
    } else {
        return -1; // Or throw exception here.
    }
}

The nearly as cheap one

Given the problems from the previous implementation, we can fix at least the possible has collisions by using the full path as key instead.

protected Map<String, Integer> values = new HashMap<>();

public int getValue(String... keys) {
    String key = String.join("/", keys);
    Integer value = values.get(Integer.valueOf(key));
    
    if (value != null) {
        return value.intValue();
    } else {
        return -1; // Or throw exception here.
    }
}

Now that solves the possible hash collisions, but still allows us to store values at each node, basically. That might even be wanted, I don't know, you never specified.

The one with the many maps

As you've done, we can build a hierarchy of Maps, however, I'd base decisions on the type of the encountered leaf.

Recursive implementation:

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

public int getValue(String... keys) {
    return getValue(tree, keys, 0);
}

protected int getValue(Map<String, Object> branch, String[] keys, int currentKeyIndex) {
    String key = keys[currentKeyIndex];
    Object value = branch.get(key);
    
    if (value == null) {
        return -1; // Or throw an exception here.
    } else if (value instanceof Integer) {
        return ((Integer)value).intValue();
    } else if (value instanceof Map<?, ?>) {
        return getValue((Map<String, Object)value, keys, currentKeyIndex + 1)
    }
}

Implementation using a loop instead:

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

public int getValue(String... keys) {
    Map<String, Object> branch = tree;
    int currentKeyIndex = 0;
    
    while (branch != null) {
        String key = keys[currentKeyIndex];
        Object value = branch.get(key);
        
        if (value == null) {
            return -1; // Or throw an exception here.
        } else if (value instanceof Integer) {
            return ((Integer)value).intValue();
        } else if (value instanceof Map<?, ?>) {
            branch = (Map<String, Object)value;
            currentKeyIndex++;
        }
    }
}

Both implementations lack proper checks, though, but you should get the idea.

Given the use case as example, I'd go with flattening/joining the path into a single string (using "/" as separator) and, when adding a new path, increasing the existing value or setting a new one if it does not exist.

Map<String, Object> map = new HashMap<String, Object>();
...
for (Map.Entry<String, Object> entry : map.entrySet()) {
    if (entry.getValue() instanceof String) {
        // Do something with entry.getKey() and entry.getValue()
    } else if (entry.getValue() instanceof Class) {
        // Do something else with entry.getKey() and entry.getValue()
    } else {
        throw new IllegalStateException("Expecting either String or Class as entry value");
    }
}