怎么使用Lambda表達(dá)式簡(jiǎn)化Comparator的使用問(wèn)題

這篇“怎么使用Lambda表達(dá)式簡(jiǎn)化Comparator的使用問(wèn)題”文章的知識(shí)點(diǎn)大部分人都不太理解，所以小編給大家總結(jié)了以下內(nèi)容，內(nèi)容詳細(xì)，步驟清晰，具有一定的借鑒價(jià)值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來(lái)看看這篇“怎么使用Lambda表達(dá)式簡(jiǎn)化Comparator的使用問(wèn)題”文章吧。

Comparator 接口

使用集合時(shí)，如果需要實(shí)現(xiàn)集合元素排序的話，通常有兩種選擇，元素本身實(shí)現(xiàn) Comparable 接口或者集合使用 Comparator 對(duì)象實(shí)現(xiàn)排序。這里來(lái)介紹一個(gè) Comparator 這個(gè)類。

接口簡(jiǎn)介

Comparator 是一個(gè)函數(shù)式接口，這個(gè)可以從它的定義上看出來(lái)。它具有這個(gè)注解：@FunctionalInterface。

這個(gè)注解標(biāo)注此接口屬于函數(shù)式接口，意味著只能有一個(gè)抽象方法，但是帶你進(jìn)去看，你會(huì)發(fā)現(xiàn)兩個(gè)抽象方法！

int compare(T o1, T o2);
boolean equals(Object obj);

這并不是定義錯(cuò)誤，而是上面那個(gè)注解（@FunctionalInterface）的文檔里有說(shuō)明：如果接口聲明了一個(gè)覆蓋了 java.lang.Object 的全局方法之一的抽象方法，那么它不會(huì)計(jì)入接口的抽象方法數(shù)量中，因?yàn)榻涌诘娜魏螌?shí)現(xiàn)都將具有 java.lang.Object 或者其它地方的實(shí)現(xiàn)。 因此，它確實(shí)是只有一個(gè)抽象方法：

int compare(T o1, T o2);

定義一個(gè)示例類用來(lái)演示：Dog類

package com.dragon;

public class Dog {
	private String name;
	private int age;
	private double weight;
	
	public Dog(String name, int age, double weight) {
		super();
		this.name = name;
		this.age = age;
		this.weight = weight;
	}
	//省略 getter 和 setter 方法，使用 IDE 自動(dòng)生成比較方便。
	//下面兩個(gè)方法，也都可以自動(dòng)生成。

	@Override
	public String toString() {
		return "Dog [name=" + name + ", age=" + age + ", weight=" + weight + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		long temp;
		temp = Double.doubleToLongBits(weight);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Dog other = (Dog) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (Double.doubleToLongBits(weight) != Double.doubleToLongBits(other.weight))
			return false;
		return true;
	}
}

接口方法介紹

這個(gè)接口雖然是一個(gè)函數(shù)式接口，但是它的方法可不少！所以，它可以實(shí)現(xiàn)非常豐富的排序功能！

直接使用接口的抽象方法創(chuàng)建 Comparator 對(duì)象

**排序規(guī)則是按照年齡升序。我這里使用的表達(dá)式為：

o1.getAge()-o2.getAge();

如果想要實(shí)現(xiàn)反序，調(diào)換 o1和o2的位置即可，但是我們不使用這種方式。下面會(huì)使用更加方便的方式。
**

1.使用原始的匿名內(nèi)部類方式，實(shí)現(xiàn) Comparator 對(duì)象。

package com.dragon;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class ComparatorTest {
	public static void main(String[] args) {
		//測(cè)試使用的集合，下面不再提供，只提供方法的實(shí)現(xiàn)。
		List<Dog> dogList = new ArrayList<>();
		dogList.add(new Dog("小黑", 3, 37.0));
		dogList.add(new Dog("二哈", 2, 40.0));
		dogList.add(new Dog("泰迪", 1, 8.0));
		dogList.add(new Dog("大黃", 4, 55.0));
		rawComparator(dogList);
	}
	
	/**
	 * 原始的實(shí)現(xiàn)比較器的方法，使用匿名類
	 * */
	static void rawComparator(List<? extends Dog> dogList) {
		dogList.sort(new Comparator<Dog>() {
			@Override
			public int compare(Dog o1, Dog o2) {
				return o1.getAge()-o2.getAge();
			}
		});
		dogList.forEach(System.out::println);
	}
}

說(shuō)明：這樣顯得較為繁瑣，不夠體現(xiàn)代碼的簡(jiǎn)介，下面使用Java8的 lambda 表達(dá)式來(lái)改寫。

運(yùn)行結(jié)果：

2.使用Java8 的lambda 表達(dá)式來(lái)簡(jiǎn)化代碼

/**
* 使用lambda的寫法
* */
static void lambda(List<? extends Dog> dogList) {
	Comparator<Dog> c = (dog1, dog2)->dog1.getAge() - dog2.getAge();
	dogList.sort(c);
	dogList.forEach(System.out::println);
}

3.舍去中間變量 c，進(jìn)一步簡(jiǎn)化代碼

/**
 * 舍去中間變量 c 的寫法
 * */
static void lambda2(List<? extends Dog> dogList) {
	dogList.sort((dog1, dog2)->dog1.getAge() - dog2.getAge());
	dogList.forEach(System.out::println);
}

總結(jié)：基本上，我們第一次接觸 lambda 的話，都會(huì)去學(xué)習(xí)寫這個(gè)表達(dá)式，感覺使用起來(lái)特別的方便，達(dá)到了簡(jiǎn)化代碼的目的。

接口中的靜態(tài)方法和默認(rèn)創(chuàng)建 Comparator 對(duì)象

comparing 方法（靜態(tài)）

接口中有一個(gè)靜態(tài)方法 comparing，使用起來(lái)也特別的方便，基本上可以代替上面的那種方式了，它的參數(shù)為：Function<? super T, ? extends U> keyExtractor，這需要傳入一個(gè) lambda 表達(dá)式。雖然這些方法的定義很復(fù)雜，但是使用起來(lái)卻感覺很簡(jiǎn)單，復(fù)雜的事情都被別人做了。

comparing 方法源碼

public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)
{
    Objects.requireNonNull(keyExtractor);
    return (Comparator<T> & Serializable)
        (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}

1.使用 comparing方法創(chuàng)建 Comparator 對(duì)象

/**
 * 使用 Java 8 提供的靜態(tài)方法 comparing 方法，
 * 再配合方法引用，寫法更加簡(jiǎn)潔了。但是看這個(gè)
 * 方法，我們可能會(huì)疑問(wèn)排序順序到底是正序還是逆序呢？
 * */
static void lambda3(List<? extends Dog> dogList) {
	dogList.sort(Comparator.comparing(Dog::getAge));
	dogList.forEach(System.out::println);
}

說(shuō)明： 通過(guò)上面的源碼可以看到，c1 和 c2 的位置是固定的（排序是固定的升序方式），它是通過(guò) Function 接口，調(diào)用apply方法，生成一個(gè)對(duì)象，然后調(diào)用 compareTo 方法進(jìn)行比較的。（例如，我們傳進(jìn)去的是age，類型為int，但是通過(guò)apply會(huì)返回 Integer類型。因?yàn)榘b類型和 String 類都實(shí)現(xiàn)了 Comparable 接口。）

注意： 如果不使用方法引用的話，那么 Dog::getAge 應(yīng)該被替換為：

(dog1, dog2)->dog1.getAge() - dog2.getAge()

不過(guò)，這樣做顯然就是去了簡(jiǎn)介性。

2.使用重載的 comparing 方法創(chuàng)建 Comparator 對(duì)象

comparing 方法源碼

 public static <T, U> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
 {
     Objects.requireNonNull(keyExtractor);
     Objects.requireNonNull(keyComparator);
     return (Comparator<T> & Serializable)
         (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                           keyExtractor.apply(c2));
 }

說(shuō)明： 它比上面的 comparing 方法多了一個(gè)參數(shù)，意味著它可以實(shí)現(xiàn)更豐富的比較操作。而且，這個(gè)參數(shù)也是一個(gè) Comparator 對(duì)象。

好了，下面使用這個(gè)方法，來(lái)實(shí)現(xiàn)按照年齡逆序排序。

/**
 * 解決 lambda3 中的疑問(wèn)，關(guān)于排序順序的問(wèn)題。
 * 上面那個(gè)方法是一個(gè)簡(jiǎn)便方法，它的排序是默認(rèn)的正序，
 * 而我們有時(shí)會(huì)希望逆序排序。所以我們需要使用它的一個(gè)重載方法了。
 * */
static void lambda4(List<? extends Dog> dogList) {
	//它的第二個(gè)參數(shù)，可能會(huì)引起困惑，第二個(gè)參數(shù)的類型就是第一個(gè)參數(shù)指定的類型（如果是基本類型，則為對(duì)應(yīng)的包裝類）
	dogList.sort(Comparator.comparing(Dog::getAge, (age1, age2)->age2-age1));
	dogList.forEach(System.out::println);
}

注意： 這里的第二個(gè)參數(shù)中的 age1 和 age2 的實(shí)際類型為 Integer而不是 int，可以直接相減的原因是因?yàn)樽詣?dòng)拆箱機(jī)制，所以這里推薦更換為：

說(shuō)明： 這樣看起來(lái)，似乎不夠簡(jiǎn)潔，下面將使用更加簡(jiǎn)潔的方式來(lái)實(shí)現(xiàn)逆序排序。

(age1, age2)->age2.compareTo(age1)

運(yùn)行結(jié)果：

3.使用comparing方法的更加簡(jiǎn)潔形式
Comparator 具有一個(gè)靜態(tài)的方法，它的功能很簡(jiǎn)單就是逆序。

/**
 * 相信看完 lambda4 都會(huì)感覺還沒有 lambda2 的方式簡(jiǎn)潔呢，
 * 但是因?yàn)檎蚝湍嫘蛑皇且粋€(gè)變換順序的問(wèn)題，所以它也提
 * 供了簡(jiǎn)潔的實(shí)現(xiàn)。當(dāng)然了，這也與我這里的使用的Dog對(duì)象，比較簡(jiǎn)單有關(guān)，
 * 只看這里的話， 和上面 lambda2 進(jìn)行比較，優(yōu)勢(shì)不太明顯。
 * */
static void lambda5(List<? extends Dog> dogList) {
	dogList.sort(Comparator.comparing(Dog::getAge, Comparator.reverseOrder()));
	dogList.forEach(System.out::println);
}

這樣，代碼就顯得簡(jiǎn)潔多了，當(dāng)然了，還可以使用一個(gè)默認(rèn)方法當(dāng)?shù)酵瑯拥哪康摹?/p>

/**
 * 這樣也可以
 * */
static void lambda55(List<? extends Dog> dogList) {
	dogList.sort(Comparator.comparing(Dog::getAge).reversed());
	dogList.forEach(System.out::println);
}

thenComparing 方法（默認(rèn)）

thenComparing 方法源碼：

default <U extends Comparable<? super U>> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor)
{
    return thenComparing(comparing(keyExtractor));
}

有時(shí)候，會(huì)碰到這樣的需求，需要使用多種排序方法，而不是單純的一種。例如使用：姓名、年齡、體重進(jìn)行排序。這時(shí)就需要使用 thenComparing 方法了。

/**
 * 實(shí)現(xiàn)按照多個(gè)標(biāo)準(zhǔn)排序：姓名、年齡、體重
 * 全部按照自然排序（升序）的順序
 * */
static void lambda7(List<? extends Dog> dogList) {
	dogList.sort(Comparator
			.comparing(Dog::getName)
			.thenComparing(Dog::getAge)
			.thenComparing(Dog::getWeight));
	dogList.forEach(System.out::println);
}

說(shuō)明1： 這里按照三個(gè)條件排序是指如果姓名相同了，再按照下一個(gè)排序，以此類推，所以你可能看不出來(lái)差別（這個(gè)結(jié)果和按照姓名排序一樣，主要是排序的數(shù)據(jù)不太適合，但我不想換了。）。

說(shuō)明2： 你仍然可以繼續(xù)添加更多的排序規(guī)則，因?yàn)?thenComparing 方法也有重載的方法。

運(yùn)行結(jié)果：

thenComparing 方法的重載方法源碼：

 default <U> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
 {
     return thenComparing(comparing(keyExtractor, keyComparator));
 }

它的第二個(gè)方法，也和上面的 comparing 方法作用相同，是自己實(shí)現(xiàn)一個(gè)key的比較器，這里就不再說(shuō)明了。

適用于 Int、long 和 double 類型的 thenComapring 方法

default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
    return thenComparing(comparingInt(keyExtractor));
}
  
default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
    return thenComparing(comparingLong(keyExtractor));
}  

default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
    return thenComparing(comparingDouble(keyExtractor));
}

說(shuō)明：這幾個(gè)方法和上面的 thenComparing 方法作用基本相同，但是更加適合處理 int、long和double類型。如果需要排序的類型為這幾個(gè)，使用這些方法很好，但是我還是喜歡通用的 thenComparing 方法，這里只演示一個(gè) thenComparingDouble 方法：

static void thenComparingDouble() {
	List<Dog> dogList = new ArrayList<>();
	dogList.add(new Dog("小黑", 3, 37.0));
	dogList.add(new Dog("二哈", 2, 55.0));
	dogList.add(new Dog("泰迪", 1, 8.0));
	dogList.add(new Dog("大黃", 2, 40.0));
	
	dogList.sort(Comparator
			.comparing(Dog::getAge)
			.thenComparingDouble(Dog::getWeight));
	dogList.forEach(System.out::println);
}

運(yùn)行結(jié)果：

如果去掉 thenComparingDouble 方法，運(yùn)行結(jié)果為：
注意和上面的結(jié)果對(duì)比。

適用于 Int、long 和 double 類型的 comapring 方法

這三個(gè)方法，也是專門用于處理 int、long 和double類型的，和使用 comparing方法差不多。

public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
    return (Comparator<T> & Serializable)
        (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
}

 public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) {
     Objects.requireNonNull(keyExtractor);
     return (Comparator<T> & Serializable)
         (c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
 }

public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {
    Objects.requireNonNull(keyExtractor);
    return (Comparator<T> & Serializable)
        (c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
}

這里演示 comparingInt 和 comparingDouble 兩個(gè)方法的用法：
我感覺沒什么區(qū)別，可能是我這個(gè)測(cè)試用例太簡(jiǎn)單了吧。

/**
 * comparingToInt
 * */
static void comparingToInt(List<? extends Dog> dogList) {
	dogList.sort(Comparator.comparingInt(Dog::getAge));
	dogList.forEach(System.out::println);
}

/**
 * comparingToDouble
 * */
static void comparingToDouble(List<? extends Dog> dogList) {
	dogList.sort(Comparator.comparingDouble(Dog::getWeight));
	dogList.forEach(System.out::println);
}

對(duì)于集合中含有 null 值元素的排序

static void nullSort() {
		List<String> strList = new ArrayList<>();
		strList.add("dog");
		strList.add("cat");
		strList.add(null);
		strList.add("Bird");
		strList.add(null);
		
		strList.sort(Comparator.comparing(String::length));
		strList.forEach(System.out::println);
	}

運(yùn)行上面的代碼，結(jié)果為：

說(shuō)明：null 值是一個(gè)很頭疼的問(wèn)題，所以 Comparator接口也專門提供了處理null值得方法，它們都是對(duì) null 值友好的方法（null-friendly）。

//null 值在前面。
//Returns a null-friendly comparator that considers null to be less than non-null.
 public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
     return new Comparators.NullComparator<>(true, comparator);
 }

//null 值在后面。
//Returns a null-friendly comparator that considers null to be greater than non-null.
public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
    return new Comparators.NullComparator<>(false, comparator);
}

因此，對(duì)于含有null值的元素進(jìn)行排序，可以這樣做：

/**
 * 含有 null 值得元素排序
 * */
public static void nullValueSort() {
	List<String> strList = new ArrayList<>();
	strList.add("dog");
	strList.add("cat");
	strList.add(null);
	strList.add("Bird");
	strList.add(null);
	//我一開始以為是一個(gè)字符常量呢？但是一想不對(duì)勁，原來(lái)是一個(gè)靜態(tài)常量比較器。
	//這個(gè)是 String 類的比較器：CASE_INSENSITIVE_ORDER
	//null 值在前排序
	strList.sort(Comparator.nullsFirst(String.CASE_INSENSITIVE_ORDER));
	strList.forEach(System.out::println);
	System.out.println("===================分隔符====================");
	//null 值在后排序
	strList.sort(Comparator.nullsLast(String.CASE_INSENSITIVE_ORDER));
	strList.forEach(System.out::println);
}

運(yùn)行結(jié)果：
注：擺脫了，煩人的NullPointerException，哈哈。

接口中其它方法

reversed方法

in other words, it returns a comparator that imposes the reverse of the natural ordering on a collection of objects that implement the Comparable interface。
換言之，它返回一個(gè)比較器，該比較器對(duì)實(shí)現(xiàn)可比較接口的對(duì)象集合施加與自然順序相反的順序。

說(shuō)明： 由于它是默認(rèn)方法，所以必須由比較器對(duì)象本身來(lái)調(diào)用，正好可以實(shí)現(xiàn)逆序操作。可以在創(chuàng)建比較器后繼續(xù)調(diào)用這個(gè)方法，就可以實(shí)現(xiàn)逆序了。但是要注意它調(diào)用的順序，它和下面這個(gè) reverseOrder 方法還是不一樣的，下面這個(gè)方法是靜態(tài)方法，可以通過(guò)類直接調(diào)用。注意，用法上的區(qū)別就是了。

 default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
 }

reverseOrder 方法

public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
    return Collections.reverseOrder();
}

如果直接使用這個(gè)方法，創(chuàng)建比較器對(duì)象的話，那么集合里面的元素必須使用 Comparable 接口。

static void reverseSort() {
	List<String> strList = new ArrayList<>();
	strList.add("dog");
	strList.add("cat");
	strList.add("Bird");
	
	strList.sort(Comparator.reverseOrder());
	strList.forEach(System.out::println);
}

注意：這里有一個(gè)很有趣的地方，這個(gè)方法Comparator.reverseOrder()無(wú)法使用方法引用改寫：Comparator::reverseOrder，具體原因我看了，但是不是太理解，就不說(shuō)了。

運(yùn)行結(jié)果：

補(bǔ)充： 晚上思考了一下，結(jié)合別人的答案，這里其實(shí)也是不難理解的。自所以不能使用方法引用，是因?yàn)樗揪筒皇?lambda 表達(dá)式。Lambda 表達(dá)式需要依賴一個(gè)函數(shù)式接口，也就是 Comparator 接口。它的作用就是一個(gè)簡(jiǎn)化，所以它的需要的參數(shù)就是 int compare(T o1, T o2); 的方法中的參數(shù)。

所以，如果這樣寫的話，會(huì)報(bào)一個(gè)錯(cuò)誤。
The type Comparator does not define reverseOrder(String, String) that is applicable here

strList.sort(Comparator::reverseOrder);

因此，上面這個(gè)寫法就是錯(cuò)誤的了。它并不能使用lambda的形式改寫。

reverseOrder 和 reversed聯(lián)合使用

	static void reverseSort() {
		List<String> strList = new ArrayList<>();
		strList.add("dog");
		strList.add("cat");
		strList.add("Bird");
		
		Comparator c = Comparator.reverseOrder().reversed();
		strList.sort(c);
		strList.forEach(System.out::println);
	}

說(shuō)明：上面這個(gè)例子我不會(huì)添加泛型了，我無(wú)論怎么添加都是錯(cuò)誤的，但是如果不添加泛型的話，那么編譯就能通過(guò)了。但是這個(gè)東西的泛型似乎很奇怪，我也不太明白了，但是這個(gè)方法很有趣，反序的反序又是正序了。（這里存粹是娛樂(lè)一下，但是好像發(fā)現(xiàn)了好玩的東西。）

運(yùn)行結(jié)果：

naturalOrder

定制排序里面居然有一個(gè)方法名叫做自然排序，這個(gè)方法感覺很有趣。但是使用的話，需要抑制一下 unchecked 警告。

@SuppressWarnings("unchecked")
public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
    return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
}

方法注釋里面說(shuō)明了：

@param  <T> the {@link Comparable} type of element to be compared。

參數(shù)必須是 Comparable類型的，即實(shí)現(xiàn) Comparable 接口。

自然排序：

/**
 * Comparator 實(shí)現(xiàn)自然排序
 * */
@SuppressWarnings("unchecked")
static void lambda6(List<? extends Dog> dogList) {
	dogList.sort((Comparator<Dog>) Comparator.naturalOrder());
	dogList.forEach(System.out::println);
}

如果直接運(yùn)行這個(gè)方法會(huì)產(chǎn)生問(wèn)題，必須要先實(shí)現(xiàn) Comparable接口才行，并重寫 compareTo方法。

@Override
public int compareTo(Dog o) {
	return age-o.age;
}

運(yùn)行結(jié)果：

以上就是關(guān)于“怎么使用Lambda表達(dá)式簡(jiǎn)化Comparator的使用問(wèn)題”這篇文章的內(nèi)容，相信大家都有了一定的了解，希望小編分享的內(nèi)容對(duì)大家有幫助，若想了解更多相關(guān)的知識(shí)內(nèi)容，請(qǐng)關(guān)注億速云行業(yè)資訊頻道。