List对象分组排序算法

场景:

  List里面的对象是订单的节点,比如我们快递的物流状态,这个是需要有序的,所以需要根据订单号进行分组排序。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class GroupSortTest {
    public static void main(String[] args) {

        List<Order> list = new ArrayList<Order>();
        Order o1 = new Order("10086","3",(long) 1008603);
        Order o2 = new Order("10086","2",(long) 1008602);
        Order o3 = new Order("10086","1",(long) 1008601);
        Order o4 = new Order("10010","1",(long) 1001001);
        Order o5 = new Order("10000","3",(long) 1000003);
        Order o6 = new Order("10010","3",(long) 1001003);
        Order o7 = new Order("10000","1",(long) 1000001);
        Order o8 = new Order("10000","2",(long) 1000002);
        Order o9 = new Order("10010","2",(long) 1001002);

        list.add(o1);
        list.add(o2);
        list.add(o3);
        list.add(o4);
        list.add(o5);
        list.add(o6);
        list.add(o7);
        list.add(o8);
        list.add(o9);

        Map<String, List<Order>> map = OrderSortByGroup(list);

        for(Map.Entry<String, List<Order>> entry : map.entrySet()){
            for(Order o : entry.getValue() ){
                System.out.println(entry.getKey() +"--"+o.getSeq()+"--"+o.getStatusId());
            }
        }

    }

    public static Map<String, List<Order>> OrderSortByGroup(List<Order> list){
        Map<String, List<Order>> map = new HashMap<String, List<Order>>();
        for(Order order : list) {
            List<Order> staList = map.get(order.orderNo);
            if(staList==null){
                staList = new ArrayList<Order>();
            }
            Order od = new Order();
            od.setSeq(order.seq);od.setStatusId(order.statusId);
            staList.add(od);

            Collections.sort(staList, new Comparator<Order>() {
                @Override
                public int compare(Order o1, Order o2) {
                    return o1.getSeq().compareTo(o2.getSeq());
                }
            });

            map.put(order.orderNo, staList);
        }
        return map;
    }

}

class Order {
    String orderNo;    //订单号
    String seq;        //订单节点序号
    Long statusId;    //订单节点主键

    public Order() {}

    public Order(String orderNo, String seq, Long statusId) {
        super();
        this.orderNo = orderNo;
        this.seq = seq;
        this.statusId = statusId;
    }

    public String getOrderNo() {
        return orderNo;
    }
    public void setOrderNo(String orderNo) {
        this.orderNo = orderNo;
    }
    public String getSeq() {
        return seq;
    }
    public void setSeq(String seq) {
        this.seq = seq;
    }
    public Long getStatusId() {
        return statusId;
    }
    public void setStatusId(Long statusId) {
        this.statusId = statusId;
    }
}
时间: 2024-08-27 23:41:01

List对象分组排序算法的相关文章

js分组排序算法, OrderBy

由于项目中需要对数据进行分组排序,类似于sql中 order by column1,column2....  实现的关键是 分组排序,第一个column1,排序完成之后,对其分组,然后按照column2 排序, 在分组. 以此类推. 下面给出实现: /** * [orderBy description] * @param {[type]} source [description] * @param {[type]} orders [description] * @param {[type]} t

常见排序算法导读(3)[简单选择排序]

这一节将介绍简单选择排序(Simple Selection Sort). 在介绍简单排序算法之前,先给出排序的确切定义,并简单介绍一下排序算法的稳定性. 排序的确切定义 假设含有n个对象的序列为{R[0], R[1], ..., R[n-1]}, 其对应的关键字(key)序列为{K[0], K[1], ..., K[n-1]}. 所谓排序, 就是确定0, 1, ..., n-1的一种排列p[0], p[1], ..., p[n-1], 使各个关键字满足如下的非递减(升序)或非递增(降序)关系:

Java笔记(07):常见对象--StringBuffer、二分查找及排序算法

1.StringBuffer类的构造方法 1 package cn.itcast_01; 2 3 /* 4 * 线程安全(多线程讲解) 5 * 安全 -- 同步 -- 数据是安全的 6 * 不安全 -- 不同步 -- 效率高一些 7 * 安全和效率问题是永远困扰我们的问题. 8 * 安全:医院的网站,银行网站 9 * 效率:新闻网站,论坛之类的 10 * 11 * StringBuffer: 12 * 线程安全的可变字符串. 13 * 14 * StringBuffer和String的区别? 1

对大对象进行排序的算法

快速排序就是快速排序,谢尔排序就是谢尔排序.然而,直接应用基于这些算法的函数模板时,如果要排序的Comparable对象很大的话,有时效率会很低.问题就在于.问题就在于重新排列Comparable对象时,进行太多复制Comparable对象的工作.如果Comparable对象很大而且难于复制的话,其代价也会很高. 一般来说,这个问题的解决方案很简单:生成一个指向Comparable的指针数组,然后重新排列这些指针.一旦确定了元素应该在的位置,就可以直接将该元素放在相应的位置上,而不必进行过多的中

DotNet常用排序算法总结

数据结构和算法对一个程序来说是至关重要的,现在介绍一下几种算法,在项目中较为常用的算法有:冒泡排序,简单选择排序,直接插入排序,希尔排序,堆排序,归并排序,快速排序等7中算法. 现在介绍选择排序算法,希尔排序算法,快速排序算法. (1).选择排序算法:通过n-i次关键字间的比较,从n-i+1个记录中选择出关键字最小的记录,并和第i(1大于等于i小于等于n)个记录交换. (2).希尔排序:先取一个小于n的整数d1作为第一个增量,把文件的全部记录分组.所有距离为d1的倍数的记录放在同一个组中.先在各

浅析常用的排序算法

排序分内排序和外排序.内排序:指在排序期间数据对象全部存放在内存的排序.外排序:指在排序期间全部对象个数太多,不能同时存放在内存,必须根据排序过程的要求,不断在内.外存之间移动的排序.内排序的方法有许多种,按所用策略不同,可归纳为五类:插入排序.选择排序.交换排序.归并排序.分配排序和计数排序.插入排序主要包括直接插入排序,折半插入排序和希尔排序两种;选择排序主要包括直接选择排序和堆排序;交换排序主要包括冒泡排序和快速排序;归并排序主要包括二路归并(常用的归并排序)和自然归并.分配排序主要包括箱

常用排序算法小结

1 #include <stdio.h> 2 #include <stdlib.h> 3 4 5 //the basic bubble sort 6 void maopao1(int *num,int len) 7 { 8 int i,j; 9 int temp; 10 for (i = 0; i < len-1; ++i) 11 { 12 for (j = i+1; j<len; ++j) 13 { 14 if (num[i]>num[j]) 15 { 16 t

[转]各种排序算法及其java程序实现

原文:http://blog.csdn.net/t12x3456/article/details/7430700 各种排序算法:冒择路(入)兮(稀)快归堆,桶式排序,基数排序 冒泡排序,选择排序,插入排序,稀尔排序,快速排序,归并排序,堆排序,桶式排序,基数排序 一.冒泡排序(BubbleSort)1. 基本思想: 两两比较待排序数据元素的大小,发现两个数据元素的次序相反时即进行交换,直到没有反序的数据元素为止.2. 排序过程: 设想被排序的数组R[1..N]垂直竖立,将每个数据元素看作有重量的

[Data Structure] 八大排序算法

排序有内部排序和外部排序之分,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存.我们这里说的八大排序算法均为内部排序. 下图为排序算法体系结构图: 1. 直接插入排序(Straight Insertion Sort ) 基本思想:将待排序的无序数列看成是一个仅含有一个元素的有序数列和一个无序数列,将无序数列中的元素逐次插入到有序数列中,从而获得最终的有序数列. 算法流程: 1)初始时, a[0]自成一个有序区, 无序区为a[1