Ytdyklly

I have a function that looks up in a list the elements which share same values in order to group them.

As a fast summary, this should be the input/output:

[A, A', B, C, B', A''] --> [[A, A', A''], [B, B'], [C]]

I do not care about order. It could also produce:

[A, A', B, C, B', A''] --> [[B, B'], [A, A', A''], [C]]

This is my Test Code to see the output samples:

class A {

  private Long id;

  private String name;

  private Object param;



  A(Long id, String name, Object param) {

    this.id = id;

    this.name = name;

    this.param = param;

  }



  @Override

  public String toString() {

    return "{tid:" + id + ",tname:" + name + ",tparam:" + param + "}";

  }

}



public class ListsTest {



  private final A a1 = new A(1L, "A", 100);

  private final A a2 = new A(2L, "B", 200);

  private final A a3 = new A(1L, "A", 300);

  private final A a4 = new A(1L, "B", 400);



  @Test

  public void groupByIdAndName() throws IllegalAccessException, NoSuchFieldException {

    List<A> aList = List.of(a1, a2, a3, a4);

    System.out.println("groupByIdAndName");

    System.out.println("Input: ---> " + aList);

    List<List<A>> aGroupedBy = Lists.groupByFields(aList, "id", "name");

    System.out.println("Output: --> " + aGroupedBy);

    System.out.println("------------------------------------------------------------------------");

    assertThat(aGroupedBy, is(List.of(List.of(a1, a3), List.of(a2), List.of(a4)))); 

  }



  @Test

  public void groupById() throws IllegalAccessException, NoSuchFieldException {

    List<A> aList = List.of(a1, a2, a3, a4);

    System.out.println("groupById");

    System.out.println("Input: ---> " + aList);

    List<List<A>> aGroupedBy = Lists.groupByFields(aList, "id");

    System.out.println("Output: --> " + aGroupedBy);

    System.out.println("------------------------------------------------------------------------");

    assertThat(aGroupedBy, is(List.of(List.of(a1, a3, a4), List.of(a2))));

  }



  @Test

  public void groupByName() throws IllegalAccessException, NoSuchFieldException {

    List<A> aList = List.of(a1, a2, a3, a4);

    System.out.println("groupByName");

    System.out.println("Input: ---> " + aList);

    List<List<A>> aGroupedBy = Lists.groupByFields(aList, "name");

    System.out.println("Output: --> " + aGroupedBy);

    System.out.println("------------------------------------------------------------------------");

    assertThat(aGroupedBy, is(List.of(List.of(a1, a3), List.of(a2, a4))));

  }

}

Which outputs:

groupById

Input: ---> [{ id:1, name:A, param:100}, { id:2, name:B, param:200}, { id:1, name:A, param:300}, { id:1, name:B, param:400}]
Output: --> [[{ id:1, name:A, param:100}, { id:1, name:A, param:300}], [{ id:2, name:B, param:200}], [{ id:1, name:B, param:400}]]

Output: --> [[{ id:1, name:A, param:100}, { id:1, name:A, param:300}, { id:1, name:B, param:400}], [{ id:2, name:B, param:200}]]

---

groupByIdAndName

Input: ---> [{ id:1, name:A, param:100}, { id:2, name:B, param:200}, { id:1, name:A, param:300}, { id:1, name:B, param:400}]

Output: --> [[{ id:1, name:A, param:100}, { id:1, name:A, param:300}], [{ id:2, name:B, param:200}], [{ id:1, name:B, param:400}]]

---

groupByName

Input: ---> [{ id:1, name:A, param:100}, { id:2, name:B, param:200}, { id:1, name:A, param:300}, { id:1, name:B, param:400}]

Output: --> [[{ id:1, name:A, param:100}, { id:1, name:A, param:300}], [{ id:2, name:B, param:200}, { id:1, name:B, param:400}]]

---

The code I developed for it is the following:

public class Lists {



  private static <T> Object getObjectFieldsHash(T obj, String... fields) throws NoSuchFieldException, IllegalAccessException {

    List<Object> vals = new ArrayList<>();

    for (String field: fields) {

      Field f = obj.getClass().getDeclaredField(field);

      f.setAccessible(true);

      vals.add(f.get(obj));

    }

    return Objects.hash(vals);

}



  public static <T> List<List<T>> groupByFields(List<T> objects, String... fields ) throws NoSuchFieldException, IllegalAccessException {

    List<List<T>> result = new ArrayList<>(); // Is it possible to create same type of original List instead of always ArrayList?

    Map<Object, Integer> indexes = new HashMap<>();

    for (T obj: objects) {

      Object hash = getObjectFieldsHash(obj, fields);

      indexes.computeIfAbsent(hash, (_unused) -> indexes.size()); // How can I remove _unused variable?

      Integer nextIndex = indexes.get(hash);

      if (nextIndex >= result.size()) { // Maybe I could use ==. Does it improve anything? 

        result.add(new ArrayList<T>()); // Is it possible to create same type of original List instead of always ArrayList?

      }

      result.get(nextIndex).add(obj);

    }

    return result;

  }

}

Is there any way to improve this?

I'm thinking of:

1. I can pass as argument any subtype of List, but I'm always returning ArrayLists


2. I was forced to declare the _unused variable in my lambda function, or won't compile, producing error: "Cannot infer functional interface type"


3. Does using == instead of >= to check if I already created a sublist provide me any kind of improvement?


4. I named this method groupByFields, but I feel like is the opposite of "flatMap" kind functions. Is there any concept which gives me a more standarized method name?