Java泛型的實際應用

本篇內容介紹了“Java泛型的實際應用”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

Java有很多的高級特性，泛型是其中之一，泛型即參數化類型。關于泛型的概念，有很多文章都有介紹，這里就不再過多的介紹了。本文將從實戰的角度，來看看泛型在實際項目中的使用

1 泛型在框架中的使用

泛型在框架中及為常見，我們在使用各種框架的時候，都會使用到泛型，具體看下面的例子。

1.1 集合框架中使用泛型

這是最常見的泛型的使用場景，比如下面的代碼

List<String> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();

list1和list2雖然都是列表類型，但是列表里面存的數據可以是String，可以是Integer，也可以是自定義類型。集合中存放的數據，在定義的時候不能確定是什么類型，只有當使用集合時，才能確定放什么類型的數據。所以在集合的定義中，就用泛型來代表集合里面的數據。

1.2 fastjson框架中使用泛型

alibaba的fastjson很多人應該都用過，fastjson很多地方也用到了泛型，比如將json字符串轉成對象，如下的例子

// 將userStr字符串映射成UserDto類
String userStr = "{id: '123', name: '張三'}";
UserDto userDto = JSON.parseObject(userStr, UserDto.class);

JSON類中，對parseObject方法的定義，如下

public static <T> T parseObject(String text, Class<T> clazz) {
    return parseObject(text, clazz);
}

parseObject方法中的參數傳遞用到了泛型，要把json字符串轉成什么類，在定義的時候并不知道，只有在用到的時候，才知道具體的類型。

1.3 泛型使用場景總結

綜合集合框架和JSON框架的例子，我們可以大概總結出泛型的使用場景，便于理解：不管是數據存儲還是參數傳遞，定義的時候，類型并不確定，只有到使用的時候，才知道具體的類型。所以我們的項目中，如果有用到這種不確定類型的時候，就可以考慮泛型。

當然，泛型還有更多的使用場景，比如泛型接口，這里就不一一舉例了。

2 泛型的實戰應用

2.1 數據的存儲使用泛型類

在實際項目開發中，有一種場景：前后端分離時，為了方便前后端的對接，一般會統一定義參數的傳遞格式和結果的返回格式。以結果返回為例，一般都會定義【返回碼】，【返回描述】，【返回數據】等，所以可以定義一個ResponseDto類，如下：

public class ResponseDto {
    /**
     * 返回碼
     */
    private String code;

    /**
     * 返回信息
     */
    private String message;

    /**
     * 返回數據，???，應該定義成什么類型呢？
     */
    private ??? content;

	// 省略set get
	...
}

【返回碼】一般是前后端約好的字符串類型，【返回描述】一般就是字符串類型，【返回數據】就不一定了，如果是查詢類的請求，返回的數據就是列表信息，可能還包含分頁信息；如果是保存、刪除之類的請求，返回的數據可能是一條數據，也可能只是ID，也可能不需要返回數據。所以【返回數據】這個字段就是個不確定的類型，可以定義成泛型。所以我們就可以把ResponseDto類改成下面這樣：

public class ResponseDto<T> {
    /**
     * 返回碼
     */
    private String code;

    /**
     * 返回信息
     */
    private String message;

    /**
     * 返回數據
     */
    private T content;
}

使用的方法如下：

// 返回單個UserDto對象
ResponseDto<UserDto> responseDto = new ResponseDto<>();
responseDto.setContent(userDto); // userDto是已有的變量

// 返回UserDto列表
ResponseDto<List<UserDto>> responseDto = new ResponseDto<>();
responseDto.setContent(userDtoList); // userDtoList是已有的變量

// 返回ID
ResponseDto<String> responseDto = new ResponseDto<>();
responseDto.setContent(id); // id是已有的變量

這個類就叫做泛型類。

2.2 參數的傳遞使用泛型方法

以BeanUtils.copyProperties為例，大家應該對這個方法不陌生，就是將一個實體類中的屬性值，拷貝到另一個實體類中。一般我們的使用方法是這樣的：

// 功能：將UserDto數據拷貝到User
User user = new User();
BeanUtils.copyProperties(userDto, user); // userDto是已有的變量

但是每次都要寫兩行代碼有點麻煩，要先new一個新的實體類，再往里面拷數據。于是我封裝了個通用的工具類

public class CopyUtil {
    /**
     * CopyUtil.copy的定義很類似JSON.parseObject的定義
     */
    public static <T> T copy(Object source, Class<T> clazz) {
        if (source == null) {
            return null;
        }
        T obj = null;
        try {
            obj = clazz.newInstance(); // 生成一個實例
        } catch (Exception e) {
            e.printStackTrace();
        }
        BeanUtils.copyProperties(source, obj);
        return obj;
    }
}

同樣是上面的例子，用工具類的寫如下

User user = CopyUtil.copy(userDto, User.class); // userDto是已有的變量

CopyUtil.copy的定義很類似JSON.parseObject的定義。代碼變成了一行，當然，減少一行也不足以將其封裝成一個工具類。再來看一個場景，列表的拷貝，用BeanUtils.copyProperties的寫法如下

// 功能：將List<UserDto>數據拷貝到List<User>
List<User> userList = new ArrayList<>();
// userDtoList是已有的變量
for (int i = 0, l = userDtoList.size(); i < l; i++) {
    UserDto userDto = userDtoList.get(i);
    User user = new User();
    BeanUtils.copyProperties(userDto, user);
    userList.add(user);
}

這樣的代碼量就比較多了，并且代碼寫法比較固定。如果項目中用到列表復制的功能比較多，那就有必要對其進行封裝了，如下的copyList方法：

import org.springframework.beans.BeanUtils;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.List;

/**
 * @author 甲蛙
 */
public class CopyUtil {

    /**
     * 列表復制
     */
    public static <T> List<T> copyList(List source, Class<T> clazz) {
        List<T> target = new ArrayList<>();
        if (!CollectionUtils.isEmpty(source)){
            if (!CollectionUtils.isEmpty(source)){
                for (Object c: source) {
                    T obj = copy(c, clazz);
                    target.add(obj);
                }
            }
        }
        return target;
    }

    /**
     * 單體復制
     */
    public static <T> T copy(Object source, Class<T> clazz) {
        if (source == null) {
            return null;
        }
        T obj = null;
        try {
            obj = clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        BeanUtils.copyProperties(source, obj);
        return obj;
    }
}

用法很簡單，還是以上面的列表復制為例，代碼就變成這樣：

// 功能：將List<UserDto>數據拷貝到List<User>
List<User> userList = CopyUtil.copyList(userDtoList, User.class);

封裝成CopyUtil工具類后，不管是單體復制還是列表復制，都只需要一行代碼，省去了大量的重復代碼，從而提高開發效率，這里的copy方法和copyList方法，就是泛型方法，在方法的參數中使用了泛型。

當然這個工具類有個缺點，就是用到了反射，會犧牲一點性能，不過這點性能對于大部分的項目來說可以忽略不計。

2.3 總結

本文討論了兩種泛型的實戰應用，一種是用來存儲類型不確定的數據，用到泛型類；一種是用來傳遞類型不確定的參數，用到了泛型方法。當然，泛型還有更多的用法，比如泛型接口，比較典型的是比較器接口Comparable，這里就不再展開了。

“Java泛型的實際應用”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！