Java程式設計的利器：Pair和Triple無縫解決多值返回問題，助力編寫高效程式碼

在實際編碼中，經常會遇到一個方法需要返回多個值的情況，你編寫一個方法，需要同時返回某個操作的結果和一些相關的附加資訊。使用傳統的方式，你可能需要建立一個包含這些資訊的自定義類或者使用集合（如 Map）來儲存這些值。然而，這往往使得程式碼變得臃腫，而且對於呼叫方來說，理解和提取這些值可能會顯得有些繁瑣。

這時使用org.apache.commons.lang3.tuple下的Pair 或 Triple 及其子類是一種非常便捷的解決方案。這些類提供了一種清晰、簡單的方式來組織和傳遞多個相關聯的值，使得程式碼更加直觀和易於理解。

使用 Pair 或 Triple 就能輕鬆解決這個問題。你可以在一個方法中返回一個 Pair 或 Triple 物件，其中包含你想要傳遞的多個值。這樣，你可以清晰地表示這些值之間的關係，而且呼叫方可以輕鬆地訪問和使用這些值，而無需繁瑣的解包過程。

在接下來的部分，我們將深入研究如何在這類場景中使用 Pair 和 Triple 及其子類，以及它們如何簡化我們在編碼中常遇到的多值返回問題。

引入依賴：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

Pair 類介紹

Pair 類是org.apache.commons.lang3庫提供的一個簡單的鍵值對容器，用於表示兩個相關聯的值。其主要作用是將兩個值組織在一起，提供一種便捷的方式進行傳遞和處理。

首先我們來看一下Pair的原始碼：

/**
 * 抽象類，表示簡單的鍵值對。
 * 實現了 Map.Entry 介面，支援在各種集合中使用。
 * 實現了 Comparable 介面，用於比較兩個 Pair 物件的大小。
 * 可序列化，支援物件的序列化和反序列化。
 *
 * @param <L> 左值的型別
 * @param <R> 右值的型別
 */
public abstract class Pair<L, R> implements Map.Entry<L, R>, Comparable<Pair<L, R>>, Serializable {

    private static final long serialVersionUID = 4954918890077093841L;

    // 空陣列，用於表示空的 Pair 物件陣列
    public static final Pair<?, ?>[] EMPTY_ARRAY = new PairAdapter[0];

    /**
     * 返回一個空的 Pair 陣列。
     *
     * @return 空的 Pair 陣列
     */
    public static <L, R> Pair<L, R>[] emptyArray() {
        return (Pair[]) EMPTY_ARRAY;
    }

    /**
     * 靜態工廠方法，建立一個新的 ImmutablePair 物件，表示給定的左右值的鍵值對。
     *
     * @param left  左值
     * @param right 右值
     * @param <L>   左值的型別
     * @param <R>   右值的型別
     * @return ImmutablePair 物件
     */
    public static <L, R> Pair<L, R> of(L left, R right) {
        return ImmutablePair.of(left, right);
    }

    /**
     * 靜態工廠方法，建立一個新的 ImmutablePair 物件，表示給定 Map.Entry 物件的鍵值對。
     *
     * @param pair Map.Entry 物件
     * @param <L>  左值的型別
     * @param <R>  右值的型別
     * @return ImmutablePair 物件
     */
    public static <L, R> Pair<L, R> of(Map.Entry<L, R> pair) {
        return ImmutablePair.of(pair);
    }

    /**
     * 返回左值，實現了 Map.Entry 介面。
     *
     * @return 左值
     */
    public final L getKey() {
        return this.getLeft();
    }

    /**
     * 抽象方法，由子類實現，用於獲取左值。
     *
     * @return 左值
     */
    public abstract L getLeft();

    /**
     * 抽象方法，由子類實現，用於獲取右值。
     *
     * @return 右值
     */
    public abstract R getRight();

    /**
     * 返回右值，實現了 Map.Entry 介面。
     *
     * @return 右值
     */
    public R getValue() {
        return this.getRight();
    }
}

Pair類是一個抽象類，它有兩個子類ImmutablePair和MutablePair。接下來我們介紹一下這兩個子類，也是我們要使用的兩個類。

MutablePair

MutablePair是一個可變的。它允許在建立後動態修改鍵和值，提供了更大的靈活性。但是它是執行緒不安全的。
我們可以根據它提供的幾個靜態方法或者它的構造器去構造一個MutablePair:

// 靜態工廠方法，返回一個空的 MutablePair
public static <L, R> MutablePair<L, R>[] emptyArray();

// 靜態工廠方法，傳入給定的左右值的鍵值對，建立並返回一個MutablePair 物件
public static <L, R> MutablePair<L, R> of(L left, R right);

// 靜態工廠方法，傳入給定 Map.Entry 物件的鍵值對，建立並返回一個新的MutablePair 物件
public static <L, R> MutablePair<L, R> of(Map.Entry<L, R> pair);

// 無參構造器
public MutablePair()

// 指定左右值的鍵值對的構造器
public MutablePair(L left, R right)

我們可以根據它的幾個方法修改鍵和值：

// 修改左值
public void setLeft(L left);

// 修改右值
public void setRight(R right);

// 修改新的右值，並返回之前的右值。
public R setValue(R value);

我們可以根據它的幾個方法獲取鍵和值：

// 獲取左值
public L getLeft();

// Pair中的方法  獲取左值
public final L getKey();

// 獲取右值
public R getRight();

// Pair中的方法  獲取右值 
public R getValue();

當然我們看到它的left以及right都是public的。所以我們也可以直接取值，不用使用它的get方法。

ImmutablePair

ImmutablePair是Pair的一個不可變的子類。它在建立完成之後，不允許改變鍵和值。它是執行緒安全的。

我們可以看一下它如何進行構造的：

// 靜態工廠方法，返回一個空的 ImmutablePair 陣列。
public static <L, R> ImmutablePair<L, R>[] emptyArray();

// 靜態工廠方法，返回一個包含 null 左值和 null 右值的 ImmutablePair 物件，表示空值。
public static <L, R> ImmutablePair<L, R> nullPair();

// 靜態工廠方法，返回一個包含指定左值和 null 右值的 ImmutablePair 物件。
public static <L, R> Pair<L, R> left(L left);

// 靜態工廠方法，返回一個包含 null 左值和指定右值的 ImmutablePair 物件。
public static <L, R> Pair<L, R> right(R right);

// 靜態工廠方法，建立並返回一個新的 ImmutablePair 物件，表示給定的左右值的鍵值對。
public static <L, R> ImmutablePair<L, R> of(L left, R right);

// 靜態工廠方法，建立並返回一個新的 ImmutablePair 物件，表示給定 Map.Entry 物件的鍵值對。
public static <L, R> ImmutablePair<L, R> of(Map.Entry<L, R> pair);

// 有參構造器 傳入給定的左右值的鍵值對。
public ImmutablePair(L left, R right);

我們可以根據它的幾個方法獲取鍵和值：

// 獲取左值
public L getLeft();

// Pair中的方法  獲取左值
public final L getKey();

// 獲取右值
public R getRight();

// Pair中的方法  獲取右值 
public R getValue();

當然我們看到它的left以及right都是public的。所以我們也可以直接取值，不用使用它的get方法。

那我們再看一下為什麼ImmutablePair是不可變的，並且是執行緒安全的。
首先我們看一下它的左值以及右值都是final的，不可更改的。並且呼叫它的setValue會丟擲UnsupportedOperationException。

public final L left;  
public final R right;

public R setValue(R value) {  
    throw new UnsupportedOperationException();  
}

類中的 left 和 right 成員變數被宣告為 final，這意味著它們在物件建立後不能被修改，確保了執行緒安全性。ImmutablePair 被設計為不可變的鍵值對類，即一旦建立，其內容不可更改。這確保了在多執行緒環境中，不會有併發修改的問題。

使用示例

/**  
 * 返回MutablePair  
 * @param userDO  
 * @return  
 */  
private static MutablePair<String, Integer> handleUserInfo1(UserDO userDO){  
    return MutablePair.of(userDO.getUserId(), userDO.getAge());  
}  
  
/**  
 * 返回ImmutablePair  
 * @param userDO  
 * @return  
 */  
private static ImmutablePair<String, Integer> handleUserInfo2(UserDO userDO){  
    return ImmutablePair.of(userDO.getUserId(), userDO.getAge());  
}  
  
public static void main(String[] args) {  
    UserDO userDO = new UserDO();  
    userDO.setUserId("coderacademy");  
    userDO.setAge(35);  
  
    MutablePair<String, Integer> mutablePair = handleUserInfo1(userDO);  
    System.out.println(mutablePair.getLeft()+" MutablePair修改前："+ mutablePair.right);  
    mutablePair.setRight(40);  
    System.out.println(mutablePair.getLeft()+" MutablePair修改後："+ mutablePair.right);  
  
    ImmutablePair<String, Integer> immutablePair = handleUserInfo2(userDO);  
    System.out.println(mutablePair.getLeft()+" ImmutablePair修改前："+ mutablePair.right);  
    immutablePair.setValue(50);  
    System.out.println(mutablePair.getLeft()+" ImmutablePair修改後："+ mutablePair.right);  
}

執行結果，我們發現ImmutablePair在修改value時報錯：

Pair 類及其子類 ImmutablePair 和 MutablePair 是用於表示鍵值對的實用工具類。ImmutablePair 是不可變的、執行緒安全的，適用於安全共享；MutablePair 允許動態修改值，但不具備執行緒安全性，適用於單執行緒環境。它們在方法返回多個值時提供了簡便的解決方案，提高了程式碼的靈活性。

Triple介紹

Triple 是一個用於表示三元組的抽象類。三元組是由三個元素組成的有序集合，其中每個元素都有特定的位置，分別稱為左值（Left）、中間值（Middle）和右值（Right）。Triple 類提供了一種便捷的方式來組織和處理這種具有固定順序的資料。可以在不建立專門類的情況下輕鬆返回三個值。透過 Triple，開發者可以更方便地處理包含三個元素的資料，減少了建立和維護多個變數的複雜性，使程式碼更加簡潔。

我們來看一下Triple的原始碼：

/**
 * 表示包含三個元素的三元組的抽象類 Triple。
 *
 * 該類是一個抽象實現，定義了基本的 API，將元素分別稱為 'left'、'middle' 和 'right'。
 *
 * 子類的實現可以是可變的或不可變的。對儲存的物件型別沒有限制。
 * Triple 物件的可變性取決於其中儲存的物件是否是可變的。如果儲存的是可變物件，那麼 Triple 本身也就變得可變，因為儲存的物件狀態可以被修改。
 * 如果儲存的是不可變物件，那麼Triple 物件在建立後就保持不可變。
 *
 */
public abstract class Triple<L, M, R> implements Comparable<Triple<L, M, R>>, Serializable {

    /**
     * 一個空陣列。
     */
    public static final Triple<?, ?, ?>[] EMPTY_ARRAY = new TripleAdapter[0];

    /**
     * 返回可分配而無需編譯器警告的空陣列單例。
     *
     */
    @SuppressWarnings("unchecked")
    public static <L, M, R> Triple<L, M, R>[] emptyArray() {
        return (Triple<L, M, R>[]) EMPTY_ARRAY;
    }

    /**
     * 獲取由三個物件組成的不可變三元組，推斷出泛型型別。
     *
     * 此工廠方法允許使用推斷型別來建立三元組以獲取泛型型別。
     *
     * @param left   左元素，可以為 null
     * @param middle 中間元素，可以為 null
     * @param right  右元素，可以為 null
     * @return 由三個引數形成的三元組，非 null
     */
    public static <L, M, R> Triple<L, M, R> of(final L left, final M middle, final R right) {
        return new 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）方法，允許在建立後修改其內部值。具體來說，MutableTriple 提供了 setLeft、setMiddle 和 setRight 方法，使得在物件建立後可以修改左、中、右元素的值。

/**
 * 表示由三個 {@code Object} 元素組成的可變三元組。
 *
 * 非執行緒安全
 *
 */
public class MutableTriple<L, M, R> extends Triple<L, M, R> {


    /**
     * 透過推斷泛型型別獲取三個物件的可變三元組。
     *
     * 該工廠允許透過推斷泛型型別建立三元組。
     *
     */
    public static <L, M, R> MutableTriple<L, M, R> of(final L left, final M middle, final R right) {
        return new MutableTriple<>(left, middle, right);
    }

    /** 左物件 */
    public L left;
    /** 中間物件 */
    public M middle;
    /** 右物件 */
    public R right;

    /**
     * 建立一個新的三元組例項，包含三個 null 值。
     */
    public MutableTriple() {
    }

    /**
     * 建立一個新的三元組例項。
     *
     * @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;
    }
}

MutableTriple 被明確標記為非執行緒安全。

ImmutableTriple

ImmutableTriple 是一個不可變的三元組類，由三個泛型元素（left、middle、right）組成。不可變意味著一旦建立，其狀態無法修改。該類被設計為執行緒安全的，但需要注意，如果儲存在三元組中的物件是可變的，那麼三元組本身實際上就不再是不可變的。

/**
 * 一個由三個元素組成的不可變三元組。
 *
 * ImmutableTriple 是一個最終類，被設計成不可變的，即在例項化後其狀態不可更改。
 * 如果儲存在三元組中的三個物件都是執行緒安全的，則該類是執行緒安全的。類的最終性防止了子類化，確保不會新增不希望的行為。
 *
 * 執行緒安全的 如果三個物件都是執行緒安全的
 *
 */
public final class ImmutableTriple<L, M, R> extends Triple<L, M, R> {

    /**
     * 返回可以在不觸發編譯器警告的情況下分配的空陣列單例。
     * @return 可以在不觸發編譯器警告的情況下分配的空陣列單例。
     */
    @SuppressWarnings("unchecked")
    public static <L, M, R> ImmutableTriple<L, M, R>[] emptyArray() {
        return (ImmutableTriple<L, M, R>[]) EMPTY_ARRAY;
    }

    /**
     * 返回一個由 null 組成的不可變三元組。
     *
     * @return 一個由 null 組成的不可變三元組。
     */
    public static <L, M, R> ImmutableTriple<L, M, R> nullTriple() {
        return NULL;
    }

    /**
     * 透過推斷泛型型別獲得由三個物件組成的不可變三元組。
     *
     * 此工廠允許使用推斷建立三元組以獲得泛型型別。
     *
     * @return 由三個引數形成的不可變三元組，不為 null
     */
    public static <L, M, R> ImmutableTriple<L, M, R> of(final L left, final M middle, final R right) {
        return new ImmutableTriple<>(left, middle, right);
    }

    /** 左物件 */
    public final L left;
    /** 中間物件 */
    public final M middle;
    /** 右物件 */
    public final R right;

    /**
     * 構造方法 建立一個新的三元組例項。
     *
     */
    public ImmutableTriple(final L left, final M middle, final R right) {
        this.left = left;
        this.middle = middle;
        this.right = right;
    }
}

ImmutableTriple 被宣告為 final，表示不可繼承，確保不可變性。確保不會有子類新增或修改行為。然後類中的屬性 left、middle、right 被宣告為 final，表示它們在例項化後無法被修改。類中沒有提供修改元素的公共方法。ImmutableTriple 主張不可變性，不提供修改例項狀態的方法。當然如果儲存在三元組中的物件是可變的，則整個三元組就變得可變。這是因為雖然 ImmutableTriple 本身是不可變的，但如果儲存的物件是可變的，它們的狀態可能會發生變化。

類宣告中使用 #ThreadSafe# 標記，表示在儲存的三個物件都是執行緒安全的情況下，ImmutableTriple 是執行緒安全的。

示例

/**  
* 返回可變Truple  
* @param userDO  
* @return  
*/  
private static MutableTriple<String, Integer, UserDO> handleUserInfo1(UserDO userDO){  
	return MutableTriple.of(userDO.getUserId(), userDO.getSex(), userDO);  
}  
  
/**  
* 返回不可變Triple  
* @param userDO  
* @return  
*/  
private static ImmutableTriple<String, Integer, UserDO> handleUserInfo2(UserDO userDO){  
	return ImmutableTriple.of(userDO.getUserId(), userDO.getSex(), userDO);  
}  
  
  
public static void main(String[] args) {  
	UserDO userDO = new UserDO();  
	userDO.setUserId("coderacademy");  
	userDO.setUserName("碼農Academy");  
	userDO.setSex(1);  
	  
	MutableTriple<String, Integer, UserDO> mutableTriple = handleUserInfo1(userDO);  
	System.out.println("mutableTriple改變前的值：" + mutableTriple);  
	mutableTriple.setMiddle(2);  
	System.out.println("mutableTriple改變後的值：" + mutableTriple);  
	  
	ImmutableTriple<String, Integer, UserDO> immutableTriple = handleUserInfo2(userDO);  
	System.out.println("ImmutableTriple改變前的值：" + immutableTriple);  
	UserDO userFromTriple = immutableTriple.right;  
	userFromTriple.setSex(2);  
	System.out.println("ImmutableTriple改Right鍵值物件的值：" + immutableTriple);  
	// 因ImmutableTriple 不可變，無法透過set方法修改鍵值。
}

總結

使用 Pair 和 Triple 類可以簡化程式碼、提高可讀性，使關聯資料更清晰，保持型別安全，增強程式碼清晰度，提高擴充套件性，並提供豐富的功能，從而使開發人員更高效地處理相關資料，編寫更簡潔可讀的程式碼，提升程式碼質量和開發效率。

本文已收錄於我的個人部落格：碼農Academy的部落格，專注分享Java技術乾貨，包括Java基礎、Spring Boot、Spring Cloud、Mysql、Redis、Elasticsearch、中介軟體、架構設計、面試題、程式設計師攻略等