关于java中的排序排序

/**
	 * comparable接口使用举例：自然排序
	 * 像String 包装类都重写了compareTo()方法，默认从小到大排序
	 * 
	 */
	@Test
	public void test1() {
		String[] arr = new String[] {"BB","AA","RR","CC"};
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
	}

/**
     * 对于自定义类，如果需要排序，，可以让自定义类实现comparable接口,重写compareTo(),在compareTo()方法中指明如何排序
     * 重写规则（从小到大排序）：如果当前对象this大于形参对象obj，返回正整数
     *              如果当前对象this小于形参对象obj，返回负整数
     *              如果当前对象this等于形参对象obj，返回0
     */

import org.w3c.dom.css.ElementCSSInlineStyle;

/**
 * 商品类
 * @author LiLanQi
 *
 */
public class Goods implements Comparable{
	private String name;
	private double price;
	
	public Goods() {
	}
	
	public Goods(String name, double price) {
		super();
		this.name = name;
		this.price = price;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	@Override
	public String toString() {
		return "Goods [name=" + name + ", price=" + price + "]";
	}

	//按照什么方法进行排序，按照价格从低到高，若价格一样，按照产品名称排序
	@Override
	public int compareTo(Object o) {
		if(o instanceof Goods) {
			Goods goods = (Goods) o;
			if (this.price > goods.price) {
				return 1;
			} else if(this.price < goods.price) {
				return -1;
			} else {
				return this.name.compareTo(goods.name);
			}
		}
		return 0;
	}
}

完整代码看注释

import java.util.Arrays;
import java.util.Comparator;

import org.junit.jupiter.api.Test;

public class CompareTest {

	/**
	 * comparable接口使用举例：自然排序
	 * 像String 包装类都重写了compareTo()方法，默认从小到大排序
	 * 
	 */
	@Test
	public void test1() {
		String[] arr = new String[] {"BB","AA","RR","CC"};
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	/**
	 * 对于自定义类，如果需要排序，，可以让自定义类实现comparable接口,重写compareTo(),在compareTo()方法中指明如何排序
	 * 重写规则（从小到大排序）：如果当前对象this大于形参对象obj，返回正整数
	 * 			 如果当前对象this小于形参对象obj，返回负整数
	 * 			 如果当前对象this等于形参对象obj，返回0
	 */
	@Test
	public void test2() {
		Goods[] arr = new Goods[5];
		arr[0] = new Goods("lenovoMouse", 34);
		arr[1] = new Goods("dellMouse", 43);
		arr[2] = new Goods("xiaomiMouse", 12);
		arr[3] = new Goods("huaweiMouse", 65);
		arr[4] = new Goods("weiruanMouse", 43);
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	/**
	 * comparator接口的使用:定制排序
	 * 1.背景
	 * 当元素的类型没有实现comparable接口而又不方便修改代码
	 * 或者实现了comparable接口的排序规则不适合当前的操作
	 * 那么可以考虑使用comparator的对象来排序
	 * 2.重写compare(Object o1, Object o2)方法
	 * 如果返回正整数，那么表示o1>o2
	 * 如果返回负整数，那么表示o1<o2
	 * 如果返回0，那么表示o1=o2
	 */
	@Test
	public void test3() {
		String[] arr = new String[] {"BB","AA","RR","CC"};
		//按照字符串从大到小的顺序排列
		Arrays.sort(arr, new Comparator() {//匿名内部类
			
			@Override
			public int compare(Object o1, Object o2) {
				if (o1 instanceof String && o2 instanceof String) {
					String s1 = (String) o1;
					String s2 = (String) o2;
					return -s1.compareTo(s2);
				}
				throw new RuntimeException("输入的数据类型不一致");
			}
			
		});
		
		
		System.out.println(Arrays.toString(arr));
	}
	
	//按照什么方法进行排序，按照按照产品名称排序从低到高，再按照价格从高到低
	@Test
	public void test4() {
		Goods[] arr = new Goods[5];
		arr[0] = new Goods("lenovoMouse", 34);
		arr[1] = new Goods("lenovoMouse", 43);
		arr[2] = new Goods("lenovoMouse", 12);
		arr[3] = new Goods("huaweiMouse", 65);
		arr[4] = new Goods("weiruanMouse", 43);
		Arrays.sort(arr, new Comparator<Goods>() {

			@Override
			public int compare(Goods o1, Goods o2) {
				if (!o1.getName().equals(o2.getName())) {
					return o1.getName().compareTo(o2.getName());
				} else {
					return -Double.compare(o1.getPrice(), o2.getPrice());
				}
			}
		});
		
		
		System.out.println(Arrays.toString(arr));
	}
	
}

总结：一般为了实现排序有俩种方法，一种就是继承comparable接口，实现里面的compareTo方法，另外一种继承comparator接口，实现里面的compare方法。