java-Map-system

一 概述

0--星期日
1--星期一
...

有对应关系，对应关系的一方是有序的数字，可以将数字作为角标。

public String getWeek(int num){

if(num<0 || num>7)
throw new NoWeekException(num+"没有对应的星期");
String[] weeks = {"","星期一"...."星期日"};//一张表。记录对应关系。换成List集合。

return weeks[num];
}

新需求：
"星期一"--"Monday"
....
"星期日"--"Sunday"

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();

2.1 存储 获取 移除

package cn.itcast.api.a.map;

import java.util.HashMap;
import java.util.Map;

public class MapDemo {

    /**
     * @param args
     */
    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);
    }

}

2.2 keySet()

    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));
        }

2.3 entrySet()

    Map<String, String> map = new HashMap<String, String>();

        map.put("星期一", "Monday");
        map.put("星期日", "Sunday");
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);
        }

2.4 values

        System.out.println("-----------获取所有值的方法 values()----------------");
        /*
         * 获取所有的值，因为值不需要保证唯一性。所以返回类型时Collection。
         * 姓名--归属地。对应关系，获取所有的归属地。values();
         */

        //所有的英文星期。
        Collection<String> values = map.values();
        for(String value : values){
            System.out.println("value:"+value);
        }

三 常见子类

Map
|--Hashtable：数据结构：哈希表。是同步的，不允许null作为键和值。被hashMap替代。
|--Properties：属性集，键和值都是字符串，而且可以结合流进行键值的操作。等到了IO流，你会更清楚。
|--HashMap：数据结构：哈希表。不是同步的，允许null作为键和值。
|--LinkedHashMap：基于链表+哈希表。可以保证map集合有序（存入和取出的顺序一致）。
|--TreeMap：数据结构：二叉树。不是同步的。可以对map集合中的键进行排序。

3.1 Hashmap

package cn.itcast.api.b.map.subclass;

import java.util.HashMap;
import java.util.Map;

import cn.itcast.domain.Student;

public class HashMapTest {

    /**
     * @param args
     */
    public static void main(String[] args) {

        /*
         * 练习一：
         * 学生对象(姓名，年龄)都有自己的归属地，既然有对应关系。
         * 将学生对象和归属地存储到map集合中。
         * 注意：同姓名同年龄视为重复的键。
         */

        //1,创建hashmap集合对象。
        Map<Student,String> map = new HashMap<Student,String>();

        //2,添加元素。
        map.put(new Student("lisi",), "上海");
        map.put(new Student("wangwu",), "北京");
        map.put(new Student("zhaoliu",), "成都");
        map.put(new Student("zhouqi",), "广州");
        map.put(new Student("wangwu",), "南京");

        //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);
        }

    }

}

3.2 TreeMap

package cn.itcast.api.b.map.subclass;

import java.util.Map;
import java.util.TreeMap;

import cn.itcast.api.c.comparator.ComparatorByName;
import cn.itcast.domain.Student;

public class TreeMapTest {

    /**
     * @param args
     */
    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", ), "上海");
        map.put(new Student("wangwu", ), "北京");
        map.put(new Student("zhaoliu", ), "成都");
        map.put(new Student("zhouqi", ), "广州");
        map.put(new Student("wangwu", ), "南京");

        //3,取出所有元素，entrySet()
        for(Map.Entry<Student, String> me : map.entrySet()){

            Student key = me.getKey();
            String value = me.getValue();

            System.out.println(key+"::"+value);

        }

    }

}

3.3 练习-字母次数

package cn.itcast.api.d.test;

import java.util.Map;
import java.util.TreeMap;

public class MapTest {

    /**
     * @param args
     */
    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 = ; 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],);
            }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();
    }
}

什么时候使用map集合呢？
分析问题时出现对应关系，毫不犹豫的想到map集合。
如果对应关系中出现了有序的数字，想到数组。
注意：如果对应关系个数不确定，还是以map为主。

四  jdk1.5

4.1 可变参数

package cn.itcast.api.e.jdk5;

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(,,);
        System.out.println("sum="+sum);

        int sum1 = add(,,,,);
        System.out.println("sum1="+sum1);

        //注意事项：记录可变参数一定要定义在参数列表最后。
        //public static int add(int a,int...  arr)
    }

    public static int add(int...  arr){// 数组参数的简化表现形式。 ... 代表很多int类型数据。
        int sum = ;
        for (int i = ; 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;
    }

}

4.2 静态导入

package cn.itcast.api.e.jdk5;

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");

    }

}

五 system

4.1 system

package cn.itcast.api.f.otherapi;

import java.util.Properties;
import java.util.Set;

public class SystemDemo {

    private static final String LINE_SEPARATOR = System.getProperty("line.separator");

    /**
     * @param args
     */
    public static void main(String[] args) {

        /*
         * System:
         * 1，不需要实例化，都是静态的属性和方法。
         * 2，out对应标准输出流(显示器)，int属性对应的是键盘。
         * 演示一些System类中的方法。
         * currentTimeMilles:获取当前时间。可以用于计算程序运行时间只要将开始时间和结束时间相减即可。
         */

        long time = System.currentTimeMillis();
        System.out.println(time);//毫秒值。1382691495296

        //演示getProperties()获取系统属性集。
        Properties prop = System.getProperties();

        //获取系统属性集中的信息，遍历Properties集合。使用map的方法没问题，但是map有泛型取出时要强转。
        //Properties有没有提供自身获取数据的方法呢？
        //获取键集合。
//        Set<String> keySet = prop.stringPropertyNames();
//        for(String key : keySet){
//            String value = prop.getProperty(key);//通过键获取值。
//            System.out.println(key+"::::"+value);
//        }

        //获取指定信息，比如：操作系统。
        String osname =System.getProperty("os.name");
        System.out.println(osname);

        //获取系统中的行分隔符。这样该程序在移植时，很方便。不同的系统，获取该系统上行分隔符
        System.out.println("hello"+LINE_SEPARATOR+"itcast");

    }

}

4.2 Math

package cn.itcast.api.f.otherapi;

import java.util.Random;

public class MathDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        /*
         * Math数序运算。方法都是静态的。
         * Math.PI
         */

//        Math.abs(-4);

        double d1 = Math.ceil(-12.34); //获取参数右边的整数   //11 12floor 12.34  ceil13  14  15
        double d2 = Math.floor(12.34);//获取参数左边的整数。
        double d3 = Math.round(12.54);//四舍五入。
//        System.out.println("d1="+d1);//13
//        System.out.println("d2="+d2);//12
//        System.out.println("d3="+d3);

//        System.out.println(Math.pow(10,3));

        Random r = new Random();
        for(int x=; x<; x++){
//            int d = (int)(Math.random()*6 + 1);
//            double d = Math.ceil(Math.random()*6);

            int num  = r.nextInt()+;
            System.out.println(num);
        }

    }

}