API-集合框架（5）-Map

0--星期日1--星期一...有对应关系，对应关系的一方是有序的数字，可以将数字作为角标。public String getWeek(int num){    if(num<0 || num>7)        throw new NoWeekException(num+"没有对应的星期");    String[] weeks = {"","星期一"...."星期日"};//一张表。记录对应关系。换成List集合。    return weeks[num];}新需求："星期一"--"Monday"...."星期日"--"Sunday"也存在对应关系，没有一方是有序的数字，无法作为角标存在。咋办?0--星期日1--星期一...int index = listcn.indexOf("星期一")listen.get(index);0--Sunday1--Monday...解决中英对应问题，可以通过两个List完成。一个list中通过中文获取对应角标。在用角标到另一个英文list中获取对应的星期英文。前提：必须保证中英文对应的角标是一致的。麻烦！Collection集合一次只能存储一个元素。希望的将两个有对应关系的一次都存储进去。这样更便于操作。集合框架中是否有提供解决方案？找到了Map集合。Map集合特点；1，内部存储的都是键key值value对。2，必须要保证的键的唯一性。Map常见功能。    1，存储。v put(k,v);    2，获取。v get(k);    3，移除。v remove(k);    4，Set<k> keySet();    5，Set<Map.Entry<k,v>> entrySet();    6，Collection<v> values();Map    |--Hashtable：数据结构：哈希表。是同步的，不允许null作为键和值。被hashMap替代。        |--Properties：属性集，键和值都是字符串，而且可以结合流进行键值的操作。等到了IO流，你会更清楚。    |--HashMap：数据结构：哈希表。不是同步的，允许null作为键和值。        |--LinkedHashMap：基于链表+哈希表。可以保证map集合有序（存入和取出的顺序一致）。    |--TreeMap：数据结构：二叉树。不是同步的。可以对map集合中的键进行排序。什么时候使用map集合呢？分析问题时出现对应关系，毫不犹豫的想到map集合。如果对应关系中出现了有序的数字，想到数组。注意：如果对应关系个数不确定，还是以map为主。

Map-特点&基本使用

import java.util.HashMap;import java.util.Map;public class MapDemo {    public static void main(String[] args) {        /*         * 存储中英文星期。         * 使用map集合。         */        Map<String,String> map = new HashMap<String,String>();        //添加元素。        System.out.println(map.put("星期一", "Monday"));//      System.out.println(map.put("星期一", "Mon"));//如果键相同，值覆盖。并put方法会返回旧值。如果没有旧值就null。        //....        map.put("星期日", "Sunday");        //通过给定键获取值。        String value = map.get("星期二");//如果键 不存在，返回null，通过此判断键的是否存在。        System.out.println("value="+value);        //删除元素。根据键删除。        String s = map.remove("星期一");//获取给定键对应的值，并将该键值对从map集合删除。        System.out.println("s="+s);        System.out.println(map);    }}

Map-keySet&()&entrySet()&values()演示

import java.util.Collection;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set;public class MapDemo2 {    public static void main(String[] args) {        Map<String, String> map = new HashMap<String, String>();        map.put("星期一", "Monday");        map.put("星期日", "Sunday");        System.out.println("------------keySet方法的获取---------------");//      System.out.println(map.get("星期一"));        //怎么获取到所有的键呢？既然是所有的键，应该是一个集合，而且是一个单列集合。        //list还是set呢？应该是set，因为map集合中键需要保证唯一性。        //找到一个方法   Set<k> keySet();获取map集合中的键的set集合。        Set<String> keySet = map.keySet();        for(Iterator<String> it= keySet.iterator(); it.hasNext() ; ){            String key = it.next();            String value = map.get(key);//通过键获取对应的值。            System.out.println(key+"::"+value);        }        //使用foreach循环，进行遍历。        for(String key : keySet){            System.out.println(key+":::::"+map.get(key));        }        System.out.println("-----------entrySet方法获取----------------");        /*         * Set entrySet():将map集合中映射关系存储到了Set集合中.         * 映射关系：其实就是指键和值的对应关系。其实就是夫妻的结婚证。         * 映射关系是什么类型的呢？  Map.Entry         */        Set<Map.Entry<String,String>> entrySet = map.entrySet();        Iterator<Map.Entry<String, String>> it = entrySet.iterator();        //遍历Set中的映射关系对象。        while(it.hasNext()){            Map.Entry<String, String> me = it.next();//取到了映射关系对象。            //获取键。            String key = me.getKey();            //获取值。            String value = me.getValue();            System.out.println(key+"-----"+value);        }        /*         * 总结：map集合没有迭代器，取出元素的方式：将map集合转成单列结合，在使用单列集合的迭代器就可以了。         * map集合也不能直接被foreach循环遍历。         */        for(Map.Entry<String,String> me : map.entrySet()){            String key = me.getKey();            //获取值。            String value = me.getValue();            System.out.println(key+"--------"+value);        }        System.out.println("-----------获取所有值的方法 values()----------------");        /*         * 获取所有的值，因为值不需要保证唯一性。所以返回类型时Collection。         * 姓名--归属地。对应关系，获取所有的归属地。values();         */        //所有的英文星期。        Collection<String> values = map.values();        for(String value : values){            System.out.println("value:"+value);        }    }}//interface MyMap{//  public static interface MyEntry{}//内部接口。//}

domain-Student

public class Student implements Comparable<Student> {    private String name;    private int age;    public Student() {        super();    }    public Student(String name, int age) {        super();        this.name = name;        this.age = age;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    @Override    public int hashCode() {        final int prime = 31;        int result = 1;        result = prime * result + age;        result = prime * result + ((name == null) ? 0 : name.hashCode());        return result;    }    @Override    public boolean equals(Object obj) {        if (this == obj)            return true;        if (obj == null)            return false;        if (getClass() != obj.getClass())            return false;        Student other = (Student) obj;        if (age != other.age)            return false;        if (name == null) {            if (other.name != null)                return false;        } else if (!name.equals(other.name))            return false;        return true;    }    @Override    public String toString() {        return "Student [name=" + name + ", age=" + age + "]";    }    @Override    public int compareTo(Student o) {        int temp = this.age - o.age;        return temp==0?this.name.compareTo(o.name):temp;    }}

Map-HashMap存储自定义键值

往HashMap中存储学生对象(姓名，年龄)—归属地对应关系。

import java.util.HashMap;import java.util.Map;import cn.itcast.domain.Student;public class HashMapTest {    public static void main(String[] args) {        /*         * 练习一：         * 学生对象(姓名，年龄)都有自己的归属地，既然有对应关系。         * 将学生对象和归属地存储到map集合中。         * 注意：同姓名同年龄视为重复的键。         */        //1,创建hashmap集合对象。        Map<Student,String> map = new HashMap<Student,String>();        //2,添加元素。        map.put(new Student("lisi",28), "上海");        map.put(new Student("wangwu",22), "北京");        map.put(new Student("zhaoliu",24), "成都");        map.put(new Student("zhouqi",25), "广州");        map.put(new Student("wangwu",22), "南京");        //3,取出元素。keySet  entrySet//      Set<Student> keySet = map.keySet();//      for(Student key : keySet){}        for(Student key : map.keySet()){            String value = map.get(key);            System.out.println(key.toString()+"....."+value);        }    }}

import java.util.Comparator;import cn.itcast.domain.Student;public class ComparatorByName implements Comparator<Student> {    @Override    public int compare(Student o1, Student o2) {        int temp = o1.getName().compareTo(o2.getName());        return temp==0?o1.getAge() - o2.getAge() : temp;    }}

Map-TreeMap存储自定义键值

对Map中存储学生对象(姓名，年龄)—归属地对应关系。

import java.util.Map;import java.util.TreeMap;import cn.itcast.api.c.comparator.ComparatorByName;import cn.itcast.domain.Student;public class TreeMapTest {    public static void main(String[] args) {        /*         * 练习二： 学生对象(姓名，年龄)都有自己的归属地，既然有对应关系。 将学生对象和归属地存储到map集合中。         * 注意：同姓名同年龄视为重复的键。 按照学生的年龄进行从小到大的排序。 TreeMap。         *          * 如果要对学生按照姓名排序呢？         */        // 1,创建TreeMap集合对象。        Map<Student, String> map = new TreeMap<Student, String>(new ComparatorByName());        // 2,添加元素。        map.put(new Student("lisi", 28), "上海");        map.put(new Student("wangwu", 22), "北京");        map.put(new Student("zhaoliu", 24), "成都");        map.put(new Student("zhouqi", 25), "广州");        map.put(new Student("wangwu", 22), "南京");        //3,取出所有元素，entrySet()        for(Map.Entry<Student, String> me : map.entrySet()){            Student key = me.getKey();            String value = me.getValue();            System.out.println(key+"::"+value);        }    }}

Test

“werertrtyuifgkiryuiop”,获取字符串中每一个字母出现的次数。
要求返回结果个格式是 a(1)b(2)d(4)……;

import java.util.Map;import java.util.TreeMap;public class MapTest {    public static void main(String[] args) {        /*         * 练习：         * "werertrtyuifgkiryuiop",获取字符串中每一个字母出现的次数。         * 要求返回结果个格式是  a(1)b(2)d(4)......;         * 思路：         * 1，获取到字符串中的每一个字母。         * 2，用字母取查表，如果查到了该字母对应的次数，就将这个次数+1后重新存回表中。         *  如果没有查到呢？将该字母和1存到表中。         * 3，每一字母都查完表后，表中记录的就是所有字母出现的次数。         *          * 字母和次数之间存在对应关系，而且字母是唯一性的，所以可以使用map集合做表进行查询。         * 通过结果发现 字母有顺序的，所以可以通过map集合中的treemap作为表。         *          */        String str = "awaa+acr=ebarct,btydui[efgkiryuiop";        str = getCharCount(str);        System.out.println(str);    }    /**     * 获取字符串中的字母出现次数。     *      * @param str     * @return 返回一个每一个字母对应次数的字符串 格式  char1(count)char2(count).....;     */    public static String getCharCount(String str) {        //1，将字符串转成字符数组。        char[] chs = str.toCharArray();        //2，定义表。treemap.        TreeMap<Character, Integer> map = new TreeMap<Character, Integer>();        //3，遍历字符数组。        for (int i = 0; i < chs.length; i++) {            //判断必须是字母。            if(!(chs[i]>='a' && chs[i]<='z' || chs[i]>='A' && chs[i]<='Z')){                continue;            }            //4，将遍历到的字母作为键去查map这个表。获取对应的次数。            Integer value = map.get(chs[i]);            //5，有可能要查询的字母在表中不存在对应的次数，需要判断。            //如果返回是null，说明字母没有对应的次数。就将这个字母和1存储到表中。            if(value == null){                //将字母和1存储。                map.put(chs[i],1);            }else{                //否则，说明有对应的次数对次数自增。将字母和新的次数存储到表中。                value++;                map.put(chs[i],value);            }            /*             //两个if判断，选择哪个都行。            int count = 0;            if(value!=null){                count = value;//用count记录次数。            }            count++;//自增。            map.put(chs[i], count);            */        }        //将map集合中的键值转成   格式是  a(1)b(2)d(4)......        return mapToString(map);    }    /*     * 将map集合中的键值转成   格式是  a(1)b(2)d(4)......     * map中有很多数据，无论是多少个，什么类型，最终都变成字符串。     * StringBuffer 这个容器就符合这个需求。如果是单线程，建议使用StringBuilder。     *      */    private static String mapToString(Map<Character, Integer> map) {        //1，明确容器。        StringBuilder sb = new StringBuilder();        //2,遍历map集合。        for(Character key  : map.keySet()){            Integer value = map.get(key);            sb.append(key+"("+value+")");        }        return sb.toString();    }}

API-JDK1.5-可变参数

public class ParamDemo {    /**     * @param args     */    public static void main(String[] args) {//      int[] arr = {34,12,89};//      int sum = add(arr);//      System.out.println("sum="+sum);//      int[] arr1 = {23,11,44,55,66};//先创建数组，再将这个数组作为实参传递给add方法。//      int sum1 = add(arr1);//      System.out.println("sum1="+sum1);        //jdk1.5以后。出现了简化操作。... 用在参数上，称之为可变参数。        //同样是代表数组，但是在调用这个带有可变参数的函数时，不用创建数组(这就是简单之处)，直接        //将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些实参先封装到一个数组中，在进行传递。        //这些动作编译器在生产class时，都帮你完成了。        int sum = add(34,12,89);        System.out.println("sum="+sum);        int sum1 = add(23,11,44,55,66);        System.out.println("sum1="+sum1);        //注意事项：记录可变参数一定要定义在参数列表最后。        //public static int add(int a,int...  arr)    }    public static int add(int...  arr){// 数组参数的简化表现形式。 ... 代表很多int类型数据。        int sum = 0;        for (int i = 0; i < arr.length; i++) {            sum += arr[i];        }        return sum;    }    /*    // 求多个整数的和。    public static int add(int[] arr){        int sum = 0;        for (int i = 0; i < arr.length; i++) {            sum += arr[i];        }        return sum;    }    */    // 求两个整数的和。    public static int add(int a, int b) {        return a + b;    }    // 求三个整数的和。    public static int add(int a,int b,int c){        return a + b + c;    }}

API-JDK1.5-静态导入

import java.util.List;import java.util.ArrayList;import static java.util.Collections.*;//静态导入，导入是指定的类中的静态成员。import static java.lang.System.*;public class StaticImportDemo {    /**     * @param args     */    public static void main(String[] args) {        List<String> list = new ArrayList<String>();        max(list);        min(list);        out.println("hello itcast");    }}