2. 程式人生 > >java List Map String Object泛型通用排序 支援兩個欄位排序

java List Map String Object泛型通用排序 支援兩個欄位排序

阿新 • • 發佈：2019-01-14

環境

java：1.7+

前言

公司有個公共的排序方法類，其中，字串一個方法、日期字串一個方法、數字一個方法等等；
我覺得這些方法都可以寫成一個方法；

下面程式碼只針對List<Map<String, Object>>這種方式進行排序

程式碼

完整程式碼
下面這段程式碼有問題 繼續看後面的優化程式碼

/**
 * 對結果集進行排序，目前支援日期、字串、各種整形、各種浮點型
 * @param result 結果集
 * @param order
 * @param orderType -1降序 1升序, 下面程式碼假設orderType為1
 * @return
 

 * @author yutao
 * @date 2018年4月24日下午2:20:35
 */
public static List<Map<String, Object>> resultOrder(List<Map<String, Object>> result, String order, Integer orderType){

    if(result == null || orderType == null){
        return result;
    }

    if(orderType != -1){
        orderType = 1
 
;
    }

    final String orderKey = order;
    final Integer oType = orderType;

    Collections.sort(result, new Comparator<Map<String, Object>>() {

        @Override
        public int compare(Map<String, Object> o1, Map<String, Object> o2) {
            Object obj1 = o1.get(orderKey);
            Object obj2 = o2.get(orderKey);

            if
 
 (obj1 == null) {
                if(oType < 0){
                    return -oType;
                }
                return oType;
            }
            if (obj2 == null) {
                if(oType < 0){
                    return oType;
                }
                return -oType;
            }

            if(obj1 instanceof Date){
                //日期排序
                Date date1 = (Date)obj1;
                Date date2 = (Date)obj2;
                return longCompare(oType, date1.getTime(), date2.getTime());
            }else if(obj1 instanceof String){
                //字串排序
                String str1 = obj1.toString();
                String str2 = obj2.toString();

                if(str1.compareTo(str2) < 0){
                    return -oType;
                }else if(str1.compareTo(str2) == 0){
                    return 0;
                }else if(str1.compareTo(str2) > 0){
                    return oType;
                }
            }else if(obj1 instanceof Double || obj1 instanceof Float){
                //浮點型排序
                return doubleCompare(oType, obj1, obj2);
            }else if(obj1 instanceof Long || obj1 instanceof Integer || obj1 instanceof Short || obj1 instanceof Byte){
                //整數型排序
                return longCompare(oType, obj1, obj2);
            }
            return 0;
        }
    });
    return result;
}

private static int longCompare(final Integer oType, Object obj1, Object obj2) {
    long d1 = Long.parseLong(obj1.toString());
    long d2 = Long.parseLong(obj2.toString());
    if(d1 < d2){
        return -oType;
    }else if(d1 == d2){
        //相同的是否進行互動
        return 0;
    }else if(d1 > d2){
        return oType;
    }
    return 0;
}

private static int doubleCompare(final Integer oType, Object obj1, Object obj2) {
    double d1 = Double.parseDouble(obj1.toString());
    double d2 = Double.parseDouble(obj2.toString());
    if(d1 < d2){
        return -oType;
    }else if(d1 == d2){
        return 0;
    }else if(d1 > d2){
        return oType;
    }
    return 0;
}

講解：
①Collections.sort()的排序規則參考：
https://blog.csdn.net/u013066244/article/details/78997869
② 如果是字串就用compareTo方法進行比較；
如果是整數（各種整數）或者Date，都統一轉成long進行比較。
如果是浮點數，就轉成Double進行比較。

犯的錯誤

long d1 = Long.parseLong(obj1.toString());
long d2 = Long.parseLong(obj2.toString());

//錯誤寫法
Long d1 = Long.valueOf(obj1.toString());
Long d2 = Long.valueOf(obj2.toString());
//當為Integer或者其他非Long整數時，會報型別轉換異常

相同元素不交換帶來的後果

上面的程式碼中，如果元素相同，不會進行互動，那麼在進行倒序時可能會與實際想要的結果有偏差。

比如：
假設資料庫降序的順序如下，按照count的值進行排序：

{
    name: "a",
    count: 29
},
{
    name: "b",
    count: 22
},
{
    name: "c",
    count: 22
}

我們再使用上面的程式碼，在記憶體裡進行倒序（即升序）。
結果為：

{
    name: "b",
    count: 22
},
{
    name: "c",
    count: 22
}，
{   name: "a",
    count: 29
}

但是可能我們實際想要的結果應該為：

{
    name: "c",
    count: 22
}，
{
    name: "b",
    count: 22
},
{   name: "a",
    count: 29
}

為什麼結果會這樣呢？因為b和a進行比較count時，a大，排後面，接下來b和c進行比較，發現相同，上面的程式碼返回0，也就是不交換，這時，c就放b的後頭，因為演算法認為，目前b才是最小的。

針對這樣的情況，我們反而希望，相同時，發生交換。

總結

記憶體排序，不到萬不得已才去用，一般資料庫排序是最好的！

當需要記憶體排序時，相同元素是否發生交換需要而外注意。

==============2018-05-18======================start=======
今天遇到這樣一個錯誤：

java.lang.NumberFormatException: For input string: \"0.002091696324526065\"

之所以會報這個錯誤，是因為其執行到了longCompare()這個方法，也就是當做整型來處理。
為什麼呢？通過打日誌我知道了：

class java.lang.Integer---------該值為-------0
class java.lang.Double---------該值為--------0.035

我的資料中，既有Integer型，又有Double型，而我上面的程式碼判斷，只判斷Obj1，這樣在執行時，就會把兩個元素都當做整型來處理。所以就調了longCompare()方法。這塊需要優化

優化後的程式碼

/**
 * 對結果集進行排序，目前支援日期、字串、各種整形、各種浮點型
 * @param result 結果集
 * @param order
 * @param orderType -1降序 1升序, 下面程式碼假設orderType為1
 * @return
 * @author yutao
 * @date 2018年4月24日下午2:20:35
 */
public static List<Map<String, Object>> resultOrder(List<Map<String, Object>> result, String order, Integer orderType){

    if(result == null || orderType == null){
        return result;
    }

    if(orderType != -1){
        orderType = 1;
    }

    final String orderKey = order;
    final Integer oType = orderType;

    Collections.sort(result, new Comparator<Map<String, Object>>() {

        @Override
        public int compare(Map<String, Object> o1, Map<String, Object> o2) {
            Object obj1 = o1.get(orderKey);
            Object obj2 = o2.get(orderKey);

            if (obj1 == null) {
                if(oType < 0){
                    return -oType;
                }
                return oType;
            }
            if (obj2 == null) {
                if(oType < 0){
                    return oType;
                }
                return -oType;
            }

            if(obj1 instanceof Date && obj2 instanceof Date){
                //日期排序
                Date date1 = (Date)obj1;
                Date date2 = (Date)obj2;
                return longCompare(oType, date1.getTime(), date2.getTime());
            }else if(obj1 instanceof String && obj2 instanceof String){
                //字串排序
                String str1 = obj1.toString();
                String str2 = obj2.toString();

                if(str1.compareTo(str2) < 0){
                    return -oType;
                }else if(str1.compareTo(str2) == 0){
                    return 0;
                }else if(str1.compareTo(str2) > 0){
                    return oType;
                }
            }else if((obj1 instanceof Double || obj1 instanceof Float) && (obj2 instanceof Double || obj2 instanceof Float)){
                //浮點型排序
                return doubleCompare(oType, obj1, obj2);
            }else if((obj1 instanceof Long || obj1 instanceof Integer || obj1 instanceof Short || obj1 instanceof Byte) && 
                     (obj2 instanceof Long || obj2 instanceof Integer || obj2 instanceof Short || obj2 instanceof Byte)){
                //整數型排序
                return longCompare(oType, obj1, obj2);
            }else if((obj1.getClass() != obj2.getClass()) && (obj1 instanceof Number && obj2 instanceof Number)){
                //這種情況可能是，既有整數又有浮點數
                return doubleCompare(oType, obj1, obj2);
            }
            return 0;
        }
    });
    return result;
}

private static int longCompare(final Integer oType, Object obj1, Object obj2) {
    long d1 = Long.parseLong(obj1.toString());
    long d2 = Long.parseLong(obj2.toString());
    if(d1 < d2){
        return -oType;
    }else if(d1 == d2){
        //相同的是否進行互動
        return 0;
    }else if(d1 > d2){
        return oType;
    }
    return 0;
}

private static int doubleCompare(final Integer oType, Object obj1, Object obj2) {
    double d1 = Double.parseDouble(obj1.toString());
    double d2 = Double.parseDouble(obj2.toString());
    if(d1 < d2){
        return -oType;
    }else if(d1 == d2){
        return 0;
    }else if(d1 > d2){
        return oType;
    }
    return 0;
}

其實上面的程式碼應該還可以優化，就是無論是整數還是浮點數，都當做Double來處理。

遇到的異常

Comparison method violates its general contract!

因為我的程式碼裡沒有return：

... 上面程式碼省略。。。
else if((obj1.getClass() != obj2.getClass()) && 
(obj1 instanceof Number && obj2 instanceof Number)){
                //這種情況可能是，既有整數又有浮點數
                 doubleCompare(oType, obj1, obj2);//我這裡沒有寫return 也就是自定義排序，不給任何數字
            }

==============2018-05-18======================end=======

==============2018-05-24======================start=======

兩個欄位排序

今天需要一個需求，是要兩個欄位進行排序，所以我得進行以下修改；

思路：既然是兩個欄位排序，那麼我們就要先第一欄位排好序後，相等的話，再進行第二欄位排序。

直接上完整的程式碼了：

/**
 * 支援兩個欄位排序
 * @param result
 * @param order
 * @param orderType
 * @param twoOrder 第二排序欄位
 * @param twoType 第二排序順序
 * @return
 * @author yutao
 * @date 2018年5月24日下午3:00:03
 */
public static List<Map<String, Object>> resultOrder(List<Map<String, Object>> result, String order, Integer orderType, 
                                                    final String twoOrder, final Integer twoType){

    if(result == null || orderType == null){
        return result;
    }

    if(orderType != -1){
        orderType = 1;
    }

    final String orderKey = order;
    final Integer oType = orderType;

    Collections.sort(result, new Comparator<Map<String, Object>>() {
        @Override
        public int compare(Map<String, Object> o1, Map<String, Object> o2) {
            Object obj1 = o1.get(orderKey);
            Object obj2 = o2.get(orderKey);
            return commonOrder(orderKey, oType, obj1, obj2, twoOrder, twoType);
        }
    });
    return result;
}

/**
 * 對結果集進行排序，目前支援日期、字串、各種整形、各種浮點型
 * @param result 結果集
 * @param order
 * @param orderType -1降序 1升序, 下面程式碼假設orderType為1
 * @return
 * @author yutao
 * @date 2018年4月24日下午2:20:35
 */
public static List<Map<String, Object>> resultOrder(List<Map<String, Object>> result, String order, Integer orderType){
    return resultOrder(result, order, orderType, null, null);
}

/**
 * 公共的排序部分
 * @param orderKey
 * @param oType
 * @param obj1
 * @param obj2
 * @param twoOrder
 * @param twoType
 * @return
 * @author yutao
 * @date 2018年5月24日下午3:19:37
 */
public static Integer commonOrder(final String orderKey, final Integer oType, Object obj1, Object obj2, String twoOrder, Integer twoType) {
    if (obj1 == null) {
        if(oType < 0){
            return -oType;
        }
        return oType;
    }
    if (obj2 == null) {
        if(oType < 0){
            return oType;
        }
        return -oType;
    }

    if(obj1 instanceof Date && obj2 instanceof Date){
        //日期排序
        Date date1 = (Date)obj1;
        Date date2 = (Date)obj2;
        return longCompare(oType, date1.getTime(), date2.getTime(), twoOrder, twoType);
    }else if(obj1 instanceof String && obj2 instanceof String){
        //字串排序
        String str1 = obj1.toString();
        String str2 = obj2.toString();

        if(str1.compareTo(str2) < 0){
            return -oType;
        }else if(str1.compareTo(str2) == 0){
            return 0;
        }else if(str1.compareTo(str2) > 0){
            return oType;
        }
    }else if((obj1 instanceof Double || obj1 instanceof Float) && (obj2 instanceof Double || obj2 instanceof Float)){
        //浮點型排序
        return doubleCompare(oType, obj1, obj2, twoOrder, twoType);
    }else if((obj1 instanceof Long || obj1 instanceof Integer || obj1 instanceof Short || obj1 instanceof Byte) && 
             (obj2 instanceof Long || obj2 instanceof Integer || obj2 instanceof Short || obj2 instanceof Byte)){
        //整數型排序
        return longCompare(oType, obj1, obj2, twoOrder, twoType);
    }else if((obj1.getClass() != obj2.getClass()) && (obj1 instanceof Number && obj2 instanceof Number)){
        //這種情況可能是，既有整數又有浮點數
        return doubleCompare(oType, obj1, obj2, twoOrder, twoType);
    }
    return 0;
}


/**
 * 整形比較大小
 * @param oType
 * @param obj1
 * @param obj2
 * @param twoOrder
 * @param twoType
 * @return
 * @author yutao
 * @date 2018年5月24日下午3:09:18
 */
private static int longCompare(final Integer oType, Object obj1, Object obj2, String twoOrder, Integer twoType) {
    long d1 = Long.parseLong(obj1.toString());
    long d2 = Long.parseLong(obj2.toString());
    if(d1 < d2){
        return -oType;
    }else if(d1 == d2){

        if(twoOrder != null && twoType != null){
            //相等就使用第二欄位排序
            return commonOrder(twoOrder, twoType, obj1, obj2, null, null);
        }
        //相同的是否進行互動
        return 0;
    }else if(d1 > d2){
        return oType;
    }
    return 0;
}

/**
 * 浮點型比較大小
 * @param oType
 * @param obj1
 * @param obj2
 * @return
 * @author yutao
 * @date 2018年5月24日下午3:09:41
 */
private static int doubleCompare(final Integer oType, Object obj1, Object obj2, String twoOrder, Integer twoType) {
    double d1 = Double.parseDouble(obj1.toString());
    double d2 = Double.parseDouble(obj2.toString());
    if(d1 < d2){
        return -oType;
    }else if(d1 == d2){
        if(twoOrder != null && twoType != null){

            //相等就使用第二欄位排序
            return commonOrder(twoOrder, twoType, obj1, obj2, null, null);
        }
        return 0;
    }else if(d1 > d2){
        return oType;
    }
    return 0;
}

==============2018-05-24======================end=======

==============2018-05-31======================start=======

上面的程式碼其實並不能實現兩個欄位排序，邏輯上有點問題。

因為第二次，並沒有改變排序欄位obj1|obj2。

/**
 * 支援兩個欄位排序
 * @param result
 * @param order
 * @param orderType
 * @param twoOrder 第二排序欄位
 * @param twoType 第二排序順序
 * @return
 * @author yutao
 * @date 2018年5月24日下午3:00:03
 */
public static List<Map<String, Object>> resultOrder(List<Map<String, Object>> result, String order, Integer orderType, 
                                                    final String twoOrder, final Integer twoType){

    if(result == null || orderType == null){
        return result;
    }

    if(orderType != -1){
        orderType = 1;
    }

    final String orderKey = order;
    final Integer oType = orderType;

    Collections.sort(result, new Comparator<Map<String, Object>>() {
        @Override
        public int compare(Map<String, Object> o1, Map<String, Object> o2) {
            //這裡加了個判空，原則上，空元素（map）就不該進來
            if(o1 == null && o2 == null){
                return 0;
            }
            if (o1 == null) {
                if(oType < 0){
                    return -oType;
                }
                return oType;
            }
            if (o2 == null) {
                if(oType < 0){
                    return oType;
                }
                return -oType;
            }
            return commonOrder(orderKey, oType, obj1, obj2, twoOrder, twoType, o1, o2);
        }
    });
    return result;
}


/**
 * 對結果集進行排序，目前支援日期、字串、各種整形、各種浮點型
 * @param result 結果集
 * @param order
 * @param orderType -1降序 1升序, 下面程式碼假設orderType為1
 * @return
 * @author yutao
 * @date 2018年4月24日下午2:20:35
 */
public static List<Map<String, Object>> resultOrder(List<Map<String, Object>> result, String order, Integer orderType){
    return resultOrder(result, order, orderType, null, null);
}

/**
 * 公共的排序部分
 * @param orderKey
 * @param oType
 * @param obj1
 * @param obj2
 * @param twoOrder
 * @param twoType
 * @return
 * @author yutao
 * @param obj2 
 * @param obj1 
 * @param o2 
 * @param o1 
 * @date 2018年5月24日下午3:19:37
 */
public static Integer commonOrder(final String orderKey, final Integer oType, String twoOrder, Integer twoType, 
        Map<String, Object> o1, Map<String, Object> o2) {
    Object obj1 = o1.get(orderKey);
    Object obj2 = o2.get(orderKey);

    if(obj1 == null && obj2 == null){
        return 0;
    }
    if (obj1 == null) {
        if(oType < 0){
            return -oType;
        }
        return oType;
    }
    if (obj2 == null) {
        if(oType < 0){
            return oType;
        }
        return -oType;
    }

    if(obj1 instanceof Date && obj2 instanceof Date){
        //日期排序
        Date date1 = (Date)obj1;
        Date date2 = (Date)obj2;
        return longCompare(oType, date1.getTime(), date2.getTime(), twoOrder, twoType,o1, o2);
    }else if(obj1 instanceof String && obj2 instanceof String){
        //字串排序
        String str1 = obj1.toString();
        String str2 = obj2.toString();

        if(str1.compareTo(str2) < 0){
            return -oType;
        }else if(str1.compareTo(str2) == 0){
            return 0;
        }else if(str1.compareTo(str2) > 0){
            return oType;
        }
    }else if((obj1 instanceof Double || obj1 instanceof Float) && (obj2 instanceof Double || obj2 instanceof Float)){
        //浮點型排序
        return doubleCompare(oType, obj1, obj2, twoOrder, twoType,o1, o2);
    }else if((obj1 instanceof Long || obj1 instanceof Integer || obj1 instanceof Short || obj1 instanceof Byte) && 
             (obj2 instanceof Long || obj2 instanceof Integer || obj2 instanceof Short || obj2 instanceof Byte)){
        //整數型排序
        return longCompare(oType, obj1, obj2, twoOrder, twoType, o1, o2);
    }else if((obj1.getClass() != obj2.getClass()) && (obj1 instanceof Number && obj2 instanceof Number)){
        //這種情況可能是，既有整數又有浮點數
        return doubleCompare(oType, obj1, obj2, twoOrder, twoType,o1, o2);
    }
    return 0;
}

/**
 * 整形比較大小
 * @param oType
 * @param obj1
 * @param obj2
 * @param twoOrder
 * @param twoType
 * @return
 * @author yutao
 * @param o2 
 * @param o1 
 * @date 2018年5月24日下午3:09:18
 */
private static int longCompare(final Integer oType, Object obj1, Object obj2, String twoOrder, Integer twoType, 
                               Map<String, Object> o1, Map<String, Object> o2) {
    long d1 = Long.parseLong(obj1.toString());
    long d2 = Long.parseLong(obj2.toString());
    if(d1 < d2){
        return -oType;
    }else if(d1 == d2){

        if(twoOrder != null && twoType != null){
            //相等就使用第二欄位排序
            return commonOrder(twoOrder, twoType, null, null, o1, o2);
        }
        //相同的是否進行互動
        return 0;
    }else if(d1 > d2){
        return oType;
    }
    return 0;
}

/**
 * 浮點型比較大小
 * @param oType
 * @param obj1
 * @param obj2
 * @return
 * @author yutao
 * @param o2 
 * @param o1 
 * @date 2018年5月24日下午3:09:41
 */
private static int doubleCompare(final Integer oType, Object obj1, Object obj2, String twoOrder, Integer twoType, 
                                 Map<String, Object> o1, Map<String, Object> o2) {
    double d1 = Double.parseDouble(obj1.toString());
    double d2 = Double.parseDouble(obj2.toString());
    if(d1 < d2){
        return -oType;
    }else if(d1 == d2){
        if(twoOrder != null && twoType != null){

            //相等就使用第二欄位排序
            return commonOrder(twoOrder, twoType, null, null, o1, o2);
        }
        return 0;
    }else if(d1 > d2){
        return oType;
    }
    return 0;
}

相關推薦

java List Map String Object泛型通用排序 支援兩個欄位排序

環境 java：1.7+ 前言 公司有個公共的排序方法類，其中，字串一個方法、日期字串一個方法、數字一個方法等等； 我覺得這些方法都可以寫成一個方法； 下面程式碼只針對List<Map<String, Object>>這種方

List Map String,Object 轉換成Map String,List Map String,Object

import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import

List<Map<String, Object>>是什麼意思

List集合中的物件是一個Map物件,而這個Map物件的鍵是String型別,值是Object型別 List以Map介面物件為列表物件。 Map以String為鍵，以Object為值。 List裡只能放Map型別的物件，而這個Map型別的物件又只能放以String型別為鍵，以Object型別為值

hibernate使用原生sql查詢，返回List Map String, Object ，並重命名返回資料列名稱

hibernate使用原生sql查詢時返回的欄位不能重新命名 例如使用如下sql查詢時報錯 sql = "SELECT t.type_name as `name`,SUM(o.circulation) FROM " +

使用map操作物件排序，根據物件欄位排序

map是一個由鍵值對資料組成的集合。在某個專案中，前端顯示的資料量不大，於是採用map進行顯示。但是後來才發現，這樣並不是最簡單的處理方式，但是由於一開始沒考慮好，一路坑到底。把對資料庫的操作轉成在map身上，如果只是用於學習，可以借鑑，如果是要在專案中進行操作的話，可能會偏

在Java中使用Collections.sort 依據多個欄位排序

## 一、如何使用Collections工具類進行排序 使用Collections工具類進行排序主要有兩種方式： ### 1.物件實現Comparable介面，重寫compareTo方法 ```java /** * @author Hanstrovsky */ @Data @AllArgsConst

java 將list轉換為map 的泛型通用方法

將list轉換為map 背景：最近使用比較多的mongodb，由於其缺乏表連線的查詢，導致我們經常需要將表資料查詢到記憶體中，然後進行匹配連線，組成需要的資料格式，匹配的方式通常是： list1中有list2需要的欄位，於是將list1轉換為map，遍歷list2，從ma

java泛型詳解和反射泛型通用BaseDao實現

一 泛型的基本概念 1.1什麼是泛型？ 泛型，即“引數化型別”。一提到引數，最熟悉的就是定義方法時有形參，然後呼叫此方法時傳遞實參。那麼引數化型別怎麼理解呢？顧名思義，就是將型別由原來的具體的型別引數化，類似於方法中的變數引數，此時型別也定義成引數形式（可以

java中的幾種泛型類——HashSet、HashMap、TreeSet、TreeMap，遍歷map，排序，HashTable比較

package test; import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.TreeMap; public c

java list轉String,list轉map,String陣列轉list，帶逗號String轉list

專案中經常會遇到list轉String,list轉map,String轉list等情況，特在這裡記錄一下。 1.list轉String 將List集合轉化為用符號隔開的String字串，只要用StringUtils中的join就行。 String

基於java反射篩選List對於不同實體泛型的公共方法

前提：在最近做的專案當中有個奇葩的需要，就是需要將已知的list<實體類>進行一次篩選，查詢list裡面屬性中的值是否包含某個值（模糊查詢）。將符合要求的物件新增到一個list1裡面，從而生

Java中讓fastJson識別Colloction和Map中的泛型類

return input 泛型 簡單 得到 針對 this 一個 urn 由於fastJson的高效性，最近采用fastJson來做序列化並存儲數據，但出現了一個麻煩的問題，如果將Map<K,V>這樣的類型序列化，反序列化就會不盡人意，有以下嘗試： 使用JSO

Head first java chapter 16 集合與泛型（數據結構）

技術分享 rst image 結構 logs ges nbsp alt log Head first java chapter 16 集合與泛型（數據結構）

《Effective Java》第5章 泛型

增加 規範 註釋 line 元素 eric 有關 img shu 第23條:請不要在新代碼中使用原生態類型 聲明中具有一個或者多個類型參數( type parameter)的類或者接口，就是泛型(generic)類或者接口。 每種泛型定義一組參數化的類型(paramet

201671010128 2017-10-30《Java程序設計》之泛型程序設計

amd 進度 第六周 進度條 ray 數量 返回 不同 概念 一、基本概念 泛型也被稱為參數化類型(parameterized type)，就是在定義類、接口和方法時，通過類型參數指示將要處理的對象類型。（如ArrayList類） 泛型程序設計（Generic progr

java week 9----- 集合與泛型

評估 -m 正常 面向對象思想 acm 元素 篩選 -o 內容 1. 本周學習總結 1.1 以你喜歡的方式（思維導圖或其他）歸納總結集合與泛型相關內容。 2. 書面作業 本次作業題集集合 1. List中指定元素的刪除(題集題目) 1.1 實驗總結。並回答：列舉至少2種在

Java初學者筆記五：泛型處理

不同 pat private tin face 泛型接口 nts override ace 一、泛型類： 泛型是指適用於某一種數據類型而不是一個數據機構中能存不同類型 1 import java.io.*; 2 import java.nio.file.Files;

list<String,object>的元素判空（用於判斷查詢數據庫返回值）

size 元素 數據庫 bject 要去 邏輯 判斷 成功 ise 一般人可能會使用list.size或者list==null來做判斷。當沒有返回值時返回的類型為"[ ]"它並不是空也沒有元素，所以使用==null以及if(list.size()>0){//業務邏輯}

根據用戶名的輸入顯示密碼（用了<String>泛型）

子類 secret public pan rgs else println stat system.in /*接口List分為LinkedList和ArrayList；泛型<String>規定該類new出的對象或聲明的引用只能存放String類的對象 eg:Li

java基礎（3）-----泛型

1.概述（什麼是泛型？） 泛型，即“引數化型別”，顧名思義，將具體的型別引數化，在呼叫的時候再傳入具體的型別 2.一個簡單的例子 public class GenericTest { public static void main(String[] args) {