Java的分组和排序

一、排序

数组排序：
 Array.sort(int[] a)：直接对数组a进行升序排序 

 Array.sort(int[] a , int fromIndex, int toIndex)：直接对数组a中第fromIndex到toIndex-1个（自然语言描述）元素进行排序。
集合排序：
    Collections.sort指定一个Comparator接口
    List对象的sort方法指定一个Comparator接口

二、分组计算

(1)先准备组，再准备数据
    每次检查元素所对应组是否有数据
    若无，则新建分组将元素放入处理；
    否则将元素放入对应分组放入处理。
(2)先准备数据，再分组
    将数据按照分组条件进行排序，再进行处理。
    若是第一行，则新起一个分组存放该组数据；
    若当前行与上一行分组条件一致，则将元素追加到当前分组处理；
    若当前行与上一行分组条件不一致，则当前分组将不会再有数据，同时新组数据开始
    若是最后一行，则为当前分组最后一行数据。

例子：

实体类

package ch03;

public class EmployeeScore {
	private String employeeScoreId;
	private String courseName;
	private int grade;

	public String getEmployeeScoreId() {
		return employeeScoreId;
	}

	public void setEmployeeScoreId(String employeeScoreId) {
		this.employeeScoreId = employeeScoreId;
	}

	public String getCourseName() {
		return courseName;
	}

	public void setCourseName(String courseName) {
		this.courseName = courseName;
	}

	public int getGrade() {
		return grade;
	}

	public void setGrade(int grade) {
		this.grade = grade;
	}

	@Override
	public String toString() {
		return "EmployeeScore [employeeScoreId=" + employeeScoreId + ", courseName=" + courseName + ", grade=" + grade
				+ "]";
	}

	public EmployeeScore(String employeeScoreId, String courseName, int grade) {
		super();
		this.employeeScoreId = employeeScoreId;
		this.courseName = courseName;
		this.grade = grade;
	}

}

测试类：

package ch03;

import java.util.ArrayList;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TreeMap;

public class Test {
	public static void main(String[] args) {
		//问题一:按照员工号小到大，课程名小到大排序:
		Sort();
	        //问题二:使用先分组，再遍历合并的方法将数据按员工号，课程名对成绩求和。
		Group_First();
		//问题三:使用先排序，再遍历合并的方法将数据按员工号，课程名对成绩求和。
		Sort_First();
	}

	//问题一:按照员工号小到大，课程名小到大排序:
	public static void Sort() {
		ArrayList<EmployeeScore> empList = Test.getList();
		empList.sort((data1, data2) -> {
			 int res=data1.getEmployeeScoreId().compareTo(data2.getEmployeeScoreId())==0?
					 data2.getCourseName().compareTo(data1.getCourseName()):
					 data1.getEmployeeScoreId().compareTo(data2.getEmployeeScoreId());
			 return res;
		});
		System.out.println("按照员工号小到大，课程名小到大排序:");
		for(EmployeeScore e: empList){
			System.out.println(e);
		} 
	}

	// 问题二:使用先分组，再遍历合并的方法将数据按员工号，课程名对成绩求和。
	public static void Group_First() {
		ArrayList<EmployeeScore> empList = Test.getList();
		// 求和后的結果集
		Map<String, EmployeeScore> map = new TreeMap<String, EmployeeScore>();
		for (EmployeeScore e : empList) {
			// 判断是否已有同分组
			String key = e.getEmployeeScoreId() + e.getCourseName();
			EmployeeScore value = e;
			if (map.containsKey(key)) {
				EmployeeScore tempEmp = map.get(key);
				map.put(key, new EmployeeScore(tempEmp.getEmployeeScoreId(), tempEmp.getCourseName(),
						tempEmp.getGrade() + e.getGrade()));
			} else {
				map.put(key, value);
			}
		}
		System.out.println("使用先分组，再遍历合并的方法将数据按员工号，课程名对成绩求和:");
		// 遍历显示每组的值
		for (Entry<String, EmployeeScore> entry : map.entrySet()) {
			System.out.println(entry.getValue().getEmployeeScoreId() + " " + entry.getValue().getCourseName() + " 成绩="
					+ entry.getValue().getGrade());
		}
	}
	
	// 问题三:使用先排序，再遍历合并的方法将数据按员工号，课程名对成绩求和。
	public static void Sort_First() {
		ArrayList<EmployeeScore> empList = Test.getList();
		// 排序
		empList.sort((data1, data2) -> {
			int res = data1.getEmployeeScoreId().compareTo(data2.getEmployeeScoreId()) == 0
					? data1.getCourseName().compareTo(data2.getCourseName())
					: data1.getEmployeeScoreId().compareTo(data2.getEmployeeScoreId());
			return res;
		});
		System.out.println("使用先排序，再遍历合并的方法将数据按员工号，课程名对成绩求和:");
		// 用于保存上一条数据的变量
		String oldDataKey = null;
		// 用于保存同组值求和的变量
		Integer sumValue = 0;
		for (EmployeeScore newData : empList) {
			String newDataKey = newData.getEmployeeScoreId() + " "+newData.getCourseName();
			Integer newDataValue = newData.getGrade();
			// KEY发生变化时，表示原KEY数据已遍历完成
			if (oldDataKey != null && !newDataKey.equals(oldDataKey)) {
				System.out.println(oldDataKey + " 成绩=" + sumValue);
				sumValue = 0;
			}
			// 集计本行数据
			sumValue += newDataValue;
			// 将本行数据的key变为旧key
			oldDataKey = newDataKey;
		}
		// 显示最后一行处理完后最后一个key的数据
		System.out.println(oldDataKey + " 成绩=" + sumValue);
	}
	
	// 取得集合
	public static ArrayList<EmployeeScore> getList() {
		ArrayList<EmployeeScore> empList = new ArrayList<EmployeeScore>();
		EmployeeScore em1 = new EmployeeScore("111", "課程1", 6);
		empList.add(em1);
		EmployeeScore em2 = new EmployeeScore("222", "課程3", 5);
		empList.add(em2);
		EmployeeScore em3 = new EmployeeScore("333", "課程1", 1);
		empList.add(em3);
		EmployeeScore em4 = new EmployeeScore("111", "課程3", 3);
		empList.add(em4);
		EmployeeScore em5 = new EmployeeScore("111", "課程2", 7);
		empList.add(em5);
		EmployeeScore em6 = new EmployeeScore("222", "課程5", 3);
		empList.add(em6);
		EmployeeScore em7 = new EmployeeScore("222", "課程5", 6);
		empList.add(em7);
		EmployeeScore em8 = new EmployeeScore("222", "課程5", 1);
		empList.add(em8);
		EmployeeScore em9 = new EmployeeScore("111", "課程1", 2);
		empList.add(em9);
		return empList;
	}
}