常用对象API（集和框架--Map）

import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.HashMap;
/**
 * Map：一次添加一对元素，Collection一次添加一个元素。
 *      Map也称为双列集和，Collection集和称为单列集和。
 *      Map集和中存储的就是键值对。
 *      Map集和中必须保证键的唯一性
 * 常用方法：
 *      1.添加
 *          value put(key,value);返回前一个和key关联的值，如果没有返回null
 *      2.删除
 *          void clear();清空map集和
 *          value remove(key);根据指定的key删除这个键值对
 *      3.判断
 *          boolean containsKey(key);
 *          boolean contaionsValue(value);
 *          boolean isEmpty();
 *      4.获取
 *          value get(key);通过键获取值，如果没有该键返回null
 *                          当然可以通过返回null来判断是否包含该键
 *          int size();获取键值对的个数。
 * Map常用子类：
 *      Hashtable:内部结构是哈希表，是同步的，不允许null作为键，null作为值。
 *          Properties：用来存储键值对型的配置文件信息。可以和io技术相结合。
 *      HashMap:内部结构是哈希表，不是同步的，允许null作为键，null作为值。
 *      TreeMap:内部结构是二叉树，不是同步的，可以对Map集和的键进行排序
 */
/**
 * 比较器
 */
class ComparatorByName implements Comparator<Student>{
    public int compare(Student s1,Student s2) {
        int temp = s1.name.compareTo(s2.name);
        return temp==0?s1.age-s2.age:temp;
    }
}
class Student implements Comparable{
    String name;
    int age;
    Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    public int compareTo(Object obj) {
        Student p = (Student)obj;
        if(this.age>p.age)
            return 1;
        else if(this.age<p.age)
            return -1;
        return this.name.compareTo(p.name);//为了在set存放对象时不因为年龄相同视为同一对象不存储
        // int temp = this.age-p.age;
        // return temp==0?this.name.compareTo(p.name):temp;
    }
}
public class packDemo{
    public static void main(String[] args){
        Map<Integer,String> map = new HashMap<Integer,String>();
        TreeMapDemo();
    }
    /*
    map基础操作
    */
    public static void mapDemo(Map<Integer,String> map) {//学号和姓名
        //1.添加元素
        System.out.println(map.put(8, "kpp"));//null
        System.out.println(map.put(8, "zzz"));//kpp  存相同键，值会覆盖
        System.out.println(map.put(12, "qw"));
        map.put(2, "xy");
        //2.删除
        System.out.println("remove:"+map.remove(12));//remove:qw
        //3.判断
        System.out.println("containsKey:"+map.containsKey(8));//containsKey:true
        System.out.println("containsValue:"+map.containsValue("xy"));//containsValue:true
        //4.获取
        System.out.println("get:"+map.get(2));//get:xy
        System.out.println(map);//{8=zzz}
    }
    /*
    输出map中每个键值对
    */
    public static void mapDemo2(Map<Integer,String> map){
        map.put(8, "pp");
        map.put(7, "zz");
        map.put(12, "xx");
        map.put(1, "mm");
        //取出map中的所有元素
        //原理：通过keySet方法获取map中所有的键所在的Set集和，在通过Set的迭代器获取到每一个键
        //再对每一个键通过map集和的get方法获取其对应的值即可。
        Set<Integer> keySet = map.keySet();
        Iterator<Integer> it = keySet.iterator();
        while(it.hasNext()){
            Integer key = it.next();
            String value = map.get(key);
            System.out.println(key+"::"+value);
        }
        // 1::mm
        // 7::zz
        // 8::pp
        // 12::xx
        /*
        通过map转成Set就可以迭代。
        找到了另一个方法。entrySet。
        该方法将键和值的映射关系作为对象存储到了Set集和中，而这个映射关系的类型就是Map.Entry类型(结婚证)
        */
        Set<Map.Entry<Integer,String>> entrySet = map.entrySet();
        Iterator<Map.Entry<Integer,String>> i = entrySet.iterator();
        while(i.hasNext()){
            Map.Entry<Integer,String> me = i.next();
            Integer key = me.getKey();
            String value = me.getValue();
            System.out.println(key+"::"+value);
        }
        // 1::mm
        // 7::zz
        // 8::pp
        // 12::xx
        /*
        方法values演示
        */
        Collection<String> values = map.values();
        Iterator<String> i1 = values.iterator();
        while(i1.hasNext()){
            System.out.println(i1.next());
        }
        // mm
        // zz
        // pp
        // xx
    }
    /*
    HashMap存储自定义对象  不能排序
    将学生对象和学生的归属地通过键与值存储到map集和中。
    */
    public static void HashMapDemo_3(){
        HashMap<Student,String> hm = new HashMap<Student,String>();
        hm.put(new Student("ww", 25), "beijing");
        hm.put(new Student("zz", 23), "sichuan");
        hm.put(new Student("pp", 24), "sichuan");
        hm.put(new Student("ss", 25), "chengdu");
        Set<Student> keySet = hm.keySet();
        Iterator<Student> it = keySet.iterator();
        while(it.hasNext()){
            Student stu = it.next();
            String add = hm.get(stu);
            System.out.println(stu.name+":"+stu.age+"---"+add);
        }
    }
    // pp:24---sichuan
    // ss:25---chengdu
    // ww:25---beijing
    // zz:23---sichuan
    /*
    TreeMap存储自定义对象  可以排序
    */
    public static void TreeMapDemo(){
        // TreeMap<Student,String> tm = new TreeMap<Student,String>();//通过Student类的compareTo方法比较
        TreeMap<Student,String> tm = new TreeMap<Student,String>(new ComparatorByName());//通过比较器比较
        tm.put(new Student("ww", 25), "beijing");
        tm.put(new Student("zz", 23), "sichuan");
        tm.put(new Student("pp", 24), "sichuan");
        tm.put(new Student("ss", 25), "chengdu");
        // Set<Student> keySet = tm.keySet();
        // Iterator<Student> it = keySet.iterator();
        Iterator<Map.Entry<Student,String>> it = tm.entrySet().iterator();
        while(it.hasNext()){
            // Student stu = it.next();
            // String add = tm.get(stu);
            Map.Entry<Student,String> me = it.next();
            String add = me.getValue();
            Student stu = me.getKey();
            System.out.println(stu.name+":"+stu.age+"---"+add);
        }
    }
}

Map集和的使用

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;


public class packDemo{
    public static void main(String[] args){
        hashMap_Demo_2();
    }
    public static void hashMap_Demo(){
        // HashMap<Integer,String> hm = new HashMap<Integer,String>();
        HashMap<Integer,String> hm = new LinkedHashMap<Integer,String>();
        hm.put(7, "pp");
        hm.put(6, "dd");
        hm.put(5, "xx");
        Iterator<Map.Entry<Integer,String>> it = hm.entrySet().iterator();
        while(it.hasNext()){
            Map.Entry<Integer,String> me = it.next();
            Integer key = me.getKey();
            String value = me.getValue();
            System.out.println(key+"::"+value);
        }
    }
    /**
     * 练习：
     * "daskjdjkjiusiew"获取该字符串中，每一个字母出现的次数。
     * 要求打印结果是：a(1)b(2)...
     * 思路：
     * 对于结果的分析发现，字母和次数之间存在着映射关系，而且这种关系很多，
     * 很多就需要存储，能存储映射关系的容器有数组和Map集和。
     * 关系一方式有序编号吗？不需要
     * Map集和！发现可以保证唯一性的一方具备顺序如a,b,c
     * 所以可以使用TreeMap集和。
     */
    public static void hashMap_Demo_2(){
        String str = "daskjdjkjiusiew";
        String s = getCharCount(str);
        System.out.println(s);
        System.out.println("end");
    }
    
    public static String getCharCount(String str) {
        //将字符串变成字符数组
        char[] chs = str.toCharArray();
        //定义map集和表
        Map<Character,Integer> map = new TreeMap<Character,Integer>();
        for(int i=0;i<chs.length;i++){
            //将数组中的字母作为键去查表
            Integer value = map.get(chs[i]);
            //判断值是否为null
            
            if(value==null){
                map.put(chs[i], 1);
            }else{
                map.put(chs[i], value+1);
            }
            //改进：

        }
        String res = mapToString(map);
        return res;
    }
    public static String mapToString(Map<Character,Integer> map){
        StringBuilder sb = new StringBuilder();
        Iterator<Character> it = map.keySet().iterator();
        while(it.hasNext()){
            Character key = it.next();
            Integer value = map.get(key);
            sb.append(key+"--"+value);
        }
        return sb.toString();
    }
}