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

来源:https://www.cnblogs.com/coderacademy/p/18044476
-Advertisement-
Play Games

Pair和Triple類是commons-lang3庫提供的實用工具，可以方便地將多個值組合在一起，實現多個返回值的效果，提高了代碼的可讀性和可維護性，使得處理多值情景更加輕鬆。 ...


在實際編碼中，經常會遇到一個方法需要返回多個值的情況，你編寫一個方法，需要同時返回某個操作的結果和一些相關的附加信息。使用傳統的方式，你可能需要創建一個包含這些信息的自定義類或者使用集合（如 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時報錯：
image.png

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、中間件、架構設計、面試題、程式員攻略等


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 多線程系列(十二) -生產者和消費者模型
    一、簡介 在 Java 多線程編程中，還有一個非常重要的設計模式，它就是：生產者和消費者模型。 這種模型可以充分發揮 cpu 的多線程特性，通過一些平衡手段能有效的提升系統整體處理數據的速度，減輕系統負載，提高程式的效率和穩定性，同時實現模塊之間的解耦。 那什麼是生產者和消費者模型呢？ 簡單的說，生 ...
  • 使用 Java 在Excel中創建下拉列表
    下拉列表（下拉框）可以確保用戶僅從預先給定的選項中進行選擇，這樣不僅能減少數據輸入錯誤，還能節省時間提高效率。在MS Excel中，我們可以通過 “數據驗證” 提供的選項來創建下拉列表，但如果要在Java程式中通過代碼實現這一功能，可能需要藉助一些第三方庫。本文將分享兩種使用免費Java庫在Exce ...
  • 【自動化】使用PlayWright+代理IP實現多環境隔離
    Playwright是由微軟公司2020年初發佈的新一代自動化測試工具，相較於目前最常用的Selenium，它僅用一個API即可自動執行Chromium、Firefox、WebKit等主流瀏覽器自動化操作。 對各種開發語言也有非常好的支持。常用的NodeJs、Java、python都有支持，且有豐富 ...
  • 總結的Java知識點集合
    這是我讀大學時的Java知識點總結，還不全面，後續會逐漸增加完善。 知識點集合 實例變數 實例變數是指在類中聲明的變數，其值是針對類的每個實例而獨立存儲的。每個類的實例都有自己的一組實例變數，它們的值可以在對象創建時初始化，併在整個對象的生命周期中保持不變或者隨著對象的狀態而改變。 實例變數也被稱為 ...
  • 詳解Python中sys模塊的功能與應用
    本文分享自華為雲社區《深入Python：sys模塊的功能與應用詳解》，作者： 檸檬味擁抱。 在Python的標準庫中，sys 模塊是一個常用而強大的工具，它提供了與Python解釋器交互的函數和變數。本文將介紹sys模塊的一些常用函數和方法，並通過實際的代碼實例來解析它們的用法。 1. sys.ar ...
  • Python實現snap：對齊多張遙感影像的空間範圍
    本文介紹基於Python中ArcPy模塊，實現基於柵格圖像批量裁剪柵格圖像，同時對齊各個柵格圖像的空間範圍，統一其各自行數與列數的方法~ ...
  • 多線程系列(十一) -淺析併發讀寫鎖StampedLock
    一、摘要 在上一篇文章中，我們講到了使用ReadWriteLock可以解決多線程同時讀，但只有一個線程能寫的問題。 如果繼續深入的分析ReadWriteLock，從鎖的角度分析，會發現它有一個潛在的問題：如果有線程正在讀數據，寫線程準備修改數據的時候，需要等待讀線程釋放鎖後才能獲取寫鎖，簡單的說就是 ...
  • Java 21 終於對這些功能動刀了！！
    來源：https://medium.com/@benweidig 儘管 Java 是我使用過的向後相容程度最高的語言和環境之一，但始終存在功能棄用甚至刪除的可能性。Java 21 將棄用兩個功能，這就是我們今天要討論的內容。 推薦一個開源免費的 Spring Boot 實戰項目： https://g ...
一周排行
    -Advertisement-
    Play Games
  • WPF 已知問題 監聽 WMI 事件導致觸摸失效
    示例項目結構 在 Visual Studio 中創建一個 WinForms 應用程式後，項目結構如下所示： MyWinFormsApp/ │ ├───Properties/ │ └───Settings.settings │ ├───bin/ │ ├───Debug/ │ └───Release/ ...
  • [STAThread]特性
    [STAThread] 特性用於需要與 COM 組件交互的應用程式，尤其是依賴單線程模型（如 Windows Forms 應用程式）的組件。在 STA 模式下，線程擁有自己的消息迴圈，這對於處理用戶界面和某些 COM 組件是必要的。 [STAThread] static void Main(stri ...
  • UWP WinUI3 傳入 AddHandler 的 RoutedEventHandler 類型與事件所需不匹配將拋出參數異常
    在WinForm中使用全局異常捕獲處理 在WinForm應用程式中，全局異常捕獲是確保程式穩定性的關鍵。通過在Program類的Main方法中設置全局異常處理，可以有效地捕獲並處理未預見的異常，從而避免程式崩潰。 註冊全局異常事件 [STAThread] static void Main() { / ...
  • .NET 多版本 WinForm 開源控制項庫 SunnyUI
    前言 給大家推薦一款開源的 Winform 控制項庫，可以幫助我們開發更加美觀、漂亮的 WinForm 界面。 項目介紹 SunnyUI.NET 是一個基於 .NET Framework 4.0+、.NET 6、.NET 7 和 .NET 8 的 WinForm 開源控制項庫，同時也提供了工具類庫、擴展 ...
  • .net core8 使用Swagger（附當前源碼）
    說明 該文章是屬於OverallAuth2.0系列文章，每周更新一篇該系列文章（從0到1完成系統開發）。 該系統文章，我會儘量說的非常詳細，做到不管新手、老手都能看懂。 說明：OverallAuth2.0 是一個簡單、易懂、功能強大的許可權+可視化流程管理系統。 有興趣的朋友，請關註我吧(*^▽^*) ...
  • WPF 什麼時候 VisualTreeHelper.GetDescendantBounds 將返回無窮大
    一、下載安裝 1.下載git 必須先下載並安裝git，再TortoiseGit下載安裝 git安裝參考教程：https://blog.csdn.net/mukes/article/details/115693833 2.TortoiseGit下載與安裝 TortoiseGit，Git客戶端，32/6 ...
  • C# 開源教程帶你輕鬆掌握數據結構與演算法
    前言 在項目開發過程中，理解數據結構和演算法如同掌握蓋房子的秘訣。演算法不僅能幫助我們編寫高效、優質的代碼，還能解決項目中遇到的各種難題。 給大家推薦一個支持C#的開源免費、新手友好的數據結構與演算法入門教程：Hello演算法。 項目介紹 《Hello Algo》是一本開源免費、新手友好的數據結構與演算法入門 ...
  • 第22篇 生成proto文件bat腳本
    1.生成單個Proto.bat內容 @rem Copyright 2016, Google Inc. @rem All rights reserved. @rem @rem Redistribution and use in source and binary forms, with or with ...
  • 記一次 .NET某上位機視覺程式 卡死分析
    一：背景 1. 講故事 前段時間有位朋友找到我，說他的窗體程式在客戶這邊出現了卡死，讓我幫忙看下怎麼回事？dump也生成了，既然有dump了那就上 windbg 分析吧。 二：WinDbg 分析 1. 為什麼會卡死 窗體程式的卡死，入口門檻很低，後續往下分析就不一定了，不管怎麼說先用 !clrsta ...
  • 醫學DICOM文件與PACS系統進行數據傳輸
    前言 人工智慧時代，人臉識別技術已成為安全驗證、身份識別和用戶交互的關鍵工具。 給大家推薦一款.NET 開源提供了強大的人臉識別 API，工具不僅易於集成，還具備高效處理能力。 本文將介紹一款如何利用這些API，為我們的項目添加智能識別的亮點。 項目介紹 GitHub 上擁有 1.2k 星標的 C# ...
所有分類