Java排序简介

2018-05-01 本文已影响102人 nextliving

排序

简介

排序相关的接口有2个:

Comparator: 主要需要实现的方法是compare(T o1, T o2).该方法的返回值是1,0和-1.实现该接口的类是一个比较器,可以比较其它类的2个不同实例.换言之,它处理的是和自己不相关的2个对象.注意：返回负值代表o1排在前面(即o1-o2<0),返回正值代表o1排在后面(即o1-o2>0)
Comparable: 主要需要实现的方法是compareTo(T o).该方法的返回值是1,0和-1.实现该接口的类,它的实例之间可以相互比较.换言之,实现该接口可以让自己和其它对象比较.实现这个接口的排序也叫自然排序(natural ordering),相对来说Comparator实现的是自定义排序.

这2个接口都让需要排序的类的实例具备可比较排序的能力,它们的区别是Comparable是一个类与生俱来的内在的默认的排序规则,比如代表一个人的类,根据年龄排序.但是如果还需要其它的更多的排序规则,比如根据成绩,根据身高等排序,就需要借助Comparator实现更多的排序规则,一个规则对应一个实现了Comparator接口的类.

注意: 如果一个类实现了Comparable,但是比较的时候又使用了Comparator,比较的规则要按照Comparator中的规则来,Comparable对应的自然排序规则完全不起作用.

返回值和排序的关系

返回值可以不是-1和1,但是必须是2个符号相反的整数,比如-2、0、2的组合也是可以的,其它以此类推.返回负值代表排序在前面,返回正值代表排序在后面

排序触发

是不是具备了排序的能力就会自动排序呢?不是的.需要调用排序相关的方法触发排序.主要的方法是:

Collections.sort(): 用于对java.util.List排序,具体参数是sort(List<T> list)或者sort(List<T> list, Comparator<? super T> c).
Arrays.sort(): 用于数组的排序

代码案例

使用Arrays.sort对int[]排序

代码如下:


@Test

public void sortInt() {

int[] intArray = {2,3,4,1,0,9,8};

for (int i=0; i<intArray.length; i++) {

System.out.println("原始数组:"+i+"-"+intArray[i]);

}

System.out.println("===============");

Arrays.sort(intArray);

for (int i=0; i<intArray.length; i++) {

System.out.println("排序后的数组:"+i+"-"+intArray[i]);

}

}

执行测试打印结果如下:


原始数组:0-2

原始数组:1-3

原始数组:2-4

原始数组:3-1

原始数组:4-0

原始数组:5-9

原始数组:6-8

===============

排序后的数组:0-0

排序后的数组:1-1

排序后的数组:2-2

排序后的数组:3-3

排序后的数组:4-4

排序后的数组:5-8

排序后的数组:6-9

可以int[]使用Arrays.sort(int[] a)排序是按照由小到大排序的.如果需要自定义排序,可以实现Comparator接口并使用Arrays.sort(T[] a, Comparator<? super T> c)方法排序.

使用Collections.sort对List进行自然排序(natural ordering)

商品有价格、编号、销量、名称4个属性,商品的自然排序(natural ordering)是按价格由高到低.对应的商品类为:


package com.ms.util.sort.list;

/**

 * 商品的自然排序(Natural Ordering)是按价格由大到小

* 自然排序也就是实现了Comparable接口的排序

 * @author iengchen

 * @since 2018-05-01

 */

public class ProductSort implements Comparable<ProductSort> {

//价格

private int price;

//销量

private int soldNum;

//分类编号

private int proNum;

//名称

private String name;

public ProductSort(int price,int soldNum,int proNum,String name) {

this.price = price;

this.soldNum = soldNum;

this.proNum = proNum;

this.name = name;

}

public int getPrice() {

return price;

}

public void setPrice(int price) {

this.price = price;

}

public int getSoldNum() {

return soldNum;

}

public void setSoldNum(int soldNum) {

this.soldNum = soldNum;

}

public int getProNum() {

return proNum;

}

public void setProNum(int proNum) {

this.proNum = proNum;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Override

public int compareTo(ProductSort o) {

if (this.price > o.price) {

//返回负值代表排在被比较的对象的前面,这里是价格大的排前面

return -1;

} else if (this.price < o.price) {

return 1;

} else {

return 0;

}

}

}

测试类ProductSortTest.java为


package com.ms.util.sort.list;

import java.util.ArrayList;

import java.util.Collections;

import org.junit.Test;

/**

 * 对ProductSort类测试

 * @author iengchen

 * @since 2018-05-01

 */

public class ProductSortTest {

/**

* 测试自然排序,也就是Comparable接口的compareTo方法所实现的排序规则.

* @author iengchen

* @since 2018-05-01

*/

@Test

public void naturalOrderingTest() {

ProductSort ps1 = new ProductSort(23, 322, 3, "松下电视机");

ProductSort ps2 = new ProductSort(74, 99, 3, "索尼电视机");

ProductSort ps3 = new ProductSort(3, 488, 8, "卫龙辣条");

ProductSort ps4 = new ProductSort(18, 300, 4, "美的电吹风");

ArrayList<ProductSort> productSorts = new ArrayList<>();

productSorts.add(ps1);

productSorts.add(ps2);

productSorts.add(ps3);

productSorts.add(ps4);

for (int i = 0; i < productSorts.size(); i++) {

ProductSort ps = productSorts.get(i);

System.out.println("名称:"+ps.getName()+",商品分类:"+ps.getProNum()+",销量:"+ps.getSoldNum()+",价格:"+ps.getPrice());

}

System.out.println("====== 自然排序后 ======");

Collections.sort(productSorts);

for (int i = 0; i < productSorts.size(); i++) {

ProductSort ps = productSorts.get(i);

System.out.println("名称:"+ps.getName()+",商品分类:"+ps.getProNum()+",销量:"+ps.getSoldNum()+",价格:"+ps.getPrice());

}

}

}

执行测试方法打印结果如下:


名称:松下电视机,商品分类:3,销量:322,价格:23

名称:索尼电视机,商品分类:3,销量:99,价格:74

名称:卫龙辣条,商品分类:8,销量:488,价格:3

名称:美的电吹风,商品分类:4,销量:300,价格:18

====== 自然排序后 ======

名称:索尼电视机,商品分类:3,销量:99,价格:74

名称:松下电视机,商品分类:3,销量:322,价格:23

名称:美的电吹风,商品分类:4,销量:300,价格:18

名称:卫龙辣条,商品分类:8,销量:488,价格:3

使用Collections.sort对List进行自定义排序

在上面的测试类ProductSortTest.java中添加下面的代码:


/**

* 使用Comparator实现自定义排序,按销量由高到低

* @author iengchen

* @since 2018-05-01

*/

@Test

public void customOrderTest() {

ProductSort ps1 = new ProductSort(23, 322, 3, "松下电视机");

ProductSort ps2 = new ProductSort(74, 99, 3, "索尼电视机");

ProductSort ps3 = new ProductSort(3, 488, 8, "卫龙辣条");

ProductSort ps4 = new ProductSort(18, 300, 4, "美的电吹风");

ArrayList<ProductSort> productSorts = new ArrayList<>();

productSorts.add(ps1);

productSorts.add(ps2);

productSorts.add(ps3);

productSorts.add(ps4);

for (int i = 0; i < productSorts.size(); i++) {

ProductSort ps = productSorts.get(i);

System.out.println("名称:"+ps.getName()+",商品分类:"+ps.getProNum()+",销量:"+ps.getSoldNum()+",价格:"+ps.getPrice());

}

System.out.println("====== 自定义排序后 ======");

Collections.sort(productSorts, new Comparator<ProductSort>() {

//compare方法返回值为正代表o1-o2>0,即o1>o2。
//返回值为负代表o1-o2<0,即o1<o2。
@Override

public int compare(ProductSort o1, ProductSort o2) {

if (o1.getSoldNum() > o2.getSoldNum()) {

//-1表示o1<o2，o2排在后面。注意：返回值和if中的大小没有关系，只和传递进来的参数顺序有关。

return -1;

} else if (o1.getSoldNum() < o2.getSoldNum()) {
//返回1表示o1>o2，o1排在后面。注意：返回值和if中的大小没有关系，只和传递进来的参数顺序有关。
return 1;

} else {

return 0;

}

}

});

for (int i = 0; i < productSorts.size(); i++) {

ProductSort ps = productSorts.get(i);

System.out.println("名称:"+ps.getName()+",商品分类:"+ps.getProNum()+",销量:"+ps.getSoldNum()+",价格:"+ps.getPrice());

}

}

执行这个测试方法的打印结果如下:


名称:松下电视机,商品分类:3,销量:322,价格:23

名称:索尼电视机,商品分类:3,销量:99,价格:74

名称:卫龙辣条,商品分类:8,销量:488,价格:3

名称:美的电吹风,商品分类:4,销量:300,价格:18

====== 自定义排序后 ======

名称:卫龙辣条,商品分类:8,销量:488,价格:3

名称:松下电视机,商品分类:3,销量:322,价格:23

名称:美的电吹风,商品分类:4,销量:300,价格:18

名称:索尼电视机,商品分类:3,销量:99,价格:74

可以看到按照销量由高到低排序.自然排序规则没有起作用.可以看出,当使用了Comparator时,Comparable的排序规则会失效.