Java中Comparable和Comparator怎么使用

這篇文章主要講解了“Java中Comparable和Comparator怎么使用”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“Java中Comparable和Comparator怎么使用”吧！

Comparable 和 Comparator

Comparable 和 Comparator 是Java的兩個和排序相關的接口，又被稱為 自然排序和定制排序。最近看了相關的內容，現在來記錄以下自己的學習情況。
Comparable 和 Comparator 是關于排序的兩個接口，用來實現 Java 集合中的的排序功能。具體作用可以查看 API 獲取。

Comparable

這是API 文檔中的簡要介紹：

This interface imposes a total ordering on the objects of each class that implements it. This ordering is referred to as the class’s natural ordering, and the class’s compareTo method is referred to as its natural comparison method. Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

用法：

需要排序實體類的實現 Comparable 接口，并重寫 compareTo() 方法，就可以具有排序功能。某些會自動對元素進行排序的集合（如 TreeSet），當把元素放入集合中，就會自動調用 CompareTo() 方法進行排序（前提是元素必須實現這個接口）。但是其他的地方也可以使用的，不只是局限于 TreeSet，使用還是很廣泛的。

Comparator

這是API 文檔中的簡要介紹：

A comparison function, which imposes a total ordering on some collection of objects. Comparators can be passed to a sort method (such as Collections.sort or Arrays.sort) to allow precise control over the sort order. Comparators can also be used to control the order of certain data structures (such as sorted sets or sorted maps), or to provide an ordering for collections of objects that don’t have a natural ordering.

用法：

Comparator 是一個第三方接口，具體用法是：設計一個比較器，創建一個類，實現這個接口，重寫 compare() 方法。并且由于 Comparator 是一個函數式接口，可以使用 Lambda 表達式代替 Comparator 對象，使得代碼更加簡潔明了。

Talk is cheap, show me the code.

注意：博客中的內容可能不會很詳細，所以想看的具體細節的，應該以書本和官方文檔為主，這里的內容更多的是簡單的介紹一下基本的用法。

測試實體類：Dog

public class Dog implements Comparable<Dog>{
	private String name;
	private int age;
	
	public Dog(String name, int age) {
		this.name = name;
		this.age = 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;
	}
	
	@Override
	public String toString() {
		return "Dog [name=" + name + ", age=" + age + "]";
	}

	@Override
	public int compareTo(Dog dog) {
		return this.age > dog.age ? 1 : this.age < dog.age ? -1 : 0;
	}
}

測試實體類：Cat

public class Cat implements Comparable<Cat>{
	private String name;
	private Integer age;
	
	public Cat(String name, Integer age) {
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "Cat [name=" + name + ", age=" + age + "]";
	}

	@Override
	public int compareTo(Cat o) {
		//可以直接調用，這樣更簡單
		//調換 o.age 和 this.age 就是相反的順序
		return o.age.compareTo(this.age); 
	}
}

測試類：Test

public class Test {
	public static void main(String[] args) {
		List<Dog> dogs = new LinkedList<>();
		List<Cat> cats = new LinkedList<>();
		
		dogs.add(new Dog("大黃",6));
		dogs.add(new Dog("大白",1));
		dogs.add(new Dog("小黑",5));
		dogs.add(new Dog("旺財",3));
		dogs.add(new Dog("二哈",2));
		
		cats.add(new Cat("牛牛",3));
		cats.add(new Cat("花咪",4));
		cats.add(new Cat("咪咪",10));
		cats.add(new Cat("小黃",2));
		cats.add(new Cat("大橘",6));
		
		//參數為 null 使用 自然排序，否則使用 定制排序
		//也可以看出來 定制排序 優先級高于 自然排序
		System.out.println("---------自然排序 升序--------");
		dogs.sort(null);   
		dogs.forEach(System.out::println);
		System.out.println("---------自然排序 降序--------");
		cats.sort(null);
		cats.forEach(System.out::println);
		
		//定制排序
	    //Comparator<Dog> c = (e1,e2)->e2.getAge() - e1.getAge();
		//dogs.sort(c) 這個就是下面這個的具體形式，
		//可以看出來參數是一個 Comparator 對象  
		System.out.println("---------定制排序 降序--------");
		dogs.sort((e1,e2)->e2.getAge() - e1.getAge());
		//流式API的簡單的應用，效果和上面的類似，或者直接使用 forEacn 循環遍歷
		dogs.stream().forEach(System.out::println);
		System.out.println("---------定制排序 升序--------");
	//	另一種遍歷方式，可以看出來函數式編程非常靈活，我也是初學，覺得很神奇。
		cats.stream()
		.sorted((e1,e2)->e1.getAge()-e2.getAge())
		.forEach(System.out::println);
	}
}

運行截圖：

補充說明：list.sort()方法
API 文檔中的描述：

Sorts this list according to the order induced by the specified Comparator.
All elements in this list must be mutually comparable using the specified comparator (that is, c.compare(e1, e2) must not throw a ClassCastException for any elements e1 and e2 in the list). If the specified comparator is null then all elements in this list must implement the Comparable interface and the elements’s natural ordering should be used. This list must be modifiable, but need not be resizable.

可以看到，這個方法進行排序通過一個 Comparator 對象，如果傳入參數為 null 的話，則會進行自然排序，但是注意：自然排序的前提是相應的實體類實現了 Comparable 接口，并重寫了 compareTo() 方法。

感謝各位的閱讀，以上就是“Java中Comparable和Comparator怎么使用”的內容了，經過本文的學習后，相信大家對Java中Comparable和Comparator怎么使用這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！