Java基础——Collections.sort的两种用法排序详解
转载自https://www.cnblogs.com/yw0219/p/7222108.html?utm_source=itdadao&utm_medium=referral
Collections是一个工具类,sort是其中的静态方法,是用来对List类型进行排序的,它有两种参数形式:
public static <T extends Comparable<? super T>> void sort(List<T> list) { list.sort(null); }
public static <T> void sort(List<T> list, Comparator<? super T> c) { list.sort(c); }
首先使用基本类型(此处使用Integer)来演示第一个方法:
static List<Integer> intList = Arrays.asList(2, 3, 1);
private static void sortBaseTypeByDefaultMode() { System.out.println("before sort:"); PrintUtil.showList(intList); System.out.println("========================="); Collections.sort(intList); System.out.println("after sort:"); PrintUtil.showList(intList); }
PrintUtil.showList是自定义的一个打印List类型的方法,此处只关心输出结果就行,如下:
可以看到,默认的排序是正序,那么如何实现逆序呢,这就要使用第二种方式了,即通过实现Comparator接口的compare方法来完成自定义排序,代码如下:
private static void sortBaseTypeByIDefineMode() { System.out.println("before sort:"); PrintUtil.showList(intList); System.out.println("========================="); Collections.sort(intList,new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { // 返回值为int类型,大于0表示正序,小于0表示逆序 return o2-o1; } }); System.out.println("after sort:"); PrintUtil.showList(intList); }
可以看到,已经实现了逆序的排序了。
接下来看看自定义类的排序:
定义一个Emp类:
public class Emp{ private int empno; private String ename; public int getEmpno() { return empno; } public void setEmpno(int empno) { this.empno = empno; } public String getEname() { return ename; } public void setEname(String ename) { this.ename = ename; } public Emp(int empno, String ename) { super(); this.empno = empno; this.ename = ename; } @Override public String toString() { return "empno:\t"+empno+"\tename:\t"+ename; } }
首先使用同样的方式来使用Collections.sort方法:
定义泛型违Emp类型的List:
static List<Emp> empList; static { Emp emp1 = new Emp(2,"Guan YunChang"); Emp emp2 = new Emp(3,"Zhang Fei"); Emp emp3 = new Emp(1,"Liu Bei"); empList = Arrays.asList(emp1,emp2,emp3); }
对empList进行排序:
此时会报错:
The method sort(List<T>) in the type Collections is not applicable for the arguments (List<Emp>)
意思是参数类型为List<Emp>时,sort方法无法执行,原因是泛型没有继承Comparable接口,这种方式稍后再说,我们先使用sort方法的第二种形式:
private static void sortEmpByIDefineMode() { System.out.println("before sort:"); PrintUtil.showList(empList); System.out.println("========================="); Collections.sort(empList,new Comparator<Emp>() { @Override public int compare(Emp o1, Emp o2) { /*按员工编号正序排序*/ return o1.getEmpno()-o2.getEmpno(); /*按员工编号逆序排序*/ //return o2.getEmpno()-o1.getEmpno(); /*按员工姓名正序排序*/ //return o1.getEname().compareTo(o2.getEname()); /*按员工姓名逆序排序*/ //return o2.getEname().compareTo(o1.getEname()); } }); System.out.println("after sort:"); PrintUtil.showList(empList); }
运行结果:
根据不同的排序方式即可呈现不同的结果。
接下来看看第一种形式的实现,首先让Emp类继承Comparable接口并重写compareTo方法(为了和上面的排序方式区别开,此次按照员工姓名逆序排列):
public class Emp implements Comparable<Emp>{ /*属性、getter/setter方法、toString方法及构造方法略*/ @Override public int compareTo(Emp emp) { /*按员工编号正序排序*/ //return this.getEmpno()-emp.getEmpno(); /*按员工编号逆序排序*/ //return emp.getEmpno()-this.getEmpno(); /*按员工姓名正序排序*/ //return this.getEname().compareTo(emp.getEname()); /*按员工姓名逆序排序*/ return emp.getEname().compareTo(this.getEname()); } }
使用Collections.sor方法的第一种形式实现:
private static void sortEmpByDefaultMode() { System.out.println("before sort:"); PrintUtil.showList(empList); System.out.println("========================="); Collections.sort(empList); System.out.println("after sort:"); PrintUtil.showList(empList); }
运行结果:
总结:
1.对于String或Integer这些已经实现Comparable接口的类来说,可以直接使用Collections.sort方法传入list参数来实现默认方式(正序)排序;
2.如果不想使用默认方式(正序)排序,可以通过Collections.sort传入第二个参数类型为Comparator来自定义排序规则;
3.对于自定义类型(如本例子中的Emp),如果想使用Collections.sort的方式一进行排序,可以通过实现Comparable接口的compareTo方法来进行,如果不实现,则参考第2点;
4.jdk1.8的Comparator接口有很多新增方法,其中有个reversed()方法比较实用,是用来切换正序和逆序的,代码如下:
private static void sortEmpByIDefineMode() { System.out.println("before sort:"); PrintUtil.showList(empList); System.out.println("========================="); Comparator<Emp> comparator = new Comparator<Emp>() { @Override public int compare(Emp o1, Emp o2) { /*按员工编号正序排序*/ return o1.getEmpno()-o2.getEmpno(); /*按员工编号逆序排序*/ //return o2.getEmpno()-o1.getEmpno(); /*按员工姓名正序排序*/ //return o1.getEname().compareTo(o2.getEname()); /*按员工姓名逆序排序*/ //return o2.getEname().compareTo(o1.getEname()); } }; /*新的逆序实现方式*/ Collections.sort(empList,comparator.reversed()); System.out.println("after sort:"); PrintUtil.showList(empList); }
复写的compare方法定义的是按员工编号正序排序,在使用reversed翻转后结果如下:
这样就使得排序规则的切换更为方便了。
转载自http://blog.csdn.net/tjcyjd/article/details/6804690
Comparator是个接口,可重写compare()及equals()这两个方法,用于比价功能;如果是null的话,就是使用元素的默认顺序,如a,b,c,d,e,f,g,就是a,b,c,d,e,f,g这样,当然数字也是这样的。
compare(a,b)方法:根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。equals(obj)方法:仅当指定的对象也是一个 Comparator,并且强行实施与此 Comparator 相同的排序时才返回 true。
Collections.sort(list, new PriceComparator());的第二个参数返回一个int型的值,就相当于一个标志,告诉sort方法按什么顺序来对list进行排序。
具体实现代码方法如下:
Book实体类:
package com.tjcyjd.comparator;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.GregorianCalendar;
import java.util.Iterator;
import java.util.TreeMap;
/**
* 书实体类
*
* @author yjd
*
*/
public class Book implements Comparable { // 定义名为Book的类,默认继承自Object类
public int id;// 编号
public String name;// 名称
public double price; // 价格
private String author;// 作者
public GregorianCalendar calendar;// 出版日期
public Book() {
this(0, "X", 0.0, new GregorianCalendar(), "");
}
public Book(int id, String name, double price, GregorianCalendar calender,
String author) {
this.id = id;
this.name = name;
this.price = price;
this.calendar = calender;
this.author = author;
}
// 重写继承自父类Object的方法,满足Book类信息描述的要求
public String toString() {
String showStr = id + "\t" + name; // 定义显示类信息的字符串
DecimalFormat formatPrice = new DecimalFormat("0.00");// 格式化价格到小数点后两位
showStr += "\t" + formatPrice.format(price);// 格式化价格
showStr += "\t" + author;
SimpleDateFormat formatDate = new SimpleDateFormat("yyyy年MM月dd日");
showStr += "\t" + formatDate.format(calendar.getTime()); // 格式化时间
return showStr; // 返回类信息字符串
}
public int compareTo(Object obj) {// Comparable接口中的方法
Book b = (Book) obj;
return this.id - b.id; // 按书的id比较大小,用于默认排序
}
public static void main(String[] args) {
Book b1 = new Book(10000, "红楼梦", 150.86, new GregorianCalendar(2009,
01, 25), "曹雪芹、高鄂");
Book b2 = new Book(10001, "三国演义", 99.68, new GregorianCalendar(2008, 7,
8), "罗贯中 ");
Book b3 = new Book(10002, "水浒传", 100.8, new GregorianCalendar(2009, 6,
28), "施耐庵 ");
Book b4 = new Book(10003, "西游记", 120.8, new GregorianCalendar(2011, 6,
8), "吴承恩");
Book b5 = new Book(10004, "天龙八部", 10.4, new GregorianCalendar(2011, 9,
23), "搜狐");
TreeMap tm = new TreeMap();
tm.put(b1, new Integer(255));
tm.put(b2, new Integer(122));
tm.put(b3, new Integer(688));
tm.put(b4, new Integer(453));
tm.put(b5, new Integer(40));
Iterator it = tm.keySet().iterator();
Object key = null, value = null;
Book bb = null;
while (it.hasNext()) {
key = it.next();
bb = (Book) key;
value = tm.get(key);
System.out.println(bb.toString() + "\t库存:" + tm.get(key));
}
}
}
自定义比较器和测试类:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.GregorianCalendar;
import java.util.Iterator;
import java.util.List;
public class UseComparator {
public static void main(String args[]) {
List<Book> list = new ArrayList<Book>(); // 数组序列
Book b1 = new Book(10000, "红楼梦", 150.86, new GregorianCalendar(2009,
01, 25), "曹雪芹、高鄂");
Book b2 = new Book(10001, "三国演义", 99.68, new GregorianCalendar(2008, 7,
8), "罗贯中 ");
Book b3 = new Book(10002, "水浒传", 100.8, new GregorianCalendar(2009, 6,
28), "施耐庵 ");
Book b4 = new Book(10003, "西游记", 120.8, new GregorianCalendar(2011, 6,
8), "吴承恩");
Book b5 = new Book(10004, "天龙八部", 10.4, new GregorianCalendar(2011, 9,
23), "搜狐");
list.add(b1);
list.add(b2);
list.add(b3);
list.add(b4);
list.add(b5);
// Collections.sort(list); //没有默认比较器,不能排序
System.out.println("数组序列中的元素:");
myprint(list);
Collections.sort(list, new PriceComparator()); // 根据价格排序
System.out.println("按书的价格排序:");
myprint(list);
Collections.sort(list, new CalendarComparator()); // 根据时间排序
System.out.println("按书的出版时间排序:");
myprint(list);
}
// 自定义方法:分行打印输出list中的元素
public static void myprint(List<Book> list) {
Iterator it = list.iterator(); // 得到迭代器,用于遍历list中的所有元素
while (it.hasNext()) {// 如果迭代器中有元素,则返回true
System.out.println("\t" + it.next());// 显示该元素
}
}
// 自定义比较器:按书的价格排序
static class PriceComparator implements Comparator {
public int compare(Object object1, Object object2) {// 实现接口中的方法
Book p1 = (Book) object1; // 强制转换
Book p2 = (Book) object2;
return new Double(p1.price).compareTo(new Double(p2.price));
}
}
// 自定义比较器:按书出版时间来排序
static class CalendarComparator implements Comparator {
public int compare(Object object1, Object object2) {// 实现接口中的方法
Book p1 = (Book) object1; // 强制转换
Book p2 = (Book) object2;
return p2.calendar.compareTo(p1.calendar);
}
}
}
相关文章
- 怎么下载java_怎样下载Java的环境?
- java常量有哪些_JAVA常量介绍「建议收藏」
- java环境_Java基础篇——环境配置
- 【说站】java中BigDecimal的数学运算
- Java基础需要掌握的单词
- 深入解析java虚拟机:垃圾回收,垃圾回收基础概述
- 重新认识java(十) —- Enum(枚举类)[通俗易懂]
- 大数据必学Java基础(九十一):JDBC概述
- 开启Java之门:访问MySQL数据库(java访问mysql数据库)
- 解决Java程序连接MySQL的准确方案:Java连接MySQL的Jar包(java连接mysql的jar包)
- Oracle 参数 JAVA_SOFT_SESSIONSPACE_LIMIT 官方解释,作用,如何配置最优化建议
- Java多线程(二):常用的实现多线程的两种方式详解编程语言
- Oracle转Java实现跨平台开发的奇妙之旅(oracle转java)
- 环境的基础Linux:Java环境的支撑者(linux是java)
- 部署Java开发下的Linux部署(java开发linux)
- 程序Oracle调用Java程序的实现方法(oracle调用java)
- Java之oracle知多少(java的oracle)
- Java与Oracle联手赋能全新版本面世(java版本oracle)
- java操作mongodb基础(查询排序输出list)
- Java进阶教程之IO基础