SortedSet与SortedMap,TreeSet与TreeMap

接口

示例

写一个方法，传递一个数字串，算出出现频率最高的数字？
例如：给定数字串(141234121283)那么出现最多的是1

思路分析一之使用TreeMap
key放数字，value放该数字出现的次数，结果发现TreeMap的排序只能针对key排序，不能对value排序。
那么使用TreeMap构造器，自定义比较器总可以了把，结果却发现构造器参数中的比较器是泛型，仍旧只针对key进行排序。

TreeMap(Comparator<? super K> comparator)
Constructs a new, empty tree map, ordered according to the given comparator.

既然如此，那就只能在比较器内部通过key拿到value，然后使用value比较作为排序依据。如此，只需要把map也传进比较器中即可。按照这个思路得到根据value排序的比较器之后，再通过上面TreeMap构造方法传入这个比较器即得到了根据value排序的TreeMap，然后把需要排序的数据放入这个TreeMap即可完成根据value排序。

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

/**
 * @author 欢迎加入Java技术交流群：646766275
 *
 */
public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        test("141234121283");
    }

    static void test(String str) {
        Map<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < str.length(); i++) {
            Character key = str.charAt(i);
            if (map.containsKey(str.charAt(i))) {
                map.put(key, map.get(key) + 1);
            } else {
                map.put(key, 1);
            }
        }

        Comparator<Character> comparator = new ValueComparator(map);

        Map<Character, Integer> map2 = new TreeMap<>(comparator);

        map2.putAll(map);

        for (Map.Entry<Character, Integer> entry : map2.entrySet()) {
            System.out.println(entry.getKey() + "出现了" + entry.getValue() + "次");
        }

    }

}

class ValueComparator implements Comparator<Character> {  

    Map<Character, Integer> map;  

    public ValueComparator(Map<Character, Integer> map) {  
        this.map = map;  
    }

    @Override
    public int compare(Character o1, Character o2) {
        // TODO Auto-generated method stub
        return map.get(o1).compareTo(map.get(o2));
    }  

}

思路分析二之使用HashMap+Collections.sort(list, comparator)

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author 欢迎加入Java技术交流群：646766275
 *
 */
public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        test("141234121283");
    }

    static void test(String str) {
        Map<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < str.length(); i++) {
            Character key = str.charAt(i);
            if (map.containsKey(str.charAt(i))) {
                map.put(key, map.get(key) + 1);
            } else {
                map.put(key, 1);
            }
        }

        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "出现了" + entry.getValue() + "次");
        }

        List<Map.Entry<Character, Integer>> list = new ArrayList<>(map.entrySet());  

        Collections.sort(list,new Comparator<Map.Entry<Character,Integer>>() {  
            public int compare(Map.Entry<Character, Integer> o1, Map.Entry<Character, Integer> o2) {  
                return o1.getValue().compareTo(o2.getValue());  
            }  
        });  

        for (Map.Entry<Character, Integer> entry : list) {  
            System.out.println(entry.getKey() + "出现了" + entry.getValue() + "次");
        } 
    }

}

思路分析三之使用TreeSet
TreeSet可以对放入其中的对象排序（对象必须实现Comparable或Comparator接口），那么只需自定义一个类，两个字段，字段key放数字，字段value放该数字出现的次数，然后比较器根据value排序即可。不过问题来了，如何统计每个数字出现的次数？这个需要借助HashMap实现

import java.util.*;

class Demo implements Comparable<Demo> {
    private String name;
    private int age;

    public Demo(){
    }

    public Demo(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String toString(){
        return name + " " + age;
    }

    public int compareTo(Demo demo){
        int result = age > demo.age ? 1 : (age == demo.age ? 0 : -1);

        if (result == 0){
            result = name.compareTo(demo.name);
        }

        return result;
    }
}

public class CompareDemo {
    public static void main(String[] args){
        Set<Demo> s = new TreeSet<Demo>();
        s.add(new Demo("C",20));
        s.add(new Demo("A",20));
        s.add(new Demo("B",18));

        for (Demo d : s){
            System.out.println(d);
        }
    }
}

输出结果：
B 18
A 20
C 20

正如期望，那么只需自定义一个类，两个字段，字段key放数字，字段value放该数字出现的次数，然后按上述类的方式比较即可得出结果。问题来了，如何统计每个数字出现的次数？借助HashMap实现

Map<Character, Integer> map = new HashMap<>();
for (int i = 0; i < str.length(); i++) {
    Character key = str.charAt(i);
    if (map.containsKey(str.charAt(i))) {
        map.put(key, map.get(key) + 1);
    } else {
        map.put(key, 1);
    }
}

感觉复杂了。

思路分析四之两个List或两个数组

第1个List或数组放数字，第二个List或数组放该数字出现的次数

import java.util.ArrayList;
import java.util.List;


/**
 * @author 欢迎加入Java技术交流群：646766275
 *
 */
public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        test("141234121283");
    }

    static void test(String str) {
        List<Character> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();

        for (int i = 0; i < str.length(); i++) {
            Character key = str.charAt(i);

            boolean flag = false;
            for (int j = 0; j < list1.size(); j++) {
                if (key.equals(list1.get(j))) {
                    list2.set(j, list2.get(j) + 1);
                    flag = true;
                    break;
                }
            }

            if (!flag) {
                list1.add(key);
                list2.add(1);
            }
        }

        for (int i = 0; i < list1.size(); i++) {
            System.out.println(list1.get(i) + "出现了" + list2.get(i) + "次");
        }
    }

}

结果发现：只能得到每个数字出现的次数，却无法得出哪个数字出现的频度最高，故而【不可取】

寻找真相：放进set的对象莫名消失了

import java.util.Set;
import java.util.TreeSet;

/**
 * @author 欢迎加入Java技术交流群：646766275
 *
 */
public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        test("141234121283");
    }

    static void test(String str) {
        Set<KeyValuePair> set = new TreeSet<KeyValuePair>();

        for (int i = 0; i < str.length(); i++) {
            Character key = str.charAt(i);

            boolean flag = false;
            for (KeyValuePair keyValuePair : set) {
                System.out.println(keyValuePair.getKey() + "=" + keyValuePair.getValue());
            }
            System.out.println("========A");
            for (KeyValuePair keyValuePair : set) {
                System.out.println(key + "<->[" + keyValuePair.getKey() + "=" + keyValuePair.getValue() + "]");
                if (String.valueOf(key).equals(String.valueOf(keyValuePair.getKey()))) {
                    keyValuePair.setValue(keyValuePair.getValue() + 1);
                    System.out.println("重置：key=" + keyValuePair.getKey() + ",value=" + keyValuePair.getValue());
                    flag = true;
                    break;
                }
            }
            System.out.println("========B");
            if (!flag) {
                System.out.println("添加：key=" + key + ",value=1");
                KeyValuePair keyValuePair = new KeyValuePair(key, 1);
                set.add(keyValuePair);
                System.out.println("------------@A@");
                for (KeyValuePair a : set) {
                    System.out.println(a.getKey() + "=" + a.getValue());
                }
                System.out.println("------------@B@");
            }

            System.out.println("\n\n\n");
        }

        for (KeyValuePair entry : set) {
            System.out.println(entry.getKey() + "出现了" + entry.getValue() + "次");
        }

    }

}

class KeyValuePair implements Comparable<KeyValuePair> {
    private Character key;
    private Integer value;

    public KeyValuePair(){
    }

    public KeyValuePair(Character key, Integer value){
        this.key = key;
        this.value = value;
    }

    public Character getKey() {
        return key;
    }

    public void setKey(Character key) {
        this.key = key;
    }

    public Integer getValue() {
        return value;
    }

    public void setValue(Integer value) {
        this.value = value;
    }

    public int compareTo(KeyValuePair keyValuePair){
        return value.compareTo(keyValuePair.getValue());
    }
}

寻找真相：动态二维赋值时出现 ArrayIndexOutOfBoundsException

/**
 * @author 欢迎加入Java技术交流群：646766275
 *
 */
public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        test("141234121283");
    }

    static void test(String str) {
        Object[][] array = new Object[][]{};


        for (int i = 0; i < str.length(); i++) {
            Character key = str.charAt(i);

            boolean flag = false;
            for (int j = 0; j < array.length; j++) {
                if (key.equals(array[j][0])) {
                    array[j][1] = (Integer)array[j][1] + 1;
                    flag = true;
                    break;
                }
            }

            if (!flag) {
                int index = array.length;
                array[index][0] = key;
                array[index][1] = 1;
            }
        }

        System.out.println(array);
    }

}