java 数据结构

private void initMap() {
    //HashMap最多只允许一条记录的键为Null(多条会覆盖);允许多条记录的值为 Null。非同步的。
    Map<String,Integer> map = new HashMap<>();
    //key 弱引用，当不被引用是会被回收。
    Map<String,Integer> weakmap = new WeakHashMap<>();
    //能够把它保存的记录根据键(key)排序,默认是按升序排序，也可以指定排序的比较器，
    // 当用Iterator 遍历TreeMap时，得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。
    Map<String,Integer> treeMap = new TreeMap<>();
    //与 HashMap类似,不同的是:key和value的值均不允许为null;它支持线程的同步，
    // 即任一时刻只有一个线程能写Hashtable,因此也导致了Hashtale在写入时会比较慢。
    Map<String,Integer> haMap = new Hashtable<>();
    //保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，
    // 先得到的记录肯定是先插入的.在遍历的时候会比HashMap慢。key和value均允许为空，非同步的。
    Map<String,Integer> linkMap = new LinkedHashMap<>();
    for (int i = 0 ;i<15;i++){
        map.put("key"+i,i*10);
        weakmap.put("weakk"+i,i*100);
        treeMap.put("tree-key"+i,i*1000);
        haMap.put("haMap"+i,i);
        linkMap.put("linkMap"+i,i*i);
        UUID.randomUUID().toString();
    }
    Log.d(TAG, map.toString());
    Log.d(TAG, weakmap.toString());
    Log.d(TAG, treeMap.toString());
    Log.d(TAG, haMap.toString());
    Log.d(TAG, linkMap.toString());


    /////////用keySet()遍历
    for (String key : map.keySet()) {
        System.out.println(key + " ：" + map.get(key));
    }

    ///用entrySet()遍历
    for (Map.Entry<String, Integer> entry : map.entrySet()) {
        System.out.println(entry.getKey() + " ：" + entry.getValue());
    }

    //用keySet()遍历
    Iterator<String> iterator = map.keySet().iterator();
    while (iterator.hasNext()) {
        String key = iterator.next();
        System.out.println(key + "　：" + map.get(key));
    }
    //用entrySet()遍历
    Iterator<Map.Entry<String, Integer>> iterator1 = map.entrySet().iterator();
    while (iterator1.hasNext()) {
        Map.Entry<String, Integer> entry = iterator1.next();
        System.out.println(entry.getKey() + "　：" + entry.getValue());
    }
    //增强for循环使用方便，但性能较差，不适合处理超大量级的数据。
    //
    //迭代器的遍历速度要比增强for循环快很多，是增强for循环的2倍左右。
    //
    //使用entrySet遍历的速度要比keySet快很多，是keySet的1.5倍左右。



    //map 按照value 排序
    // 通过ArrayList构造函数把map.entrySet()转换成list
    List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
    // 通过比较器实现比较排序
    Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
        public int compare(Map.Entry<String, Integer> mapping1, Map.Entry<String, Integer> mapping2) {
            return mapping1.getValue().compareTo(mapping2.getValue());
        }
    });
    for (String key : map.keySet()) {
        System.out.println(key + " ：" + map.get(key));
    }
}

private void initVector(){
    Vector<String> vector = new Vector<>();//重复值
    Vector<String> stringVector = new Vector<>(15);
    stringVector.add("ss");
    stringVector.add("sss");

    for (int i= 0;i<15;i++){
        stringVector.add("stack item" + i);
    }
    stringVector.add("sss");

    Log.d(TAG, stringVector.toString());
    //这种方式最快
    for (int i=0; i<stringVector.size(); i++) {
        stringVector.get(i);
    }
}
private void initStack() {
    stringStack = new Stack<>();
    for (int i= 0;i<15;i++){
        stringStack.push("stack item" + i);
    }
    Log.d(TAG, stringStack.toString());
}
private void initSet(){//Set的实现类都是基于Map来实现的
    Set<String> stringSet = new HashSet<>();//无序，不重复值
    Set<Integer> integerSet = new LinkedHashSet<>();//wu序，不重复值
    Set<String> stringSet1 = new TreeSet<>();
    stringSet.add("sss");
    integerSet.add(111);
    for (int i= 0 ; i<15;i++){
        stringSet.add("ssssss"+i);
        integerSet.add(i);
        stringSet1.add("jack"+i);
    }
    integerSet.add(111);
    stringSet.add("sss");
    stringSet.add("ssssss1");
    stringSet1.add("ajack");
    Log.d(TAG, stringSet.toString());
    Log.d(TAG, integerSet.toString());
    Log.d(TAG, stringSet1.toString());

    Iterator<String> iterator = stringSet.iterator();
    while (iterator.hasNext()){
        Log.d(TAG, iterator.next());
    }
}