11.集合Map

 

一,TreeSet

TreeSet是一种可以指定顺序的Set集合,指定顺序的方式有两种,自然顺序(Comparable,比较器(Comparator);

1,Comparable  :  在要放入TreeSet集合的类上实现Comparable接口,重写compareTo方法,对象存入TreeSet的时候就会按照compareTo()方法排序;

2,Comparator  :  如果两个TreeSet存储同一类型对象,需要使用不同顺序,那么Comparable接口就无法满足这样的需求了,compareTo()方法只有一个,无法定义两种比较方法;,

如果不希望TreeSet按照Comparable的顺序排序,可以再创建TreeSet的时候,在构造杉树中传入一个比较器,

创建TreeSet对象时,构造函数可以接收一个Comparator类型的对象;

我们可以自定义一个Comparator类的子类,重写Compare()方法;

一旦构造函数中传入了Comparator,TreeSet将不再按照Comparable中的顺序排序,add()方法执行时自动按照Comparator的顺序排序;

二,集合分类:

Collection:单列集合,一次存一个对象,

List: 可重复,有索引

LinkedList:链表结构,查找慢,增删快

ArrayList :数组结构,查找快,增删慢;

Vector:  原理和ArrayList相同,线程安全,效率低,被ArrayList取代,java1.0出现的

              特有方法:枚举;

Stack:   栈,先存的对象最后才能被取出;

Set: 不重复,无索引

*HashSet: 使用哈希算法,除去重复,速度快

*TreeSet: 使用二叉树算法,按照指定顺序排序,指定顺序的方式有:自然排序,比较器

LinkedHashSet: HashSet的子类,也是使用哈希算法,但可以保留原存储顺序;

Map: 双列集合;键值对,一次存两个对象,键唯一,可以根据键查找值

*HashMap: 使用哈希算法对键对象除去重复;

*TreeMap : 使用二叉树算法对键对象排序;

LinkedHashMap: HashMap的子类,除去重复的同时保留存储顺序

Hashtable:     : 和HashMap原理相同,都是使用哈希算法除去重复,线程安全,效率较低,不允许键和值为null,被HashMap取代;

Properties:     : 键和值都是String,用来存储一些配置项;

三:Map集合:

Map集合用来存储键值对,每次存储2个对象,一个键一个值,形成映射关系,可以根据键查找值,键必须唯一;

*Map集合常用方法:

V put(K key,V value)

存储一个键值对,如果键在集合中存在,值将会覆盖原有值,且返回原有值;如果不存在,直接存,返回null;

V get(Object key)

根据键获取值,如果不存在,返回null

V remove(Object key)

根据键删除值,并将值返回,如果不存在,返回null

Boolean containsKey(Object key)

判断指定的键对象是否存在;

举例:

package cn.itcast;

 

import java.util.HashMap;

import java.util.Map;

 

publicclass Test {

 

   publicstaticvoid main(String[] args) {

      // TODO Auto-generated method stub

      //put();

      //contains();

      //putAll();

      //remove();

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

      map.put("秦琼", 89);

      map.put("程咬金",90);

      map.put("隋炀帝", 50);

      System.out.println(map.put("秦琼", 9));

      System.out.println(map.put("袁绍", 34));

   }

 

   publicstaticvoid remove() {

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

      map.put("秦琼", 89);

      map.put("程咬金",90);

      map.put("隋炀帝", 50);

      System.out.println(map.remove("秦琼"));

      System.out.println(map.remove(78));

   }

 

   publicstaticvoid putAll() {

      Map<String,Integer> map1 = new HashMap<String,Integer>();

      map1.put("秦琼", 89);

      map1.put("程咬金",90);

      map1.put("隋炀帝", 50);

      Map<String,Integer>map2 = new HashMap<String,Integer>();

      map2.put("秦琼", 999);

      map2.put("程咬金",9);

      map2.put("宇文画戟", 50);

      //putAll:将map2集合中所有元素装入map1中;

      map1.putAll(map2);

      System.out.println(map1);

   }

 

   publicstaticvoid contains() {

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

      map.put("秦琼", 89);

      map.put("程咬金",90);

      map.put("隋炀帝", 50);

      System.out.println(map.containsKey(90));

      //boolean类型,判断集合是否包含指定键,

      System.out.println(map.containsKey("秦琼"));

      //boolean类型,判断集合是否包含指定值;

      System.out.println(map.containsValue(90));

      System.out.println(map.containsValue("秦琼"));

   }

 

   publicstaticvoid put() {

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

      //使用put,指定键与值之间发生映射关系;

      map.put("曹操",90);

      map.put("孙权",null);

      map.put("赵云", 90);

      System.out.println(map);

      //打印集合长度;

      System.out.println(map.size());

      //清空map集合;

      map.clear();

      //判断集合是否为空,空则返回true;

      System.out.println(map.isEmpty());

      System.out.println(map.size());

      //结果是Boolean型,如果包含指定键,返回true;

      System.out.println(map.containsKey("庞统"));

      System.out.println(map.containsValue(90));

   }

 

}

 

*Map集合遍历的两种方式:

**keySet:

Map集合的keySet()方法可以得到一个所有键对象组成的Set集合;

遍历这个Set集合可以得到每一个键对象;

再根据键对象即可获取所映射的值;

**entrySet :

Map集合的entrySet()方法可以得到一个Map.Entry对象(键值对)组成的set集合

遍历这个Set集合可以得到每一个Map.Entry对象

再使用Map.Entry的getKey ()方法和getValue方法获取键和值;

       例:

package Map;

importjava.util.HashMap;

publicclass MapIteratorDemo {

/**取出map集合中的键值对,有2中方式;keySet和entrySet

    * @param args

    */

   publicstaticvoid main(String[] args) {

      //TODOAuto-generated method stub

   //keySet();

      entrySet();

   }

publicstaticvoid entrySet() {

      Map<String,Integer> hs = new HashMap<String,Integer>();

      hs.put("aaa", 1);

      hs.put("xxx", 4);

      hs.put("abc", 3);

      //map集合的entrySet方法可以得到一个所有entry(键值对映射关系)组成的set集合

      Set<Map.Entry<String,Integer>> s = hs.entrySet();

      //遍历set集合可以得到每一个entry对象;

      Iterator<Map.Entry<String,Integer>> it = s.iterator();

      while(it.hasNext()) {

         Map.Entry<String,Integer> e =it.next();

      //在使用entry的getkey和getvalue获取键和值

         if(e.getKey().equals("aaa"))

            e.setValue(100);

         System.out.println(e.getKey() +"..."+ e.getValue());

      }

      /*

      //使用增强for循环.

      Set<Entry<String, Integer>> s= hs.entrySet();

      for(Entry<String,Integer> e: s) {

         System.out.println(e.getKey()+">>"+e.getValue());

      }

       */

   }

 

   publicstaticvoid keySet() {

      Map<String,Integer> hs = new HashMap<String,Integer>();

      hs.put("aaa", 1);

      hs.put("xxx", 4);

      hs.put("abc", 3);

      Set<String> s = hs.keySet();

      //使用迭代器的方法取出map集合中键值对;

      Iterator<String> it = s.iterator();

      while(it.hasNext()) {

         String key = it.next();

         Integer value = hs.get(key);

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

      }

      /*

      //Map集合的keySet方法可以得到每一个键对象所组成的Set集合

      Set<String> s = hs.keySet();

      //使用增强for循环取出键对象;

      for(String str : s)

         //根据键获取值;

         System.out.println(str+"="+hs.get(str));

      */

   }

 

}

Map常用类:

       |--HashMap：底层是哈希表数据结构，允许使用 null值和 null键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。

       |--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

Map集合扩展:一键对多值;map集合被使用是因为具备映射关系;

       例:

package Map;

importjava.util.*;

publicclass MapDemo3 {

 

   /**

    * map集合扩展:一键对多值;并打印处键和值;

   *  例:基础班,学号,姓名;

    *"base","01","张三";

    *"base","02","李四";

      就业班,学号,名字;

    *"work","01","王五";

    *"work","02","赵六";

    *

    * @param args

    */

   publicstaticvoid main(String[] args) {

      //将学号和姓名形成映射关系,装入一个班级Map集合中;再将班级名称和班级集合形成映射关系,装进另一个Map集合中;

      demo1();

 

      //创建一个学生类,将学号和姓名封装进学生类中,将学生类装入一个List集合中,再将班级名称和List集合形成映射关系,装进一个Map集合中;这种方式比较常见,如.一个公司,有不同部门,部门中有不同的员工;这就是一键对多值关系;

      demo2();

   }

 

   publicstaticvoid demo2() {

      //将学生的信息封装在Studen里,

      List<Studen> base = new ArrayList<Studen>();

      //向集合中添加对象;

      base.add(new Studen("01","张三"));

      base.add(new Studen("02","李四"));

      List<Studen> work = new ArrayList<Studen>();

      work.add(new Studen("01","王五"));

      work.add(new Studen("02","赵六"));

     

      HashMap<String,List<Studen>>hs =newHashMap<String,List<Studen>>();

      //向hs集合中添加键值对;

      hs.put("base", base);

      hs.put("work", work);

     

      //将集合中的key组成set集合;

      Set<String> set = hs.keySet();

      //使用增强for循环,取出hs集合中的key组成的set集合元素;

      for(String str :set) {

         //打印hs集合中的键值;

         System.out.println(str);

        

         //将遍历到的键所映射的值再次遍历;因为是List集合,不是map集合,所以不用keyset和entrySet方法转换,直接遍历

         for(Studen s: hs.get(str))

            //打印num和name;

            System.out.println(s);

      }

   }

 

   publicstaticvoid demo1() {

      //基础班的集合对象;

      HashMap<String, String> base =new HashMap<String, String>();

      //向集合中添加学号和名字;

      base.put("01","张三");

      base.put("02","李四");

     

      //就业班的集合对象;

      HashMap<String, String> work =new HashMap<String, String>();

      work.put("01","王五");

      work.put("02","赵六");

     

      //学校的集合对象;包括班级名字和班级内的学员;

     HashMap<String, HashMap<String,String>> hs =newHashMap<String, HashMap<String, String>>();

      //向集合中添加班级名字和班级的集合对象;

      hs.put("base", base);

      hs.put("work", work);

     

      //使用迭代器方法取出学校中所有的班级和学员;采用循环嵌套循环的形式;

      //使用hs集合的entrySet方法调用Map.Entry类,得到hs集合的所有映射关系;再使用迭代器遍历每一个映射关系;

      Iterator<Entry<String,HashMap<String,String>>>it = hs.entrySet().iterator();

      while(it.hasNext())  {

         //定义变量记住键值对;

         Entry<String,HashMap<String,String>>e = it.next();

         //打印班级名称;

         System.out.println(e.getKey()+"----");

        

         //使用迭代器取出班级中的键值对;

         //使用遍历到的班级名称所对应的班级,调用keySet方法,使用迭代器获取班级中的键所组成的集合的对象;

         Iterator<String> iter =e.getValue().keySet().iterator();

         while(iter.hasNext()) {

            //定义变量记住遍历到的键;

            String s = iter.next();

            //打印键和值;

            System.out.println(s +":::"+e.getValue().get(s));

         }

      }

   }

 

}

class Studen {

   private Stringname;

   private Stringnum;

   Studen(String num,String name) {

      this.num = num;

      this.name = name;

   }

   public String toString() {

      returnnum +"->"+name;

   }

}