關(guān)于使用Lambda表達(dá)式簡(jiǎn)化Comparator的使用問題
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ì)疑問排序順序到底是正序還是逆序呢？
* */
static void lambda3(List<? extends Dog> dogList) {
dogList.sort(Comparator.comparing(Dog::getAge));
dogList.forEach(System.out::println);
}
說(shuō)明： 通過上面的源碼可以看到，c1 和 c2 的位置是固定的（排序是固定的升序方式），它是通過 Function 接口，調(diào)用apply方法，生成一個(gè)對(duì)象，然后調(diào)用 compareTo 方法進(jìn)行比較的。（例如，我們傳進(jìn)去的是age，類型為int，但是通過apply會(huì)返回 Integer類型。因?yàn)榘b類型和 String 類都實(shí)現(xiàn)了 Comparable 接口。）
注意： 如果不使用方法引用的話，那么 Dog::getAge 應(yīng)該被替換為：
(dog1, dog2)->dog1.getAge() - dog2.getAge()
不過，這樣做顯然就是去了簡(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 中的疑問，關(guā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è)變換順序的問題，所以它也提
* 供了簡(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è)很頭疼的問題，所以 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)方法，可以通過類直接調(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ò)誤的，但是如果不添加泛型的話，那么編譯就能通過了。但是這個(gè)東西的泛型似乎很奇怪，我也不太明白了，但是這個(gè)方法很有趣，反序的反序又是正序了。（這里存粹是娛樂一下，但是好像發(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)生問題，必須要先實(shí)現(xiàn) Comparable接口才行，并重寫 compareTo方法。
@Override
public int compareTo(Dog o) {
return age-o.age;
}
運(yùn)行結(jié)果：
說(shuō)明：不太明白，安排這個(gè)方法的目的何在，感覺很奇怪。
總結(jié)
大致介紹了一下 Comparator 接口中的方法，并寫了很多演示方法。寫這篇博客的起因是我用到 Comparator 接口的時(shí)候，感覺似乎有很多豐富的方法，似乎怎么寫都行（哈哈），所以干脆一勞永逸，抽時(shí)間看一看這個(gè) Comparator 到底怎么寫，發(fā)現(xiàn)確實(shí)是很有趣的。
到此這篇關(guān)于關(guān)于使用Lambda表達(dá)式簡(jiǎn)化Comparator的使用問題的文章就介紹到這了,更多相關(guān)Lambda表達(dá)式簡(jiǎn)化Comparator內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章主要介紹了Java中的snowflake算法詳解,Snowflake算法產(chǎn)生是為了滿足Twitter每秒上萬(wàn)條消息的請(qǐng)求,每條消息都必須分配一條唯一的id,這些id還需要一些大致的順序,并且在分布式系統(tǒng)中不同機(jī)器產(chǎn)生的id必須不同,需要的朋友可以參考下2023-08-08
swagger注解@ApiModelProperty失效情況的解決
這篇文章主要介紹了swagger注解@ApiModelProperty失效情況的解決方案，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教2022-06-06
插入排序(InsertionSort)，一般也被稱為直接插入排序。對(duì)于少量元素的排序，它是一個(gè)有效的算法。插入排序是一種最簡(jiǎn)單的排序方法，它的基本思想是將一個(gè)記錄插入到已經(jīng)排好序的有序表中，從而一個(gè)新的、記錄數(shù)增 1 的有序表2021-11-11
Java線程安全的計(jì)數(shù)器簡(jiǎn)單實(shí)現(xiàn)代碼示例
這篇文章主要介紹了Java線程安全的計(jì)數(shù)器簡(jiǎn)單實(shí)現(xiàn)代碼示例，具有一定參考價(jià)值，需要的朋友可以了解下。2017-10-10
關(guān)于Java?中?Future?的?get?方法超時(shí)問題
這篇文章主要介紹了Java?中?Future?的?get?方法超時(shí),最常見的理解就是，“超時(shí)以后，當(dāng)前線程繼續(xù)執(zhí)行，線程池里的對(duì)應(yīng)線程中斷”，真的是這樣嗎？本文給大家詳細(xì)介紹，需要的朋友參考下吧2022-06-06
Java反射機(jī)制在Spring IOC中的應(yīng)用詳解
這篇文章主要介紹了Java反射機(jī)制在Spring IOC中的應(yīng)用，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教2021-09-09
java實(shí)現(xiàn)發(fā)送email小案例
這篇文章主要為大家詳細(xì)介紹了java實(shí)現(xiàn)發(fā)送email小案例，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下2020-02-02
這篇文章主要介紹了Java創(chuàng)建線程方法，文中通過示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧2019-04-04
Spring實(shí)戰(zhàn)之ResourceLoader接口資源加載用法示例
這篇文章主要介紹了Spring實(shí)戰(zhàn)之ResourceLoader接口資源加載用法,結(jié)合實(shí)例形式分析了Spring使用ResourceLoader接口加載資源的相關(guān)配置與使用技巧,需要的朋友可以參考下2020-01-01
這篇文章主要介紹了IDEA 端口占用的解決方法,本文通過兩種方法給大家介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值，需要的朋友可以參考下2020-10-10