Location>code7788 >text

【Setting Grouping Tool】Java general collection grouping scheme

Popularity：317 ℃/2025-03-28 09:45:17

Detailed explanation of Java general collection grouping implementation solution: From basic to advanced practice

In Java development, grouping elements in a collection by specific attributes is a common and important operation. This article will comprehensively introduce the various solutions to implement collection grouping in Java, from basic implementation to advanced usage, and demonstrate the actual effects of each solution through rich examples.

1. Basic grouping implementation

1.1 Single attribute grouping

The most basic way to group collections is to group according to a single attribute of the object:

// General single attribute grouping method
 public static <T, K> Map<K, List<T>> groupBySingleProperty(
         Collection<T> collection,
         Function<T, K> classifier) ​​{
     Return ()
             .collect((classifier));
 }

 // Example of usage: Group by name
 Map<String, List<Person>> byName = groupBySingleProperty(people, Person::getName);

 // Results output
 ("Group results by name:");
 ((name, list) ->
     (" " + name + ": " + list));

Execution results：

Group results by name:
   Bob: [Bob(30, Chicago), Bob(25, New York)]
   Alice: [Alice(25,New York), Alice(25,Chicago), Alice(30,New York)]

1.2 Multi-attribute grouping (using List as key)

When it is necessary to combine multiple attributes as grouping basis:

// General multi-attribute grouping method
 public static <T, K> Map<List<K>, List<T>> groupByMultipleProperties(
         Collection<T> collection,
         Function<T, K>... classes) {
    
     Return ()
             .collect((
                 item -> (classifiers)
                         .map(fn -> (item))
                         .collect(())
             ));
 }

 // Example of usage: Grouped by name and age
 Map<List<Object>, List<Person>> byNameAndAge =
     groupByMultipleProperties(people, Person::getName, Person::getAge);

 // Results output
 ("\nGroup results by name and age:");
 ((key, list) ->
     (" " + key + ": " + list));

Execution results：

Group results by name and age:
   [Alice, 25]: [Alice(25,New York), Alice(25,Chicago)]
   [Bob, 30]: [Bob(30, Chicago)]
   [Alice, 30]: [Alice(30,New York)]
   [Bob, 25]: [Bob(25,New York)]

2. Enhanced grouping implementation

2.1 Grouping using GroupKey

To avoid the possible problems caused by using List as Map key, we can introduce a special GroupKey class:

// GroupKey definition
 public static class GroupKey {
     private final Object[] keys;
    
     public GroupKey(Object... keys) {
          = keys;
     }

     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (!(o instanceof GroupKey)) return false;
         GroupKey groupKey = (GroupKey) o;
         return (keys, );
     }

     @Override
     public int hashCode() {
         return (keys);
     }

     @Override
     public String toString() {
         return (keys);
     }
 }

 // GroupKey's grouping method
 public static <T> Map<GroupKey, List<T>> groupByWithGroupKey(
         Collection<T> collection,
         Function<T, ?>... classes) {
    
     Return ()
             .collect((
                 item -> new GroupKey(
                     (classifiers)
                           .map(fn -> (item))
                           .toArray()
                 )
             ));
 }

 // Example of usage: Grouped by age and city
 Map<GroupKey, List<Person>> byAgeAndCity =
     groupByWithGroupKey(people, Person::getAge, Person::getCity);

 // Results output
 ("\nGroup results by age and city using GroupKey:");
 ((key, list) ->
     (" " + key + ": " + list));

Execution results：

Group results by age and city using GroupKey:
   [25, New York]: [Alice(25, New York), Bob(25, New York)]
   [30, Chicago]: [Bob(30, Chicago)]
   [25, Chicago]: [Alice(25, Chicago)]
   [30, New York]: [Alice(30, New York)]

3. Advanced grouping scheme based on enumeration

3.1 Enumerate grouping infrastructure

// Group field enumeration interface
 public interface GroupFieldEnum<T> {
     Function<T, Object> getExtractor();
     String getFieldName();
 }

 // Person class grouping field enumeration
 public enum PersonGroupField implements GroupFieldEnum<Person> {
     NAME("Name", Person::getName),
     AGE("Age", Person::getAge),
     CITY("City", Person::getCity);
    
     private final String fieldName;
     private final Function<Person, Object> extractor;
    
     PersonGroupField(String fieldName, Function<Person, Object> extractor) {
          = fieldName;
          = extractor;
     }
    
     @Override
     public Function<Person, Object> getExtractor() {
         return extractor;
     }
    
     @Override
     public String getFieldName() {
         return fieldName;
     }
 }

 // Enumeration grouping tool class
 public class EnumGroupingUtils {
     public static <T, E extends Enum<E> & GroupFieldEnum<T>>
             Map<GroupKey, List<T>> groupByEnumFields(
             Collection<T> collection,
             E... groupFields) {
        
         Return ()
                 .collect((
                     item -> new GroupKey(
                         (groupFields)
                               .map(field -> ().apply(item))
                               .toArray()
                     )
                 ));
     }
 }

3.2 Example of enumeration grouping

// Example of grouping by enumeration field
 ("\nEnum grouping scheme demonstration:");

 // Group by name
 Map<GroupKey, List<Person>> byNameEnum =
     (people, );
 ("1. Group results by name:");
 ((key, list) ->
     (" " + key + ": " + list));

 // Group by name and age
 Map<GroupKey, List<Person>> byNameAndAgeEnum =
     (people,
         , );
 ("\n2. Group results by name and age:");
 ((key, list) ->
     (" " + key + ": " + list));

 // Group by all fields
 Map<GroupKey, List<Person>> byAllFieldsEnum =
     (people,
         ());
 ("\n3. Group results by all fields:");
 ((key, list) ->
     (" " + key + ": " + list));

 // Dynamically select grouping fields
 List<PersonGroupField> dynamicFields = new ArrayList<>();
 ();
 ();
 Map<GroupKey, List<Person>> dynamicResult =
     (people,
         (new PersonGroupField[0]));
 ("\n4. Dynamic selection field (city + age) grouping results:");
 ((key, list) ->
     (" " + key + ": " + list));

Execution results：

Enumeration grouping scheme demonstration:
 1. Group results by name:
   [Alice]: [Alice(25,New York), Alice(25,Chicago), Alice(30,New York)]
   [Bob]: [Bob(30, Chicago), Bob(25, New York)]

 2. Group results by name and age:
   [Alice, 25]: [Alice(25,New York), Alice(25,Chicago)]
   [Bob, 30]: [Bob(30, Chicago)]
   [Alice, 30]: [Alice(30,New York)]
   [Bob, 25]: [Bob(25,New York)]

 3. Group results by all fields:
   [Alice, 25, New York]: [Alice(25, New York)]
   [Bob, 30, Chicago]: [Bob(30, Chicago)]
   [Alice, 25, Chicago]: [Alice(25, Chicago)]
   [Alice, 30, New York]: [Alice(30, New York)]
   [Bob, 25, New York]: [Bob(25, New York)]

 4. Dynamic selection field (city + age) grouping results:
   [New York, 25]: [Alice(25,New York), Bob(25,New York)]
   [Chicago, 30]: [Bob(30, Chicago)]
   [Chicago, 25]: [Alice(25, Chicago)]
   [New York, 30]: [Alice(30,New York)]

4. In-depth technical analysis

4.1 toArray(new PersonGroupField[0])principle

This writing method used in dynamic field grouping is the idiomatic pattern of Java collection to array:

(new PersonGroupField[0])
  • effect:Let ListConvert to PersonGroupField[] array
  • principle：
    1. Pass in an empty array as type template
    2. JVM creates a new array of correct type and size based on runtime type information
    3. More concise and efficient than directly specifying the size (no need to call size() first)
  • Java 11+ optimization: AvailabletoArray(PersonGroupField[]::new)Alternative

4.2 Advantages of enumeration grouping

  1. Type safety: The compiler checks the validity of the enum value
  2. Maintainability: All grouped fields are managed centrally, making it easy to modify
  3. Self-descriptive: Enumeration can contain field description information
  4. IDE support: Automatic code completion and prompts are more complete
  5. Scalability: Add a new grouping field just add an enumeration item

5. Plan comparison and selection suggestions

plan Applicable scenarios advantage shortcoming
Single attribute grouping Simple grouping requirements Simple implementation Limited functions
Multi-attribute List grouping Temporary multi-field grouping No extra classes required List as a key is not intuitive enough
GroupKey Grouping Grouping that requires clear key definition Clear key expression GroupKey class needs to be maintained
Enumeration grouping Enterprise-level application, complex grouping requirements Type-safe, maintainable Need pre-design

Selection suggestions：

  1. Simple tool class: Use basic grouping schemes
  2. Medium-sized project: Recommended GroupKey solution
  3. Large complex system: adopts enumeration grouping architecture
  4. Requires maximum flexibility: combined with dynamic field selection

6. Performance optimization suggestions

  1. Big data set processing：

    // Use parallel streams to increase processing speed
 Map<GroupKey, List<Person>> result = ()
         .collect((...));

  2. Memory optimization：

    • For immutable datasets, consider using Guava's ImmutableListMultimap
    • If the grouping result does not need to be modified, return an immutable set.

  3. Cache Optimization：

    • Caches can be considered for frequent grouping results
    • For multiple operations with the same grouping conditions, the grouping results can be multiplexed

7. Summary

This article introduces in detail four main solutions for implementing collection grouping in Java, from the basic()Use advanced enumeration-based grouping architecture. Each solution comes with a complete code example and actual execution results display to help developers understand its implementation principles and application scenarios in depth.

For most projects, it is recommended to start with the GroupKey scheme, which strikes a good balance between complexity and functionality. As the project scales, it can smoothly transition to enumeration grouping schemes for better type safety and maintainability.

No matter which solution you choose, understanding the principles behind grouping operations and the advantages and disadvantages of each solution can help developers write more efficient and easier to maintain collection processing code.

<Previous Next>