objetos - ordenar arraylist java por atributo

Agrupe una lista de objetos por un atributo: Java

Question

Necesito agrupar una lista de objetos (Estudiante) usando un atributo (Ubicación) del objeto particular, el código es como a continuación,

public class Grouping {

    /**
     * @param args the command line arguments
     */
    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"));

        //Code to group students by location
        /*  Output should be Like below
            ID : 1726   Name : John Location : New York
            ID : 5223   Name : Michael  Location : New York
            ID : 4321   Name : Max  Location : California
            ID : 7765   Name : Sam  Location : California    

         */

        for (Student student : studlist) {
            System.out.println("ID : "+student.stud_id+"/t"+"Name : "+student.stud_name+"/t"+"Location : "+student.stud_location);
        }


    }
}

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;

    }
}

Por favor sugiérame una manera limpia de hacerlo.

Answer 1

En Java 8:

Map<String, List<Student>> studlistGrouped =
    studlist.stream().collect(Collectors.groupingBy(w -> w.stud_location));

Answer 2

Esto agregará el objeto de los estudiantes a HashMap con HashMap de locationID como clave.

HashMap<Integer, List<Location>> hashMap = new HashMap<Integer, List<Location>>();

Iteramos este código y agregamos estudiantes al HashMap :

if (!hashMap.containsKey(locationId)) {
    List<Location> list = new ArrayList<Location>();
    list.add(student);

    hashMap.put(locationId, list);
} else {
    hashMap.get(locationId).add(student);
}

Si desea que todos los estudiantes con detalles de ubicación particulares, puede utilizar esto:

hashMap.get(locationId);

que le dará a todos los estudiantes con la misma ID de ubicación.

Answer 3

Implementar SQL GROUP BY Feature en Java usando Comparator, el comparador comparará los datos de su columna y los ordenará. Básicamente, si mantiene los datos ordenados que se ven como datos agrupados, por ejemplo, si tiene los mismos datos de columna repetidos, entonces clasifique los mecanismos clasificándolos manteniendo los mismos datos por un lado y luego busque otros datos que no sean similares. Esto indirectamente visto como AGRUPACIÓN de los mismos datos.

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);
        }
    }
}

La salida está aquí para la lista de ProductBean anterior se hace criterios GROUP BY, aquí si ve los datos de entrada que se da la lista de ProductBean a Collections.sort (lista, objeto de Comparator para la columna requerida) Esto ordenará en función de la implementación de su comparador y podrá ver los datos AGRUPADOS en la salida siguiente. Espero que esto ayude...

******** 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]

Answer 4

Podrías hacer esto:

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);

las claves serán ubicaciones y la lista de valores de los estudiantes. Luego, puedes obtener un grupo de estudiantes simplemente usando:

studlist = map.get("New York");

Answer 5

Puedes ordenar de esta manera:

    Collections.sort(studlist, new Comparator<Student>() {

        @Override
        public int compare(Student o1, Student o2) {
            return o1.getStud_location().compareTo(o2.getStud_location());
        }
    });

Suponiendo que también tiene el getter para ubicación en su clase de Estudiante.

Answer 6

Puedes usar lo siguiente:

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);
}

//impresión

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);
    }
}

Answer 7

Usando 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
    }

}

El resultado será:

{
    Max={
        Los Angeles=[Student@214c265e], 
        California=[Student@448139f0]
    }, 
    John={
        New York=[Student@7cca494b]
    }, 
    Sam={
        California=[Student@7ba4f24f]
    }
}

Answer 8

puedes usar Multimaps guava

@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 })

imprime:

[qianzi: [com.ctcf.message.Persion (qianzi, 100), com.ctcf.message.Persion (qianzi, 88)], zhijia: [com.ctcf.message.Persion (zhijia, 99)]]

Answer 9

Function<Student, List<Object>> compositKey = std ->
                Arrays.asList(std.stud_location());
        studentList.stream().collect(Collectors.groupingBy(compositKey, Collectors.toList()));

Si desea agregar varios objetos para el grupo, puede simplemente agregar el objeto en el método compositKey separándolo por una coma:

Function<Student, List<Object>> compositKey = std ->
                Arrays.asList(std.stud_location(),std.stud_name());
        studentList.stream().collect(Collectors.groupingBy(compositKey, Collectors.toList()));

Answer 10

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);
    }

}