How to make string comparison inclusive?

I have a TreeMap that contains words and its definition(s). I'm writing a method that will return all the word and its definitions with a range; it takes in two parameters: string begin and string end.
Here's what I have so far
I initialized a TreeMap outside of the function:

Map<String, List<String>> wordDictionary = new TreeMap<String, List<String>>();

Set<String> wordSet = wordDictionary.keySet();
    Iterator<String> iterator = wordSet.iterator();
    while (iterator.hasNext()) {
      String current = iterator.next();
      if (
        (current.compareToIgnoreCase(begin) >= 0) &&
        (current.compareToIgnoreCase(end) <= 0)
      ) {
        List<String> defList = wordDictionary.get(current);
        System.out.println(current);
        Iterator<String> itr2 = defList.iterator();
        while (itr2.hasNext()) {
          System.out.println(" " + itr2.next());
        }
      }
    }

Example use: "List a b"
The method should return all words from a to b <br>
However my method returns all words between a and b; it excludes words starting with a and b.

I tried tweaking the if case to

if (
        (current.compareToIgnoreCase(begin) > 0) &&
        (current.compareToIgnoreCase(end) < 0)
      )

but that doesn't work either. It displays words starting with begin but not end. Hope that makes sense.

If you have a TreeMap, use its subMap() method!

Map<String, List<String>> range = wordDictionary.subMap(begin, true, end, true);

And iterate over the whole map.

The 2^nd and 4^th parameters control if the range ends are inclusive or not - it seems you want inclusive both ends, but if not change the 4^th parameter to false.

——

By the way, since you are not printing the word, just the definitions, your code can be reduced to:

wordDictionary.subMap(begin, true, end, true).values().stream()
.flatMap(List::stream)
.forEach(System.out::println);

If you wanted to also print the word before indented definitions:

wordDictionary.subMap(begin, true, end, true).entrySet().stream()
.peek(e -> System.out.println(e.getKey()))
.map(Map.Entry::getValue)
.flatMap(List::stream)
.forEach(d -> System.out. println(" " + d);

You could make the subMap of TreeMap inclusive on both ends by doing something like the following:

TreeMap<String,String> map = new TreeMap<>();
         
map.put("abc","a");		
map.put("efg","a");		 
map.put("hij","v");		 
map.put("rst","o");

String start = "a";
String end = "e";

int idx = end.length() - 1;

// modify last character of end to be inclusive.
 StringBuilder sb = new StringBuilder(end);
 char c = sb.charAt(sb.length()-1);
 sb.setCharAt(sb.length()-1, (char)(c+1));
 end = sb.toString();

Map<String, String> words =
		map.subMap(start, true, end,false);

System.out.println(words);

Prints

{abc=a, efg=a}

It increments the last character of the ending string so as to include anything less than that.

To get all keys that start with e.g. 'b', use subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive):

TreeMap<String, String> wordDictionary = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
wordDictionary.put("A", "1");
wordDictionary.put("Abc", "2");
wordDictionary.put("Axe", "3");
wordDictionary.put("B", "4");
wordDictionary.put("Bee", "5");
wordDictionary.put("C", "6");
wordDictionary.put("Car", "7");

NavigableMap<String, String> bdict = wordDictionary.subMap("b", true, "c", false);
System.out.println(bdict);
System.out.println(bdict.keySet());

// Alternative
NavigableSet<String> bwords = wordDictionary.navigableKeySet().subSet("b", true, "c", false);
System.out.println(bwords);

Output

{B=4, Bee=5}
[B, Bee]
[B, Bee]