Switch HashMap to TreeMap

MartinSeeler · MartinSeeler · commit 93c1d3ad2f13 · 2014-12-15T21:53:49.000+01:00
diff --git a/core/src/main/java/fj/data/List.java b/core/src/main/java/fj/data/List.java
@@ -1238,27 +1238,57 @@ public final A mode(final Ord<A> o) {
   }
 
   /**
-   * Groups the elements of this list by a given keyFunction into a {@link HashMap}.
+   * Groups the elements of this list by a given keyFunction into a {@link TreeMap}.
+   * The ordering of the keys is determined by {@link fj.Ord#hashOrd()}.
    *
    * @param keyFunction The function to select the keys for the map.
-   * @return A HashMap containing the keys with the accumulated list of matched elements.
+   * @return A TreeMap containing the keys with the accumulated list of matched elements.
    */
-  public final <B> HashMap<B, List<A>> groupBy(final F<A, B> keyFunction) {
-    return groupBy(keyFunction, Function.identity());
+  public final <B> TreeMap<B, List<A>> groupBy(final F<A, B> keyFunction) {
+    return groupBy(keyFunction, Ord.hashOrd());
   }
 
   /**
-   * Groups the elements of this list by a given keyFunction into a {@link HashMap} and transforms
-   * the matching elements with the given valueFunction.
+   * Groups the elements of this list by a given keyFunction into a {@link TreeMap}.
+   *
+   * @param keyFunction The function to select the keys for the map.
+   * @param keyOrd An order for the keys of the tree map.
+   * @return A TreeMap containing the keys with the accumulated list of matched elements.
+   */
+  public final <B> TreeMap<B, List<A>> groupBy(final F<A, B> keyFunction, final Ord<B> keyOrd) {
+    return groupBy(keyFunction, Function.identity(), keyOrd);
+  }
+
+  /**
+   * Groups the elements of this list by a given keyFunction into a {@link TreeMap} and transforms
+   * the matching elements with the given valueFunction. The ordering of the keys is determined by
+   * {@link fj.Ord#hashOrd()}.
    *
    * @param keyFunction The function to select the keys for the map.
    * @param valueFunction The function to apply on each matching value.
-   * @return A HashMap containing the keys with the accumulated list of matched and mapped elements.
+   * @return A TreeMap containing the keys with the accumulated list of matched and mapped elements.
    */
-  public final <B, C> HashMap<B, List<C>> groupBy(
+  public final <B, C> TreeMap<B, List<C>> groupBy(
       final F<A, B> keyFunction,
       final F<A, C> valueFunction) {
-    return this.groupBy(keyFunction, valueFunction, List.<C>nil(), List::cons);
+    return this.groupBy(keyFunction, valueFunction, Ord.hashOrd());
+  }
+
+  /**
+   * Groups the elements of this list by a given keyFunction into a {@link TreeMap} and transforms
+   * the matching elements with the given valueFunction. The ordering of the keys is determined by
+   * the keyOrd parameter.
+   *
+   * @param keyFunction The function to select the keys for the map.
+   * @param valueFunction The function to apply on each matching value.
+   * @param keyOrd An order for the keys of the tree map.
+   * @return A TreeMap containing the keys with the accumulated list of matched and mapped elements.
+   */
+  public final <B, C> TreeMap<B, List<C>> groupBy(
+      final F<A, B> keyFunction,
+      final F<A, C> valueFunction,
+      final Ord<B> keyOrd) {
+    return this.groupBy(keyFunction, valueFunction, List.<C>nil(), List::cons, keyOrd);
   }
 
   /**
@@ -1270,23 +1300,29 @@ public final <B, C> HashMap<B, List<C>> groupBy(
    * @param valueFunction The function to apply on each element.
    * @param groupingIdentity The identity, or start value, for the grouping.
    * @param groupingAcc The accumulator to apply on each matching value.
-   * @return A HashMap containing the keys with the accumulated result of matched and mapped
+   * @param keyOrd An order for the keys of the tree map.
+   * @return A TreeMap containing the keys with the accumulated result of matched and mapped
    * elements.
    */
-  public final <B, C, D> HashMap<B, D> groupBy(
+  public final <B, C, D> TreeMap<B, D> groupBy(
       final F<A, B> keyFunction,
-      final F<A, C> valueFunction, final D groupingIdentity, final F2<C, D, D> groupingAcc) {
+      final F<A, C> valueFunction,
+      final D groupingIdentity,
+      final F2<C, D, D> groupingAcc,
+      final Ord<B> keyOrd) {
     return this.foldLeft(map -> element -> {
           final B key = keyFunction.f(element);
           final C value = valueFunction.f(element);
           map.set(key, map.get(key)
               .map(existing -> groupingAcc.f(value, existing))
               .orSome(groupingAcc.f(value, groupingIdentity)));
           return map;
-        }, HashMap.<B, D>hashMap()
+        }, TreeMap.<B, D>empty(keyOrd)
     );
   }
 
+
+
   /**
    * Returns whether or not all elements in the list are equal according to the given equality test.
    *
diff --git a/demo/src/main/java/fj/demo/List_groupBy.java b/demo/src/main/java/fj/demo/List_groupBy.java
@@ -1,8 +1,9 @@
 package fj.demo;
 
 import fj.Function;
-import fj.data.HashMap;
+import fj.Ord;
 import fj.data.List;
+import fj.data.TreeMap;
 
 import static fj.data.List.list;
 
@@ -17,30 +18,30 @@ public static void main(final String... args) {
   private static void keyDemo() {
     System.out.println("KeyDemo");
     final List<String> words = list("Hello", "World", "how", "are", "your", "doing");
-    final HashMap<Integer, List<String>> lengthMap = words.groupBy(String::length);
+    final TreeMap<Integer, List<String>> lengthMap = words.groupBy(String::length);
 
-    lengthMap.foreach(entry -> {
+    lengthMap.forEach(entry -> {
       System.out.println(String.format("Words with %d chars: %s", entry._1(), entry._2()));
     });
   }
 
   private static void keyValueDemo() {
     System.out.println("KeyValueDemo");
     final List<Integer> xs = list(1, 2, 3, 4, 5, 6, 7, 8, 9);
-    final HashMap<Integer, List<String>> result = xs.groupBy(x -> x % 3, Integer::toBinaryString);
+    final TreeMap<Integer, List<String>> result = xs.groupBy(x -> x % 3, Integer::toBinaryString);
 
-    result.foreach(entry -> {
+    result.forEach(entry -> {
       System.out.println(String.format("Numbers with reminder %d are %s", entry._1(), entry._2()));
     });
   }
 
   private static void keyValueAccDemo() {
     System.out.println("KeyValueAccDemo");
     final List<String> words = list("Hello", "World", "how", "are", "your", "doing");
-    final HashMap<Integer, Integer> lengthCounts =
-        words.groupBy(String::length, Function.identity(), 0, (word, sum) -> sum + 1);
+    final TreeMap<Integer, Integer> lengthCounts =
+        words.groupBy(String::length, Function.identity(), 0, (word, sum) -> sum + 1, Ord.hashOrd());
 
-    lengthCounts.foreach(entry -> {
+    lengthCounts.forEach(entry -> {
       System.out.println(String.format("Words with %d chars: %s", entry._1(), entry._2()));
     });
   }
