ArrayList存放HashMap排序方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.test.coll;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Random;

public class Index {
    public static void main(String[] args) {
        System.out.println("---------排序前---------");
        ArrayList<HashMap<String, String>> al = Index.getRondomData();
        for (HashMap<String, String> hm : al) {
            System.out.println(hm.get("key") + ":" + hm.get("value"));
        }
        System.out.println("---------排序后---------");
        Collections.sort(al, new MySort(false, true, "key"));
        for (HashMap<String, String> hm : al) {
            System.out.println(hm.get("key") + ":" + hm.get("value"));
        }
    }

    public static ArrayList<HashMap<String, String>> getRondomData() {
        ArrayList<HashMap<String, String>> al = new ArrayList<HashMap<String, String>>();
        for (int i = 0; i < 10; i++) {
            HashMap<String, String> hm = new HashMap<String, String>();
            hm.put("key", (new Random()).nextInt(100) + "");
            hm.put("value", (new Random()).nextInt(100) + "");
            al.add(hm);
        }
        return al;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com.test.coll;

import java.util.Comparator;
import java.util.HashMap;

public class MySort implements Comparator<HashMap<String, String>> {

    private boolean isAsc; // 是否为升序，true:升序，false:降序
    private boolean isNum; // 排序value是否为数值型
    private String key; // 根据哪个key排序

    public MySort(boolean isAsc, boolean isNum, String key) {
        this.isAsc = isAsc;
        this.isNum = isNum;
        this.key = key;
    }

    @Override
    public int compare(HashMap<String, String> hashMap1,
            HashMap<String, String> hashMap2) {
        String v1 = hashMap1.get(this.key);
        String v2 = hashMap2.get(this.key);
        if (!isNum) {
            return isAsc ? (v1.compareTo(v2)) : (v2.compareTo(v1));
        } else {
            if (Double.parseDouble(v1) > Double.parseDouble(v2)) {
                return isAsc ? 1 : -1;
            }else if(Double.parseDouble(v1) < Double.parseDouble(v2)) {
                return isAsc ? -1 : 1;
            }else {
                return 0;
            }
        }
    }
}