java集合进⾏排序的⽅式总结
ava集合的⼯具类Collections中提供了两种排序的⽅法，分别是:
1. Collections.sort(List list)
2. Collections.sort(List list,Comparator c)
第⼀种称为⾃然排序，参与排序的对象需实现comparable接⼝，重写其compareTo()⽅法,⽅法体中实现对象的⽐较⼤⼩规则,⽰例如下:
实体类:(基本属性,getter/setter⽅法，有参⽆参构造⽅法,toString⽅法)
package test;
public class Emp implements Comparable {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Emp() {
super();
}
public Emp(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Emp [name=" + name + ", age=" + age + "]";
}
@Override
public int compareTo(Object o) {
if(o instanceof Emp){
Emp emp = (Emp) o;
// return Age();//按照年龄升序排序
return this.Name());//换姓名升序排序
}
throw new ClassCastException("不能转换为Emp类型的对象...");
}
}
第⼆种叫定制排序，或⾃定义排序，需编写匿名内部类，先new⼀个Comparator接⼝的⽐较器对象c，同时实现compare()其⽅法;
然后将⽐较器对象c传给Collections.sort()⽅法的参数列表中，实现排序功能;
说明：第⼀种⽅法不够灵活，实体类实现了comparable接⼝后，会增加耦合，如果在项⽬中不同的位置需要根据不同的属性调⽤排序⽅法时，需要反复修改⽐较规则(按name还是按age),⼆者只能选择其⼀，会起冲突.第⼆种就很好地解决了这个问题.在需要的地⽅，创建个内部类的实例，重写其⽐较⽅法即可.
jUnit4单元测试类代码如下:
package test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import org.junit.BeforeClass;
import org.junit.Test;
public class TestSort {
static List list = new ArrayList();
//@BeforeClass注解标注的⽅法会在其它测试⽅法执⾏之前先执⾏, //且只执⾏⼀次.@Before注解标注的⽅法会在每个测试⽅法之前执⾏; //此处初始化集合只需要⼀次，因此使⽤@BeforeClass.
@BeforeClass
public static void init(){
list.add(new Emp("tom",18));
list.add(new Emp("jack",20));
list.add(new Emp("rose",15));
list.add(new Emp("jerry",17));
System.out.println("排序前:");
for(Object o : list){
System.out.println(o);
}
}
/**按age升序排序*/
// @Test
// public void testSortAge(){
// Collections.sort(list);
// System.out.println("⾃然排序按age排序后:");
// for(Object o : list){
/
/ System.out.println(o);
// }
// }
//
/**按name升序排序*/
@Test
public void testSortName(){
Collections.sort(list);
System.out.println("⾃然排序按name升序排序后:");
for(Object o : list){
System.out.println(o);
}
}
/**使⽤Comparator⽐较器按age升序排序*/
@Test
public void testComparatorSortAge(){
Collections.sort(list,new Comparator () {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Emp && o2 instanceof Emp){
Emp e1 = (Emp) o1;
Emp e2 = (Emp) o2;
Age() - e2.getAge();
}
throw new ClassCastException("不能转换为Emp类型");
}
});
System.out.println("使⽤Comparator⽐较器按age升序排序后:"); for(Object o : list){
System.out.println(o);
}
}
/**使⽤Comparator⽐较器按name升序排序*/
@Test
public void testComparatorSortName(){
Collections.sort(list,new Comparator () {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Emp && o2 instanceof Emp){
Emp e1 = (Emp) o1;
Emp e2 = (Emp) o2;
Name()Name());
}
throw new ClassCastException("不能转换为Emp类型");
}
});
System.out.println("使⽤Comparator⽐较器按name升序排序后:"); for(Object o : list){
System.out.println(o);
}
}
}
右键空⽩位置 —> Run As —> JUnit Test —>
运⾏结果如下:
排序前:
Emp [name=tom, age=18]
Emp [name=jack, age=20]
Emp [name=rose, age=15]
Emp [name=jerry, age=17]
⾃然排序按name升序排序后:
Emp [name=jack, age=20]
Emp [name=jerry, age=17]
Emp [name=rose, age=15]
Emp [name=tom, age=18]
使⽤Comparator⽐较器按age升序排序后:
Emp [name=rose, age=15]
Emp [name=jerry, age=17]
Emp [name=tom, age=18]
Emp [name=jack, age=20]
使⽤Comparator⽐较器按name升序排序后:
Emp [name=jack, age=20]
Emp [name=jerry, age=17]
Emp [name=rose, age=15]
Emp [name=tom, age=18]
内容扩展：
使⽤重载的Collections.sort(List,Comparator)⽅法
⽅法⼀：⾃定义⼀个⽐较器然后传⼊
Collections.sort(List,Comparator)中。
测试代码：
⾃定义的⽐较器：
import java.util.Comparator;
public class MyComparator implements Comparator<Cell>{
@Override
public int compare(Cell o1, Cell o2) {
Y()-o2.getY();//根据传⼊的cell的y坐标由⼩到⼤进⾏排序
java arraylist用法}
}
测试类：
@Test
public void testComparator() {
List<Cell> cells = new ArrayList<>();
cells.add(new Cell(2,3));
cells.add(new Cell(5,1));
cells.add(new Cell(3,2));
System.out.println(cells);//[Cell [x=2, y=3], Cell [x=5, y=1], Cell [x=3, y=2]]
MyComparator com = new MyComparator();
Collections.sort(cells,com);
System.out.println(cells);//根据⾃定义排序后的结果：[Cell [x=5, y=1], Cell [x=3, y=2], Cell [x=2, y=3]] }
⽅法⼆：采⽤匿名内部的形式（推荐做法）
@Test
public void testComparator() {
List<Cell> cells = new ArrayList<>();
cells.add(new Cell(2,3));
cells.add(new Cell(5,1));
cells.add(new Cell(3,2));
System.out.println(cells);//[Cell [x=2, y=3], Cell [x=5, y=1], Cell [x=3, y=2]]
Collections.sort(cells,new Comparator<Cell>(){//此处创建了⼀个匿名内部类
@Override
public int compare(Cell o1,Cell o2){
Y() - o2.getY();
}
});
System.out.println(cells);//[Cell [x=5, y=1], Cell [x=3, y=2], Cell [x=2, y=3]]
}
到此这篇关于java集合进⾏排序的⽅式总结的⽂章就介绍到这了，更多相关java集合进⾏排序的两种⽅式内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论