黑马程序员——Java基础之Map集合

   java学习第16天，学习内容

/*
Map集合：public interface Map<K,V>
该集合存储键值对，一对一对往里存，而且要保证键的唯一性
 
 1，增加
  put(K key,V value);
  putAll(Map<? extends K,? extends V>m)

 2，删除
  clear()
  remove(Object key)
 3.判断
  containsValue(Object value)
  containsKey(Object key)
  isEmpty()

 4，获取
  get(Object key)
  size()
  values() 获取所有值

  entrySet()
  keySet()

Map集合：
 |--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的，jsk1.0，效率低
 |--HashMap：底层是哈希表数据结构，允许使用null键和null值，该集合是不同步的，jdk1.2，效率高
 |--TreeMap：底层是二叉树数据结构，线程不同步，可以用于给map集合中的键进行排序

和Set很像
其实Set底层就是使用了Map集合

*/

//map的共性方法
import java.util.*;
class  MapDemo
{
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }

 public static void main(String[] args)
 {
  Map<String,String> map = new HashMap<String,String>();

  //map集合添加元素,如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，
  //并put方法会返回被覆盖的值
  sop("put:......"+map.put("01","spider01"));
  sop("put:......"+map.put("01","spider007"));
  map.put("02","spider02");
  map.put("04","spider04");
  map.put("03","spider03");
  sop("原始值："+map);

  
  //判断
  sop("containsKey:..."+map.containsKey("03"));
  //删除
  sop("remove..."+map.remove("02"));
  //获取
  sop("get:..."+map.get("01"));
  //sop("get:..."+map.get("011"));返回null

  map.put("05",null);
  sop("get:..."+map.get("05"));//返回null
  //可以通过get方法的返回值来判断一个键是否存在，通过返回null来判断

  //获取map集合中所有的值
  Collection<String> coll = map.values();
  sop(coll);
  sop("变化值：..."+map);

 }
}

import java.util.*;
/*
map集合的两种取出方式
1.keySet:  Set<k> keySet:将map中所有的键存入到Set集合，因为set具备迭代器
   所以可以空过迭代方式取出所有的键，在根据get方法，获取每一个键对应的值

 map集合取出原理：将map集合转成set集合，在通过迭代器取出

2,entrySet: Set<> entrySet: 获取map集合双类型元素的关系映射,存到Set集合中

3，Map.Entry知识
Map.Entry 其实Entry也是一个接口，他是Map接口中的一个内部接口
*/
interface Map
{
 public static interface Entry //接口在成员位子上才能加静态
 {
  public abstract Object getKey();
  public abstract Object getValue();
 }
}

class HashMap implements Map
{
 class Hahs implements Map.Entry
 {
  public  Object getKey(){}
  public  Object getValue(){}
 }
}

 

 

class  MapkeySetDemo
{
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }

 public static void main(String[] args)
 {
  Map<String,String> map = new HashMap<String,String>();

  map.put("02","spider02");
  map.put("04","spider04");
  map.put("01","spider01");
  map.put("03","spider03");

  Set<Map.Entry<String,String>> entrySet = map.entrySet();//获取map集合双类型元素的关系映射,存到Set集合中

  Iterator<Map.Entry<String,String>> it = entrySet.iterator();
  while (it.hasNext())
  {
   Map.Entry<String,String> me = it.next();  //获取映射关系
   String key = me.getKey();  //获取映射关系中的键
   String value = me.getValue();
   sop("key="+key+"valur="+value);
  }

  /*
  //因为map集合没有迭代器，所有不能通过迭代的方式获取map集合中元素的值，
  //但可以使用keySet()方法获取map集合中键的集合（Set集合）
  //因为获取的键的集合是Set集合，就可以使用Iterator迭代器方式获取元素值
  
  //获取键的值
  Set<String> keySet = map.keySet();
  
  Iterator<String> it = keySet.iterator();
  while (it.hasNext())
  {
   String key = it.next();  //得到键的值, 
   String value = map.get(key);   //在通过键的值获取对象的元素值
   sop("key..."+key+",value:..."+value);
   
   
  }*/
 }
}

 

import java.util.*;
/*
对MapTest中学生对象的年龄进行升序排序

因为数据是以键值对形式存在的
所以要使用可以排序的Map集合，TreeMap

添加对象比较器：通过实现Comparable接口，复写compare方法

*/

class StuAgeCompare implements Comparator<Student> //实现按照学生年龄排序，年龄相同时，按照姓名排序
{
 public int compare(Student stu1,Student stu2)
 {
  int num = new Integer(stu1.getAge()).compareTo(new Integer(stu2.getAge()));
  if(num==0)
   return stu1.getName().compareTo(stu2.getName());
  return num;
 }
}

class  TreeMapTest2
{
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
 public static void main(String[] args)
 {
  TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuAgeCompare());

  tm.put(new Student("Spider01",21),"jiangxi");
  tm.put(new Student("Spider04",25),"shanghai");
  tm.put(new Student("Spider02",22),"beijing");
  tm.put(new Student("Spider00",22),"beijing");
  tm.put(new Student("Spider03",23),"shenzhen");
  
  //取出元素方式有两种，一种是keySet()通过获取键，取得值
  //一种是通过获取元素的键值关系，entrySet(),再获取键值
  Set<Map.Entry<Student,String>> entrySet = tm.entrySet();

  Iterator<Map.Entry<Student,String>> it = entrySet.iterator();
  while (it.hasNext())
  {
   Map.Entry<Student,String> em = it.next();
   Student stu = em.getKey();
   String addr = em.getValue();
   sop(stu.getName()+"..."+stu.getAge()+"..."+addr);

  }

 }
}

 

import java.util.*;

/*
练习：

每一个学生都有对应的归属地。
学生Student，地址：String
学生属性：姓名，年龄；
注意：姓名和年龄相同的视为同一个学生，
保证学生的唯一性

思路：
1，描述学生

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

3，获取map集合中的元素

*/

class Student implements Comparable<Student> //Student实现Comparable接口，复写compareTo()方法
{
 private String name;
 private int age;
 Student(String name,int age)
 {
  this.name=name;
  this.age=age;
 }

 public int compareTo(Student stu)
 {
  int num = new Integer(this.age).compareTo(new Integer(stu.age));
  if (num==0)
   return this.name.compareTo(stu.name);
  return num;

 }

 //因为Student 存放在HashMap集合中，所以需要覆盖hashCode方法和equals方法，用于保证HashMap键的唯一性
 public int hashCode()
 {
  return name.hashCode()+age*34;
 }
 public boolean equals(Object obj)
 {
  if (!(obj instanceof Student))
   throw new ClassCastException("数据类型不匹配");

  Student stu = (Student)obj;
  return this.name.equals(stu.name) && this.age==stu.age;
 }

 public String getName()
 {
  return name;
 }
 public int getAge()
 {
  return age;
 }
 public String print()
 {
  return name+"..."+age;
 }
}

 

class MapTest
{
 public static void sop(Object obj)
 {
  System.out.println(obj);
 }
 public static void main(String[] args)
 {
  HashMap<Student,String> hm = new HashMap<Student,String>();

  hm.put(new Student("zzh01",23),"jiangxi");
  hm.put(new Student("zzh03",25),"beijing");
  hm.put(new Student("zzh01",23),"henan"); //键相同，不会打印出来
  hm.put(new Student("zzh04",21),"shanghai");
  hm.put(new Student("zzh02",20),"guangdong");

  //第一中获取方式，通过keySet()方式获取键
  Set<Student> keySet = hm.keySet();
  Iterator<Student> it = keySet.iterator();

  while (it.hasNext())
  {
   Student stu = it.next();
   String addr = hm.get(stu);
   sop("name="+stu.getName()+"age="+stu.getAge()+",first method."+addr);
  }

  sop("-----------------------------------------------------");

  //第二种获取方式，通过entrySet()获取映射关系获取键和值
  Set<Map.Entry<Student,String>> entrySet = hm.entrySet(); //获取映射关系集合
  Iterator<Map.Entry<Student,String>> itl = entrySet.iterator(); //获取映射关系集合的迭代器
  while (itl.hasNext())
  {
   Map.Entry<Student,String> me = itl.next(); //获取元素的映射关系
   Student stu = me.getKey();
   String addr = me.getValue();
   sop("name="+stu.getName()+"age="+stu.getAge()+",secode method."+addr);
  }

 }
}

 

import java.util.*;
/*
练习：
"sdajajznvkjhanvndvn" 获取该字符串中的字母出现的次数。

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

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

注意了，当发现有映射关系时，可以选择map集合
因为map集合中存放就是映射关系

什么时候使用map集合呢？
当数据之间存在这种映射关系时，就是先想map集合。

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

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

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

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

*/
class  MapTest2
{
 public static void main(String[] args)
 {
  String s = charCount("a+ab=dcoooobd,skdslc");
  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++;
    tm.put(chs[x],value);
   }*/

  }
  //System.out.println(tm);
  
  StringBuilder sb = new StringBuilder(); //定义一个容器，用于存放tm集合
  Set<Map.Entry<Character,Integer>> entrySet = tm.entrySet(); //获取集合元素的映射关系

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

  while (it.hasNext())
  {
   Map.Entry<Character,Integer> em = it.next();
   Character key = em.getKey();
   Integer value = em.getValue();
   sb.append(key+"("+value+")");
   //System.out.println("key="+key+"...value="+value);
  }
  return sb.toString();
 }
}