07-java学习笔记-map集合

01-java学习笔记011.Map集合

Map集合：该集合存储键值对。一对一对往里存。

                 而且要保证键的唯一性。

Map<K,V>

     1. 添加     1. put(K  key,V value)

                    2. putAll(Map<? extends K,? extends V> m)

     2. 删除

                    1. clear()

                    2. remove(Object key)

     3. 判断

                    1. containsKey(Object key)

                    2. containsValue(Object   value)

                    3. isEmpty()

     4. 获取

                    1.V get(Object key)

                    2. size()

                    3. Collection<V> values()

                    entrySet()

                    keySet()

                    

Map与Collection

Map与Collection在集合框架中属并列存在

Map存储的是键值对

Map存储元素使用put方法，Collection使用add方法

Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素

Map集合中键要保证唯一性

Map集合常用类

Hashtable：线程安全（同步），速度慢，不允许存放null键，null值，已被HashMap替代。JDK1.0 效率低

HashMap：线程不安全（不同步），速度快，允许存放null 键，null值。JDK1.2 效率高

TreeMap：对键进行排序，排序原理与TreeSet 相同。

Map

     |--Hashtable  底层是哈希表数据结构 用作键的对象必须实现hashCode方法和equals方法

     |--HashMap  底层是哈希表数据结构

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

                          和Set很像

                          其实TreeSet的底层就是TreeMap

Map共性方法

import java.util.*;
class  MapDemo
{
     public static void main(String[] args)
     {
          Map<String,String> map = new HashMap<String,String>();

          //添加元素，如果添加时出现相同的键，那么后添加的值会覆盖原有键对应值。
          //并且put方法会返回被覆盖的值。
          System.out.println("put:"+map.put("01","zhangsan1"));
          System.out.println("put:"+map.put("01","wnagwu"));
          map.put("02","zhangsan2");
          map.put("03","zhangsan3");

          System.out.println("containsKey:"+map.containsKey("022"));
          //System.out.println("remove:"+map.remove("02"));

          System.out.println("get:"+map.get("023"));

          map.put("04",null);//没有意义
          System.out.println("get:"+map.get("04"));
          //可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。

          //获取map集合中所有的值。
          Collection<String> coll = map.values();

          System.out.println(coll);
          System.out.println(map);
     }
}

map集合的两种取出方式：

    

     1.Set<E>keySet  将Map中所有的键存到Set集合。因为set具备迭代器。所以可以用迭代方式取出所有的键。

                                再根据get方法。获取每一个键对应的值

     

     2.entrySet

1.keySet

          //先获取map集合的所有键的Set集合,keySet();

          Set<String> keySet = map.keySet();

          //有了Set集合。就可以获取其迭代器。

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

          while(it.hasNext())

          {
               String key = it.next();
               //有了键可以通过map集合的get方法获取其对应的值。
               String value  = map.get(key);
               System.out.println("key:"+key+",value:"+value);

          }

2.entrySet

将map集合中的映射关系取出存到一个集合Set中，

这个关系就是Map.Entry类型

关系对象Map.Entry获取到后，

就可以通过Map.Entry中的getKey()和getValue方法获取到key和value

Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。

interface Map

{

     public static Interface Entry

     {

          public abstract Object getKey();

          public abstract Object getValue();

     }

}

class HashMap implements Map

{

     class Haha implements Map.Entry

     {

          public Object getKey();

          public Object getValue();

     }

}

练习

1.Map

     每一个学生都有对应的归属地。

     学生Student，地址String。

     学生属性：姓名，年龄。

     注意：姓名和年龄相同的视为同一个学生。

     保证学生的唯一性。

          1，描述学生。

          2，定义map容器。将学生作为键，地址作为值。存入。

          3，获取map集合中的元素。

import java.util.*;
class Student implements Comparable<Student>
{
     private String name;
     private int age;
     Student(String name,int age)
     {
          this.name = name;
          this.age = age;
     }
    
     public int compareTo(Student s)
     {
          int num = new Integer(this.age).compareTo(new Integer(s.age));
          if(num==0)
               return this.name.compareTo(s.name);
          return num;
     }

     public int hashCode()
     {
          return name.hashCode()+age*34;
     }
     public boolean equals(Object obj)
     {
          if(!(obj instanceof Student))
               throw new ClassCastException("类型不匹配");

          Student s = (Student)obj;

          return this.name.equals(s.name) && this.age==s.age;
     }
     public String getName()
     {
          return name;
     }
     public int getAge()
     {
          return age;
     }
     public String toString()
     {
          return name+":"+age;
     }
}

class  MapTest
{
     public static void main(String[] args)
     {
          HashMap<Student,String> hm = new HashMap<Student,String>();

          hm.put(new Student("lisi1",20),"beijing");
          hm.put(new Student("lisi1",20),"tianjin");
          hm.put(new Student("lisi2",22),"shanghai");
          hm.put(new Student("lisi3",24),"nanjing");
          hm.put(new Student("lisi4",25),"shenzhen");

          //第一种取出方式 keySet

          Set<Student> keySet = hm.keySet();

          Iterator<Student> it = keySet.iterator();

          while(it.hasNext())
          {
               Student stu = it.next();
               String addr = hm.get(stu);
               System.out.println(stu+".."+addr);
          }

          //第二种取出方式 entrySet
          Set<Map.Entry<Student,String>> entrySet = hm.entrySet();

          Iterator<Map.Entry<Student,String>> iter = entrySet.iterator();
         
          while(iter.hasNext())
          {
               Map.Entry<Student,String> me = iter.next();
               Student stu = me.getKey();
               String addr = me.getValue();
               System.out.println(stu+"....."+addr);
          }
     }
}

2. TreeMap需求：对学生对象的年龄进行升序排序。
 
因为数据是以键值对形式存在的。

所以要使用可以排序的Map集合。TreeMap。

import java.util.*;
class StuNameComparator implements Comparator<Student>
{
     public int compare(Student s1,Student s2)
     {
          int num = s1.getName().compareTo(s2.getName());
          if(num==0)
               return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
          return num;
     }
}

class  MapTest2
{
     public static void main(String[] args)
     {
          TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());

          tm.put(new Student("blisi3",23),"nanjing");
          tm.put(new Student("lisi1",21),"beijing");
          tm.put(new Student("alisi4",24),"wuhan");
          tm.put(new Student("lisi1",21),"tianjin");
          tm.put(new Student("lisi2",22),"shanghai");

          Set<Map.Entry<Student,String>> entrySet = tm.entrySet();

          Iterator<Map.Entry<Student,String>> it = entrySet.iterator();

          while(it.hasNext())
          {
               Map.Entry<Student,String> me = it.next();

               Student stu = me.getKey();
               String addr = me.getValue();
               System.out.println(stu+":::"+addr);
          }
     }
}

3.TreeMap练习

/*

练习：
"sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。

希望打印结果：a(1)c(2).....

通过结果发现，每一个字母都有对应的次数。
说明字母和次数之间都有映射关系。

注意，当发现有映射关系时，可以选择map集合。

因为map集合中存放就是映射关系。

什么时候使用map集合呢？

当数据之间存在这映射关系时，就要先想map集合。

思路：
1，将字符串转换成字符数组。因为要对每一个字母进行操作。

2，定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合。

3，遍历字符数组。
     将每一个字母作为键去查map集合。
     如果返回null，将该字母和1存入到map集合中。
     如果返回不是null，说明该字母在map集合已经存在并有对应次数。
     那么就获取该次数并进行自增。，然后将该字母和自增后的次数存入到map集合中。覆盖调用原理键所对应的值。

4，将map集合中的数据变成指定的字符串形式返回。

import java.util.*;
class  MapTest3
{
     public static void main(String[] args)
     {
          String s= charCount("ak+abAf1c,dCkaAbc-defa");
          System.out.println(s);
     }
    
     public static String charCount(String str)
     {
          char[] chs = str.toCharArray();

          TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();

          int count = 0;
          for(int x=0; x<chs.length; x++)
          {
               
               if(!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))
                    continue;

               Integer value = tm.get(chs[x]);

               if(value!=null)
                    count = value;
               count++;
               tm.put(chs[x],count);//直接往集合中存储字符和数字，为什么可以，因为自动装箱。

               count = 0;
               /*
               if(value==null)
               {
                    tm.put(chs[x],1);
               }
               else
               {
                    value = value + 1;
                    tm.put(chs[x],value);
               }
               */
          }

          //System.out.println(tm);

          StringBuilder sb = new StringBuilder();

          Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet();
          Iterator<Map.Entry<Character,Integer>>  it = entrySet.iterator();

          while(it.hasNext())
          {
               Map.Entry<Character,Integer> me = it.next();
               Character ch = me.getKey();
               Integer value = me.getValue();
               sb.append(ch+"("+value+")");
          }

          return sb.toString();
     }
}