java集合（二）

TreeMap tmp=new TreeMap();

Iterator iterator_2 = tmp.keySet().iterator();

while (iterator_2.hasNext()) {   

        Object key = iterator_2.next();   

        System.out.println(“tmp.get(key) is :”+tmp.get(key));  
}

package HashMap类的常用方法;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
//1.继承关系        Map接口定义了键映射到值的规则，而AbstractMap类提供 Map 接口的骨干实现。
/*        public class HashMap<K,V>
        extends AbstractMap<K,V>
        implements Map<K,V>, Cloneable, Serializable        
*/
//2.构造函数  涉及到底层原理，暂时不做解释
/*        HashMap()：构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。
        HashMap(int initialCapacity)：构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。
        HashMap(int initialCapacity, float loadFactor)：构造一个带指定初始容量和加载因子的空 HashMap。
*/
//3.实现了Map接口的常用方法
/*      1. Set entrySet()  (返回当前Map中所有的entry对象(Entry对象就包装了key，values)，使用Set存储起来。)
       2. Set keySet()    返回Map当中所有的key，存储到一个Set集合当中。
      3. Collection values()    返回所有的values，存储到一个Collection。什么返回Collection？
                                因为values 有重复，如果返回Set,就不能含有重复的元素.

      4. Object get(Object key)  通过key查找对应的值。
 */
//举例：
        Map map = new HashMap();
        map.put(1, "我好");
        map.put(2, "你好");
        map.put(3, "大家好");
        map.put(4, "啦啦啦");
        map.put(5, "么么哒");
/*        
        Set set  = map.entrySet();
        System.out.println(set);    // [1=我好, 2=你好, 3=大家好, 4=啦啦啦, 5=么么哒]
        
        Set keys = map.keySet();
        System.out.println(keys);  // [1, 2, 3, 4, 5]
        
        Collection col = map.values();
        System.out.println(col);   // [我好, 你好, 大家好, 啦啦啦, 么么哒]
        
        Object obj= map.get(5);
        System.out.println(obj);   //么么哒
*/        
//5.Map的遍历方式
/*        前言：  1. 不能使用普通for循环遍历Map元素，因为没有索引。
               2. 使用增强for行不行？ 不能，没有实现Iterable接口，foreach就是通过Iterable接口在序列中进行移动。
               3. Map里面并没有获得迭代器的方法；所有不能使用迭代器
      方式一：
          先通过keySet()方法取到所有key
        然后遍历keySet,依次通过Object get(Object key)方法,来查找value。
*/
        Set keys = map.keySet();
        for (Object object : keys) {
            System.out.print(object+":"+map.get(object));// "1:我好2:你好3:大家好4:啦啦啦5:么么哒"
        }
/*  方式二：
         先得到所有的Entry对象，遍历Entry对象的集合，然后依次从Entry对象中调用方法：getKey()，getValue() 
 */
        Set set  = map.entrySet();
        for (Object object : set) {
            Entry obj = (Entry)object;  //需要把Object强制转成 Entry类型
            System.out.print(obj.getKey()+":"+obj.getValue());// "1:我好2:你好3:大家好4:啦啦啦5:么么哒"
        }
//6.使用Map集合解决：打印 字符串中 出现最多字符的  次数
/*    实例：Map使用示例: 有如下字符串，String str = “aaaabbbyyyccc”;
         *    1.统计出str中每一个字符的个数   比如 a - 4    b - 3
         *    2.找出并打印，次数最多的字符和次数
*/
/*
     public class Test {
    public static void main(String[] args) {
        String str = "aaaabbbyyyccc";
        Map map = getChar(str);
        System.out.println(map);
        System.out.println(getCharAndValue(map));
    }
//统计每个字符出现的次数，并存储到map集合中
    public static Map getChar(String str){
        Map map = null;
        if(str!=null&&str.length()>0){
            map = new HashMap();
            for(char ch:str.toCharArray()){
                if(map.containsKey(ch)){
                    map.put(ch, (int)map.get(ch)+1);
                }else{
                    map.put(ch, 1);
                }
            }
        }
        return map;
    }
// 打印次数最多的字符和次数 。    
    public static String getCharAndValue(Map map){
        if(map!=null&&map.size()!=0){
            Collection values = map.values();
            
        //方法一： 直接调用Collections里面的max方法    
            int max = (int)Collections.max(values);
            
        //方法二：用Collection中的toArray方法,把Collection转换成数组，然后调用Arrays中的工具方法sort求出
        //    Object[] arr = values.toArray();
        //    Arrays.sort(arr);
        //    int max = (int)arr[arr.length-1];
            
            String str = "";
            Set set = map.keySet();
            for(Object obj : set){
                if(map.get(obj).equals(max)){
                    str = obj + ":"+max;
                }
            }
            return str;
        }
        return null;
    }
}
*/              
    }
}