Java利器：Pair和Triple無縫解決多值返回，編寫高效代碼！
在日常的 Java 編碼實踐里，我們常常會碰到一個方法需要返回多個值的情況。比如，在處理某個操作時，我們不僅要返回操作的結果，還得帶上一些與之相關的附加信息。傳統(tǒng)的做法是創(chuàng)建一個自定義類來封裝這些信息，或者使用集合（像 Map）來存儲這些值。然而，這樣做往往會讓代碼變得臃腫復雜，調用方在理解和提取這些值時也會感到頗為棘手。
這時，org.apache.commons.lang3.tuple 包下的 Pair 和 Triple 及其子類就成了絕佳的解決方案。它們?yōu)槲覀兲峁┝艘环N清晰、簡潔的方式來組織和傳遞多個相關聯的值，讓代碼變得更加直觀易懂。
引入依賴
在使用 Pair 和 Triple 之前，我們需要在項目中引入 Apache Commons Lang3 庫的依賴。在 Maven 項目里，只需在 pom.xml 文件中添加以下依賴即可：
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version>
</dependency>Pair 類：便捷的鍵值對容器
Pair 類概述
Pair 類是 Apache Commons Lang3 庫提供的一個抽象類，用于表示簡單的鍵值對。它實現了 Map.Entry 接口，這意味著它可以在各種集合中使用；同時，它還實現了 Comparable 接口，方便我們比較兩個 Pair 對象的大小；并且支持對象的序列化和反序列化。
下面是 Pair 類的部分源碼：
/**
* 抽象類，表示簡單的鍵值對。
* 實現了 Map.Entry 接口，支持在各種集合中使用。
* 實現了 Comparable 接口，用于比較兩個 Pair 對象的大小。
* 可序列化，支持對象的序列化和反序列化。
*
* @param <L> 左值的類型
* @param <R> 右值的類型
*/
publicabstractclass Pair<L, R> implements Map.Entry<L, R>, Comparable<Pair<L, R>>, Serializable {
privatestaticfinallong serialVersionUID = 4954918890077093841L;
// 空數組，用于表示空的 Pair 對象數組
publicstaticfinal Pair<?, ?>[] EMPTY_ARRAY = new PairAdapter[0];
/**
* 返回一個空的 Pair 數組。
*
* @return 空的 Pair 數組
*/
publicstatic <L, R> Pair<L, R>[] emptyArray() {
return (Pair[]) EMPTY_ARRAY;
}
/**
* 靜態(tài)工廠方法，創(chuàng)建一個新的 ImmutablePair 對象，表示給定的左右值的鍵值對。
*
* @param left 左值
* @param right 右值
* @param <L> 左值的類型
* @param <R> 右值的類型
* @return ImmutablePair 對象
*/
publicstatic <L, R> Pair<L, R> of(L left, R right) {
return ImmutablePair.of(left, right);
}
/**
* 靜態(tài)工廠方法，創(chuàng)建一個新的 ImmutablePair 對象，表示給定 Map.Entry 對象的鍵值對。
*
* @param pair Map.Entry 對象
* @param <L> 左值的類型
* @param <R> 右值的類型
* @return ImmutablePair 對象
*/
publicstatic <L, R> Pair<L, R> of(Map.Entry<L, R> pair) {
return ImmutablePair.of(pair);
}
/**
* 返回左值，實現了 Map.Entry 接口。
*
* @return 左值
*/
public final L getKey() {
returnthis.getLeft();
}
/**
* 抽象方法，由子類實現，用于獲取左值。
*
* @return 左值
*/
public abstract L getLeft();
/**
* 抽象方法，由子類實現，用于獲取右值。
*
* @return 右值
*/
public abstract R getRight();
/**
* 返回右值，實現了 Map.Entry 接口。
*
* @return 右值
*/
public R getValue() {
returnthis.getRight();
}
}Pair 類有兩個重要的子類：ImmutablePair 和 MutablePair，下面我們來詳細了解一下這兩個子類。
MutablePair：可變的鍵值對
MutablePair 是一個可變的鍵值對類，它允許我們在創(chuàng)建后動態(tài)修改鍵和值，這為我們的編程帶來了更大的靈活性。不過需要注意的是，它是非線程安全的，在多線程環(huán)境下使用時需要格外小心。
我們可以通過以下幾種方式來構造 MutablePair 對象：
圖片
同時，MutablePair 還提供了一些方法來修改和獲取鍵值：
圖片
需要注意的是，MutablePair 的 left 和 right 成員變量是 public 的，我們也可以直接訪問它們來獲取值。
ImmutablePair：不可變的鍵值對
ImmutablePair 是 Pair 的一個不可變子類，一旦創(chuàng)建完成，其鍵和值就不能再被改變，這使得它是線程安全的，適合在多線程環(huán)境下使用。
下面是 ImmutablePair 的構造方式：
圖片
ImmutablePair 提供了獲取鍵值的方法：
// 獲取左值
public L getLeft();
// Pair 中的方法，獲取左值
public final L getKey();
// 獲取右值
public R getRight();
// Pair 中的方法，獲取右值
public R getValue();同樣，ImmutablePair 的 left 和 right 成員變量是 public 的，我們可以直接訪問它們。
為什么 ImmutablePair 是不可變的且線程安全呢？原因在于它的左值和右值成員變量被聲明為 final，一旦初始化就不能再被修改。并且，調用它的 setValue 方法會拋出 UnsupportedOperationException 異常。
public final L left;
public final R right;
public R setValue(R value) {
throw new UnsupportedOperationException();
}Pair 使用示例
class UserDO {
private String userId;
private Integer age;
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
圖片
在上述示例中，我們可以看到 ImmutablePair 在嘗試修改值時會拋出異常，這體現了它的不可變性。
Triple 類：強大的三元組工具
Triple 類概述
Triple 是一個用于表示三元組的抽象類。三元組是由三個元素組成的有序集合，分別稱為左值（Left）、中間值（Middle）和右值（Right）。Triple 類為我們提供了一種便捷的方式來組織和處理這種具有固定順序的數據，讓我們可以在不創(chuàng)建專門類的情況下輕松返回三個值，減少了創(chuàng)建和維護多個變量的復雜性，使代碼更加簡潔。
下面是 Triple 類的部分源碼：
/**
* 表示包含三個元素的三元組的抽象類 Triple。
*
* 該類是一個抽象實現，定義了基本的 API，將元素分別稱為 'left'、'middle' 和 'right'。
*
* 子類的實現可以是可變的或不可變的。對存儲的對象類型沒有限制。
* Triple 對象的可變性取決于其中存儲的對象是否是可變的。如果存儲的是可變對象，那么 Triple 本身也就變得可變，因為存儲的對象狀態(tài)可以被修改。
* 如果存儲的是不可變對象，那么 Triple 對象在創(chuàng)建后就保持不可變。
*
*/
publicabstractclass Triple<L, M, R> implements Comparable<Triple<L, M, R>>, Serializable {
/**
* 一個空數組。
*/
publicstaticfinal Triple<?, ?, ?>[] EMPTY_ARRAY = new TripleAdapter[0];
/**
* 返回可分配而無需編譯器警告的空數組單例。
*
*/
@SuppressWarnings("unchecked")
publicstatic <L, M, R> Triple<L, M, R>[] emptyArray() {
return (Triple<L, M, R>[]) EMPTY_ARRAY;
}
/**
* 獲取由三個對象組成的不可變三元組，推斷出泛型類型。
*
* 此工廠方法允許使用推斷類型來創(chuàng)建三元組以獲取泛型類型。
*
* @param left 左元素，可以為 null
* @param middle 中間元素，可以為 null
* @param right 右元素，可以為 null
* @return 由三個參數形成的三元組，非 null
*/
publicstatic <L, M, R> Triple<L, M, R> of(final L left, final M middle, final R right) {
returnnew ImmutableTriple<>(left, middle, right);
}
/**
* 獲取此三元組的左元素。
*
* @return 左元素，可以為 null
*/
public abstract L getLeft();
/**
* 獲取此三元組的中間元素。
*
* @return 中間元素，可以為 null
*/
public abstract M getMiddle();
/**
* 獲取此三元組的右元素。
*
* @return 右元素，可以為 null
*/
public abstract R getRight();
}Triple 類有兩個子類：可變的 MutableTriple 和不可變的 ImmutableTriple。
MutableTriple：可變的三元組
MutableTriple 是可變的三元組類，它提供了公共的設置（set）方法，允許我們在創(chuàng)建后修改其內部值。具體來說，MutableTriple 提供了 setLeft、setMiddle 和 setRight 方法，使得我們可以在對象創(chuàng)建后修改左、中、右元素的值。需要注意的是，MutableTriple 是非線程安全的。
下面是 MutableTriple 的部分源碼：
/**
* 表示由三個 {@code Object} 元素組成的可變三元組。
*
* 非線程安全
*
*/
publicclass MutableTriple<L, M, R> extends Triple<L, M, R> {
/**
* 通過推斷泛型類型獲取三個對象的可變三元組。
*
* 該工廠允許通過推斷泛型類型創(chuàng)建三元組。
*
*/
publicstatic <L, M, R> MutableTriple<L, M, R> of(final L left, final M middle, final R right) {
returnnew MutableTriple<>(left, middle, right);
}
/** 左對象 */
public L left;
/** 中間對象 */
public M middle;
/** 右對象 */
public R right;
/**
* 創(chuàng)建一個新的三元組實例，包含三個 null 值。
*/
public MutableTriple() {
}
/**
* 創(chuàng)建一個新的三元組實例。
*
* @param left 左值，可以為 null
* @param middle 中間值，可以為 null
* @param right 右值，可以為 null
*/
public MutableTriple(final L left, final M middle, final R right) {
this.left = left;
this.middle = middle;
this.right = right;
}
/**
* 設置三元組的左元素。
*/
public void setLeft(final L left) {
this.left = left;
}
/**
* 設置三元組的中間元素。
*/
public void setMiddle(final M middle) {
this.middle = middle;
}
/**
* 設置三元組的右元素。
*/
public void setRight(final R right) {
this.right = right;
}
}ImmutableTriple：不可變的三元組
ImmutableTriple 是一個不可變的三元組類，由三個泛型元素（left、middle、right）組成。一旦創(chuàng)建，其狀態(tài)就無法修改，因此它是線程安全的。不過需要注意的是，如果存儲在三元組中的對象是可變的，那么三元組本身實際上就不再是不可變的。
下面是 ImmutableTriple 的部分源碼：
/**
* 一個由三個元素組成的不可變三元組。
*
* ImmutableTriple 是一個最終類，被設計成不可變的，即在實例化后其狀態(tài)不可更改。
* 如果存儲在三元組中的三個對象都是線程安全的，則該類是線程安全的。類的最終性防止了子類化，確保不會添加不希望的行為。
*
* 線程安全的 如果三個對象都是線程安全的
*
*/
publicfinalclass ImmutableTriple<L, M, R> extends Triple<L, M, R> {
/**
* 返回可以在不觸發(fā)編譯器警告的情況下分配的空數組單例。
* @return 可以在不觸發(fā)編譯器警告的情況下分配的空數組單例。
*/
@SuppressWarnings("unchecked")
publicstatic <L, M, R> ImmutableTriple<L, M, R>[] emptyArray() {
return (ImmutableTriple<L, M, R>[]) EMPTY_ARRAY;
}
/**
* 返回一個由 null 組成的不可變三元組。
*
* @return 一個由 null 組成的不可變三元組。
*/
publicstatic <L, M, R> ImmutableTriple<L, M, R> nullTriple() {
return NULL;
}
/**
* 通過推斷泛型類型獲得由三個對象組成的不可變三元組。
*
* 此工廠允許使用推斷創(chuàng)建三元組以獲得泛型類型。
*
* @return 由三個參數形成的不可變三元組，不為 null
*/
publicstatic <L, M, R> ImmutableTriple<L, M, R> of(final L left, final M middle, final R right) {
returnnew ImmutableTriple<>(left, middle, right);
}
/** 左對象 */
publicfinal L left;
/** 中間對象 */
publicfinal M middle;
/** 右對象 */
publicfinal R right;
/**
* 構造方法 創(chuàng)建一個新的三元組實例。
*
*/
public ImmutableTriple(final L left, final M middle, final R right) {
this.left = left;
this.middle = middle;
this.right = right;
}
}Triple 使用示例
class UserDO {
private String userId;
private String userName;
private Integer sex;
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public Integer getSex() {
return sex;
}
public void setSex(Integer sex) {
this.sex = sex;
}
}
圖片
總結
通過使用 Pair 和 Triple 類，我們可以顯著簡化代碼，提高代碼的可讀性。它們讓關聯數據更加清晰明了，同時保持了類型安全，增強了代碼的清晰度和擴展性。
此外，這些類還提供了豐富的功能，使開發(fā)人員能夠更高效地處理相關數據，編寫出更簡潔、易讀的代碼，從而提升代碼質量和開發(fā)效率。希望大家在今后的 Java 開發(fā)中能夠充分利用這些實用的工具類。
