如果 Java 8 是一个选择,那么你可以实现你想要的流.收集 http://download.java.net/jdk8/docs/api/java/util/stream/Stream.html#collect-java.util.stream.Collector-.
例如:
import static java.util.stream.Collectors.*;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
public class Example
{
public static void main(String[] args)
{
List<List<Object>> list = Arrays.asList(
Arrays.<Object>asList("A", "X", 1),
Arrays.<Object>asList("A", "Y", 5),
Arrays.<Object>asList("B", "X", 1),
Arrays.<Object>asList("B", "X", 2)
);
Map<Set<Object>, List<List<Object>>> groups = list.stream()
.collect(groupingBy(Example::newGroup));
System.out.println(groups);
Map<Set<Object>, Integer> sums = list.stream()
.collect(groupingBy(Example::newGroup, summingInt(Example::getInt)));
System.out.println(sums);
Map<Set<Object>, Optional<List<Object>>> max = list.stream()
.collect(groupingBy(Example::newGroup, maxBy(Example::compare)));
System.out.println(max);
}
private static Set<Object> newGroup(List<Object> item)
{
return new HashSet<>(Arrays.asList(item.get(0), item.get(1)));
}
private static Integer getInt(List<Object> items)
{
return (Integer)items.get(2);
}
private static int compare(List<Object> items1, List<Object> items2)
{
return (((Integer)items1.get(2)) - ((Integer)items2.get(2)));
}
}
给出以下输出:
{[A, X]=[[A, X, 1]], [B, X]=[[B, X, 1], [B, X, 2]], [A, Y]=[[A, Y, 5]]}
{[A, X]=1, [B, X]=3, [A, Y]=5}
{[A, X]=Optional[[A, X, 1]], [B, X]=Optional[[B, X, 2]], [A, Y]=Optional[[A, Y, 5]]}
或者,使用 Java 8 示例作为灵感,虽然有点冗长,但您可以在旧版本的 Java 中实现相同的功能,如下所示:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Example
{
public static void main(String[] args)
{
List<List<Object>> list = Arrays.asList(
Arrays.<Object>asList("A", "X", 1),
Arrays.<Object>asList("A", "Y", 5),
Arrays.<Object>asList("B", "X", 1),
Arrays.<Object>asList("B", "X", 2)
);
Function<List<Object>, Set<Object>> groupBy = new Function<List<Object>, Set<Object>>()
{
@Override
public Set<Object> apply(List<Object> item)
{
return new HashSet<>(Arrays.asList(item.get(0), item.get(1)));
}
};
Map<Set<Object>, List<List<Object>>> groups = group(
list,
groupBy
);
System.out.println(groups);
Map<Set<Object>, Integer> sums = sum(
list,
groupBy,
new Function<List<Object>, Integer>()
{
@Override
public Integer apply(List<Object> item)
{
return (Integer)item.get(2);
}
}
);
System.out.println(sums);
Map<Set<Object>, List<Object>> max = max(
list,
groupBy,
new Comparator<List<Object>>()
{
@Override
public int compare(List<Object> items1, List<Object> items2)
{
return (((Integer)items1.get(2)) - ((Integer)items2.get(2)));
}
}
);
System.out.println(max);
}
public static <K, V> Map<K, List<V>> group(Collection<V> items, Function<V, K> groupFunction)
{
Map<K, List<V>> groupedItems = new HashMap<>();
for (V item : items)
{
K key = groupFunction.apply(item);
List<V> itemGroup = groupedItems.get(key);
if (itemGroup == null)
{
itemGroup = new ArrayList<>();
groupedItems.put(key, itemGroup);
}
itemGroup.add(item);
}
return groupedItems;
}
public static <K, V> Map<K, Integer> sum(Collection<V> items, Function<V, K> groupFunction, Function<V, Integer> intGetter)
{
Map<K, Integer> sums = new HashMap<>();
for (V item : items)
{
K key = groupFunction.apply(item);
Integer sum = sums.get(key);
sums.put(key, sum != null ? sum + intGetter.apply(item) : intGetter.apply(item));
}
return sums;
}
public static <K, V> Map<K, V> max(Collection<V> items, Function<V, K> groupFunction, Comparator<V> comparator)
{
Map<K, V> maximums = new HashMap<>();
for (V item : items)
{
K key = groupFunction.apply(item);
V maximum = maximums.get(key);
if (maximum == null || comparator.compare(maximum, item) < 0)
{
maximums.put(key, item);
}
}
return maximums;
}
private static interface Function<T, R>
{
public R apply(T value);
}
}
给出以下输出:
{[A, X]=[[A, X, 1]], [A, Y]=[[A, Y, 5]], [B, X]=[[B, X, 1], [B, X, 2]]}
{[A, X]=1, [A, Y]=5, [B, X]=3}
{[A, X]=[A, X, 1], [A, Y]=[A, Y, 5], [B, X]=[B, X, 2]}