how to sort map based on key length

I have this map:

Map < String, String > unsortMap = new HashMap < String, String > ();
unsortMap.put("./cq:dialog/content/items/tabs/items/tab1/items/columns/items", "40");
unsortMap.put("./cq:dialog/content", "80");
unsortMap.put("./cq:dialog", "75");
unsortMap.put("./cq:dialog/content/items/tabs/items/tab2/items/columns/items", "40");
unsortMap.put("./cq:dialog/content/sling:resourcetype", "granite/ui/components/coral/foundation/container");

I would like to sort it as based on the length of the key, for example if the key has less number of "/" then it will be the on top.

Expected output:

./cq:dialog
./cq:dialog/content/
./cq:dialog/content/sling:resourcetype
./cq:dialog/content/items/tabs/items/tab1/items/columns/items
./cq:dialog/content/items/tabs/items/tab2/items/columns/items

So for this, I write like this:

Map<String, String> sortedMap = unsortMap.entrySet().stream()
.sorted(Map.Entry.comparingByKey())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
(oldValue, newValue) -> oldValue, LinkedHashMap::new));

It does not give output as expected because it does not compare based on "/". I have tried custom comparator but could not get the expected result.

To only compare the lengths, we can use Integer.compare in a custom Comparator. ^Demo

Map<String, String> sortedMap = unsortMap.entrySet().stream()
.sorted((a, b) -> Integer.compare(a.getKey().length(), b.getKey().length()))
.collect(Collectors.toMap(Map.Entry::getKey,
Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new));

Of course, you could also create a TreeMap with this custom Comparator so that new keys will still be ordered correctly.

final NavigableMap<String, String> sortedMap = new TreeMap<>(
(a, b) -> a.length() != b.length() ? Integer.compare(a.length(), b.length()) : a.compareTo(b));
sortedMap.putAll(unsortMap);

<hr>

In order to compare the number of slashes, we can filter over the characters of both Strings.

final NavigableMap<String, String> sortedMap = new TreeMap<>((a, b) -> {
final long slashes1 = a.chars().filter(c -> c == '/').count();
final long slashes2 = b.chars().filter(c -> c == '/').count();
return slashes1 != slashes2 ? Long.compare(slashes1, slashes2) : a.compareTo(b);
});
sortedMap.putAll(unsortMap);

As Andreas suggested, the comparator can be simplified using .thenComparing:

final NavigableMap<String, String> sortedMap = new TreeMap<>(
Comparator.comparingLong((String s) -> s.chars().filter(c -> c == '/').count())
.thenComparing(Comparator.naturalOrder()));

Alternatively:

Map<String, String> sortedMap = unsortMap.entrySet().stream()
.sorted((a, b) -> Long.compare(a.getKey().chars().filter(c->c=='/').count(), b.getKey().chars().filter(c->c=='/').count()))
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue,
LinkedHashMap::new));