[英]Group a list of objects by an attribute
我需要使用特定 object 的属性（ Location ）对对象列表（ Student ）进行分组。 代码如下：
public class Grouping {
public static void main(String[] args) {
List<Student> studlist = new ArrayList<Student>();
studlist.add(new Student("1726", "John", "New York"));
studlist.add(new Student("4321", "Max", "California"));
studlist.add(new Student("2234", "Andrew", "Los Angeles"));
studlist.add(new Student("5223", "Michael", "New York"));
studlist.add(new Student("7765", "Sam", "California"));
studlist.add(new Student("3442", "Mark", "New York"));
}
}
class Student {
String stud_id;
String stud_name;
String stud_location;
Student(String sid, String sname, String slocation) {
this.stud_id = sid;
this.stud_name = sname;
this.stud_location = slocation;
}
}
请建议我一个干净的方法来做到这一点。
在 Java 8 中：
Map<String, List<Student>> studlistGrouped =
studlist.stream().collect(Collectors.groupingBy(w -> w.stud_location));
这会将学生对象添加到以locationID为键的HashMap 。
HashMap<Integer, List<Student>> hashMap = new HashMap<Integer, List<Student>>();
迭代此代码并将学生添加到HashMap ：
if (!hashMap.containsKey(locationId)) {
List<Student> list = new ArrayList<Student>();
list.add(student);
hashMap.put(locationId, list);
} else {
hashMap.get(locationId).add(student);
}
如果您希望所有学生都具有特定位置的详细信息，则可以使用以下命令：
hashMap.get(locationId);
这将使您获得具有相同位置 ID 的所有学生。
Map<String, List<Student>> map = new HashMap<String, List<Student>>();
for (Student student : studlist) {
String key = student.stud_location;
if(map.containsKey(key)){
List<Student> list = map.get(key);
list.add(student);
}else{
List<Student> list = new ArrayList<Student>();
list.add(student);
map.put(key, list);
}
}
使用Java 8
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
class Student {
String stud_id;
String stud_name;
String stud_location;
public String getStud_id() {
return stud_id;
}
public String getStud_name() {
return stud_name;
}
public String getStud_location() {
return stud_location;
}
Student(String sid, String sname, String slocation) {
this.stud_id = sid;
this.stud_name = sname;
this.stud_location = slocation;
}
}
class Temp
{
public static void main(String args[])
{
Stream<Student> studs =
Stream.of(new Student("1726", "John", "New York"),
new Student("4321", "Max", "California"),
new Student("2234", "Max", "Los Angeles"),
new Student("7765", "Sam", "California"));
Map<String, Map<Object, List<Student>>> map= studs.collect(Collectors.groupingBy(Student::getStud_name,Collectors.groupingBy(Student::getStud_location)));
System.out.println(map);//print by name and then location
}
}
结果将是：
{
Max={
Los Angeles=[Student@214c265e],
California=[Student@448139f0]
},
John={
New York=[Student@7cca494b]
},
Sam={
California=[Student@7ba4f24f]
}
}
可能已经晚了，但我想分享一个对这个问题的改进想法。 这与@Vitalii Fedorenko 的回答基本相同，但更容易玩。
您可以通过将分组逻辑作为函数参数传递来使用Collectors.groupingBy() ，您将获得带有关键参数映射的拆分列表。 请注意，当提供的列表为null时，使用Optional是为了避免不需要的 NPE
public static <E, K> Map<K, List<E>> groupBy(List<E> list, Function<E, K> keyFunction) {
return Optional.ofNullable(list)
.orElseGet(ArrayList::new)
.stream()
.collect(Collectors.groupingBy(keyFunction));
}
现在你可以用这个groupBy任何东西。 对于问题中的用例
Map<String, List<Student>> map = groupBy(studlist, Student::getLocation);
也许你想看看这个Java 8 groupingBy Collector 指南
您可以使用以下内容：
Map<String, List<Student>> groupedStudents = new HashMap<String, List<Student>>();
for (Student student: studlist) {
String key = student.stud_location;
if (groupedStudents.get(key) == null) {
groupedStudents.put(key, new ArrayList<Student>());
}
groupedStudents.get(key).add(student);
}
//打印
Set<String> groupedStudentsKeySet = groupedCustomer.keySet();
for (String location: groupedStudentsKeySet) {
List<Student> stdnts = groupedStudents.get(location);
for (Student student : stdnts) {
System.out.println("ID : "+student.stud_id+"\t"+"Name : "+student.stud_name+"\t"+"Location : "+student.stud_location);
}
}
使用 Comparator 在 Java 中实现 SQL GROUP BY Feature，Comparator 将比较您的列数据，并对其进行排序。 基本上，如果您保留看起来像分组数据的排序数据，例如，如果您有相同的重复列数据，那么排序机制将它们排序，在一侧保留相同的数据，然后查找其他不同数据的数据。 这间接地被视为对相同数据的分组。
public class GroupByFeatureInJava {
public static void main(String[] args) {
ProductBean p1 = new ProductBean("P1", 20, new Date());
ProductBean p2 = new ProductBean("P1", 30, new Date());
ProductBean p3 = new ProductBean("P2", 20, new Date());
ProductBean p4 = new ProductBean("P1", 20, new Date());
ProductBean p5 = new ProductBean("P3", 60, new Date());
ProductBean p6 = new ProductBean("P1", 20, new Date());
List<ProductBean> list = new ArrayList<ProductBean>();
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);
list.add(p5);
list.add(p6);
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
ProductBean bean = (ProductBean) iterator.next();
System.out.println(bean);
}
System.out.println("******** AFTER GROUP BY PRODUCT_ID ******");
Collections.sort(list, new ProductBean().new CompareByProductID());
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
ProductBean bean = (ProductBean) iterator.next();
System.out.println(bean);
}
System.out.println("******** AFTER GROUP BY PRICE ******");
Collections.sort(list, new ProductBean().new CompareByProductPrice());
for (Iterator iterator = list.iterator(); iterator.hasNext();) {
ProductBean bean = (ProductBean) iterator.next();
System.out.println(bean);
}
}
}
class ProductBean {
String productId;
int price;
Date date;
@Override
public String toString() {
return "ProductBean [" + productId + " " + price + " " + date + "]";
}
ProductBean() {
}
ProductBean(String productId, int price, Date date) {
this.productId = productId;
this.price = price;
this.date = date;
}
class CompareByProductID implements Comparator<ProductBean> {
public int compare(ProductBean p1, ProductBean p2) {
if (p1.productId.compareTo(p2.productId) > 0) {
return 1;
}
if (p1.productId.compareTo(p2.productId) < 0) {
return -1;
}
// at this point all a.b,c,d are equal... so return "equal"
return 0;
}
@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
return super.equals(obj);
}
}
class CompareByProductPrice implements Comparator<ProductBean> {
@Override
public int compare(ProductBean p1, ProductBean p2) {
// this mean the first column is tied in thee two rows
if (p1.price > p2.price) {
return 1;
}
if (p1.price < p2.price) {
return -1;
}
return 0;
}
public boolean equals(Object obj) {
// TODO Auto-generated method stub
return super.equals(obj);
}
}
class CompareByCreateDate implements Comparator<ProductBean> {
@Override
public int compare(ProductBean p1, ProductBean p2) {
if (p1.date.after(p2.date)) {
return 1;
}
if (p1.date.before(p2.date)) {
return -1;
}
return 0;
}
@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
return super.equals(obj);
}
}
}
上面的 ProductBean 列表的输出是按照 GROUP BY 条件完成的，如果您看到输入数据，该数据将 ProductBean 列表提供给 Collections.sort(list, object of Comparator for your required column) 这将根据您的比较器实现进行排序您将能够在下面的输出中看到 GROUPED 数据。 希望这可以帮助...
******** BEFORE GROUPING INPUT DATA LOOKS THIS WAY ******
ProductBean [P1 20 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P1 30 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P2 20 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P1 20 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P3 60 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P1 20 Mon Nov 17 09:31:01 IST 2014]
******** AFTER GROUP BY PRODUCT_ID ******
ProductBean [P1 20 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P1 30 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P1 20 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P1 20 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P2 20 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P3 60 Mon Nov 17 09:31:01 IST 2014]
******** AFTER GROUP BY PRICE ******
ProductBean [P1 20 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P1 20 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P2 20 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P1 20 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P1 30 Mon Nov 17 09:31:01 IST 2014]
ProductBean [P3 60 Mon Nov 17 09:31:01 IST 2014]
public class Test9 {
static class Student {
String stud_id;
String stud_name;
String stud_location;
public Student(String stud_id, String stud_name, String stud_location) {
super();
this.stud_id = stud_id;
this.stud_name = stud_name;
this.stud_location = stud_location;
}
public String getStud_id() {
return stud_id;
}
public void setStud_id(String stud_id) {
this.stud_id = stud_id;
}
public String getStud_name() {
return stud_name;
}
public void setStud_name(String stud_name) {
this.stud_name = stud_name;
}
public String getStud_location() {
return stud_location;
}
public void setStud_location(String stud_location) {
this.stud_location = stud_location;
}
@Override
public String toString() {
return " [stud_id=" + stud_id + ", stud_name=" + stud_name + "]";
}
}
public static void main(String[] args) {
List<Student> list = new ArrayList<Student>();
list.add(new Student("1726", "John Easton", "Lancaster"));
list.add(new Student("4321", "Max Carrados", "London"));
list.add(new Student("2234", "Andrew Lewis", "Lancaster"));
list.add(new Student("5223", "Michael Benson", "Leeds"));
list.add(new Student("5225", "Sanath Jayasuriya", "Leeds"));
list.add(new Student("7765", "Samuael Vatican", "California"));
list.add(new Student("3442", "Mark Farley", "Ladykirk"));
list.add(new Student("3443", "Alex Stuart", "Ladykirk"));
list.add(new Student("4321", "Michael Stuart", "California"));
Map<String, List<Student>> map1 =
list
.stream()
.sorted(Comparator.comparing(Student::getStud_id)
.thenComparing(Student::getStud_name)
.thenComparing(Student::getStud_location)
)
.collect(Collectors.groupingBy(
ch -> ch.stud_location
));
System.out.println(map1);
/*
Output :
{Ladykirk=[ [stud_id=3442, stud_name=Mark Farley],
[stud_id=3443, stud_name=Alex Stuart]],
Leeds=[ [stud_id=5223, stud_name=Michael Benson],
[stud_id=5225, stud_name=Sanath Jayasuriya]],
London=[ [stud_id=4321, stud_name=Max Carrados]],
Lancaster=[ [stud_id=1726, stud_name=John Easton],
[stud_id=2234, stud_name=Andrew Lewis]],
California=[ [stud_id=4321, stud_name=Michael Stuart],
[stud_id=7765, stud_name=Samuael Vatican]]}
*/
}// main
}
你可以这样做：
Map<String, List<Student>> map = new HashMap<String, List<Student>>();
List<Student> studlist = new ArrayList<Student>();
studlist.add(new Student("1726", "John", "New York"));
map.put("New York", studlist);
键将是位置和学生的值列表。 因此，稍后您可以通过使用以下命令来获取一组学生：
studlist = map.get("New York");
你可以使用guava的Multimaps
@Canonical
class Persion {
String name
Integer age
}
List<Persion> list = [
new Persion("qianzi", 100),
new Persion("qianzi", 99),
new Persion("zhijia", 99)
]
println Multimaps.index(list, { Persion p -> return p.name })
它打印：
[qianzi:[com.ctcf.message.Persion(qianzi, 100),com.ctcf.message.Persion(qianzi, 88)],zhijia:[com.ctcf.message.Persion(zhijia, 99)]]
Function<Student, List<Object>> compositKey = std ->
Arrays.asList(std.stud_location());
studentList.stream().collect(Collectors.groupingBy(compositKey, Collectors.toList()));
如果要为 group by 添加多个对象，只需在compositKey方法中添加对象，以逗号分隔：
Function<Student, List<Object>> compositKey = std ->
Arrays.asList(std.stud_location(),std.stud_name());
studentList.stream().collect(Collectors.groupingBy(compositKey, Collectors.toList()));
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
KeyValuePair<?, ?> that = (KeyValuePair<?, ?>) o;
return Objects.equals(key, that.key) && Objects.equals(value, that.value);
}
@Override
public int hashCode() {
return Objects.hash(key, value);
}
你可以这样排序：
Collections.sort(studlist, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getStud_location().compareTo(o2.getStud_location());
}
});
假设您在 Student 类上也有位置的吸气剂。
使用Jackson进行反序列化期间将列表属性中的对象的列表分组
[英]Group list of objects in a list attribute during deserialization using Jackson
使用Java Streams按属性将对象列表组合在一起，并将它们减少为具有另一个属性平均值的新对象列表
[英]Using Java Streams to group together a List of objects by an attribute and reduce them to a new list of object with the average of another attribute
如何按属性对对象列表进行分组，然后使用（Key，Value）对迭代结果？
[英]How to group a list of objects by an attribute and then iterate the results using (Key, Value) pair?
我可以根据属性对对象列表进行分组，并在 stream 中一次将这些新列表传递给一个方法吗？
[英]Can I group a list of objects based on an attribute, and pass these new lists into a method one at a time within a stream?
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.