Map集合的子集及用法

package javaStudy;
/**
*
* @author zhaocx1
*
*/
/*
* Map 集合重点：该集合存储键值对，一对一对往里存，而且要保证键的唯一性。
*     1.添加。
*        put(K key,V value)
*        putAll(Map<? extends K,? extends V>)
*     2.删除。
*        clear()
*        remove(Object key)
*     3.判断。
*        containsValue(Object value)
*        containsKey(Object key)
*        isEmpty()
*     4.获取。
*        value get(Object key)
*        size()
*        values()
*
*        entrySet()
*        keySet()
*
* Map
*  --HashTable:底层是哈希表数据结构，不可以存入null键和null值。该集合是线程同步的。JDK1.0,效率低。
*  --HashMap：底层是哈希表数据结构，允许使用null值和null键，该集合是线程不同步的。   JDK1.2,效率高。
*  --TreeMap：底层是二叉树数据结构，线程不同步。可以用于给map集合中的键进行排序。
*
* 和Set很像。
* 其实Set底层就是使用了Map集合。
*
*/

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

public class MapDemo1 {
public static void main(String[] args) {
//定义一个Map集合，并且指定泛型，Map集合中的元素是成对出现的
Map<String, String> map = new HashMap<String, String>();

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

//判断集合中是否包含某一个键
System.out.println("containsKey:" + map.containsKey("023"));
//通过某一个键删除相对应的值
System.out.println("remove:" + map.remove("02"));
//通过某一个键获取某一个值
System.out.println("get:"+map.get("02"));

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

//Map集合中可以通过values获取所有的值
Collection<String> coll=map.values();

//输出打印所有的值
System.out.println(coll);
//输出打印集合中的所有键值
System.out.println(map);
}

}

<pre name="code" class="java">package javaStudy;
/**
*
* @author zhaocx1
* Map集合中的第一种取出元素的方法：
*/
import java.util.HashMap;//导入集合中的包类
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
* map集合的两种取出方式。
* 1.Set<K> keySet:将map中所有的键存入到set集合。因为set具备迭代器所有可以迭代的方式取出所有的键，再根据get方法获取每一个键对应的值。
*
*        Map集合的取出原理:将map集合转成set集合，再通过迭代器取出。
*
* 2.Set<Map.Entry<K.V>>  entrySet:将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry.
*
*
*/
public class MapDemo2 {
public static void main(String[] args) {
//定义一个集合容器用于存储集合，并指定泛型为字符串类型
Map<String, String> map = new HashMap<String, String>();

//添加元素，必须是成对添加
map.put("02", "zhangsan2");
map.put("03", "zhangsan3");
map.put("01", "zhangsan1");
map.put("04", "zhangsan4");

//定义一个Set集合用于存储所有的键，通过keySet()方法进行获取
Set<String> keySet = map.keySet();

// 有了Set集合，就可以获取其迭代器。
Iterator<String> it = keySet.iterator();

while (it.hasNext()) {
String key = it.next();
// 有了键就可以通过map集合的get方法获取其对应的值。
// System.out.println("key:"+key);
String value = map.get(key);
//输出打印所有的键和相对应的值
System.out.println("key:" + key + ",value:" + value);
}
}

}

<pre name="code" class="java">package javaStudy;

/**
*
* @author zhaocx1
* Map集合中的第二种取出元素的方法：
*/
import java.util.HashMap;//导入集合中的类包
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
* map集合的两种取出方式。
*
* 2.Set<Map.Entry<K.V>>  entrySet:将map集合中的映射关系存入到了set集合中，而这个关系的数据类型就是：Map.Entry.
*
* 将Map中的映射关系取出。
* 这个关系就是Map.Entry类型。那么关系对象Map.Entry获取后，就可以通过Map.Entry中getKey和getValue方法后去关系中的键和值。
*
*/
public class MapDemo3 {
public static void main(String[] args) {
// 定义一个集合，用于存储集合中的元素，并指定集合中的元素类型为字符串类型
Map<String, String> map = new HashMap<String, String>();
// 添加元素
map.put("02", "zhangsan2");
map.put("03", "zhangsan3");
map.put("01", "zhangsan1");
map.put("04", "zhangsan4");

// 定义一个Set集合，将集合中的映射关系取出，存入到Set集合中。
Set<Map.Entry<String, String>> entrySet = map.entrySet();

// 通过迭代器获取Set集合中的映射关系
Iterator<Map.Entry<String, String>> it1 = entrySet.iterator();

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

// 通过Map.Entry中getKey和getValue方法后去关系中的键和值
String key = me.getKey();
String value = me.getValue();

// 输出打印集合中的所有键和值
System.out.println(key + "::" + value);

}

}
}

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

interface Map1

{
public static interface Entry {
public abstract Object getKey();

public abstract Object getValue();

}
}

class HashMap1 implements Map1 {
class Haha implements Map1.Entry {
public Object getKey() {
return null;
}

public Object getValue() {
return null;
}
}

}

<pre name="code" class="java">package javaStudy;
import java.util.HashMap;//导入集合中的类包
import java.util.Iterator;
/**
*
* @author zhaocx1
*
*/
/*
* map扩展知识：
* map集合被使用是因为具备映射关系。
*/
public class MapDemo4 {
public static void main(String[] args) {

//定义集合用于存储集合中的元素，并指定集合中元素的类型
HashMap<String, String> yure = new HashMap<String, String>();
HashMap<String, String> jiuye = new HashMap<String, String>();

//定义集合用于存储集合中的元素，并指定集合中元素的类型，该集合中值是一个Map集合
HashMap<String, HashMap<String, String>> czbk = new HashMap<String, HashMap<String, String>>();

//添加元素，Map集合中添加元素用的是put方法
yure.put("01", "zhangsan");
yure.put("02", "lisi");

jiuye.put("01", "wangwu");
jiuye.put("02", "zhaoliu");

czbk.put("yureban", yure);
czbk.put("jiuyeban", jiuye);

// 遍历czbk集合，获取所有的键。
Iterator<String> it = czbk.keySet().iterator();
while (it.hasNext()) {
//获取集合中所有的键
String roomName = it.next();
//通过键获取集合中相对应的值
HashMap<String, String> room = czbk.get(roomName);
//输出打印集合中所有的键
System.out.println(roomName);
//调用静态方法，获取集合中所有的键和值
getStudentInfo(room);
}

getStudentInfo(yure);
}
//定义一个静态方法用于获取集合中所有的值
public static void getStudentInfo(HashMap<String, String> roomMap) {
//通过迭代器获取集合中所有的键
Iterator<String> it = roomMap.keySet().iterator();
while (it.hasNext()) {
String id = it.next();
//通过键获取集合中相对应的值
String name = roomMap.get(id);
//输出打印集合中所有的键和值
System.out.println(id + "::" + name);
}

}
}

package javaStudy;
/**
*
* @author zhaocx1
* Map集合练习
*/
/*
* 每一个学生都有对应的归属地。
* 学生Student，地址String.
* 学生属性，年龄。
* 注意：姓名和年龄相同视为同一个学生。
* 保证学生的唯一性。
*
* 1.描述学生。
* 2.定义map容器，将学生作为键，地址作为值，存  入。
* 3.获取map集合中的元素。
*/
import java.util.HashMap;//导入集合中的类包
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
//定义一个类实现Comparable接口让类中的对象具备比较性
class Student implements Comparable<Student> {
private String name;//私有name属性
private int age;//私有age属性

Student(String name, int age) {// 对类进行构造函数，并将属性传递作为参数
this.name = name;// 调用本类属性
this.age = age;
}

//覆写Comparable接口中的compareTo方法，并将学生对象作为参数传递进去
public int compareTo(Student s) {
//先对age属性进行比较
int num = new Integer(this.age).compareTo(new Integer(s.age));
//如果age相等再判断name属性
if (num == 0)
return this.name.compareTo(s.name);
return num;
}

public int hasCode() {
return name.hashCode() + age * 34;
}
// 定义一个方法判断Object类是否包含Person类，如果包含向下转型，从而Object类可以接收Person类
public boolean equals(Object obj) {
if (!(obj instanceof Student))
throw new ClassCastException("类型不匹配");
// 向下转型
Student s = (Student) obj;
// 返回本类中的name和age属性
return this.name.equals(s.name) && this.age == age;

}

public String getName() {// 定义一个获取name属性的方法
return name;// 返回值为name
}

public int getAge() {
return age;
}

public String toString() {//定义一个返回字符串类型的方法
return name + "::" + age;//返回本类中的姓名和年龄
}

}

public class MapTestDemo1 {
public static void main(String[] args) {
//定义集合容器，用于存储集合中的元素
HashMap<Student, String> hm = new HashMap<Student, String>();
//集合中添加元素
hm.put(new Student("lisi", 21), "beijing");
hm.put(new Student("lisi", 22), "tianjin");
hm.put(new Student("lisi", 23), "shanghai");
hm.put(new Student("lisi", 24), "wuhan");

// 第一种取出方式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);

}

}

}

package javaStudy;
/**
*
* @author zhaocx1
* Map集合练习
*/
/*
*需求：对学生对象的年龄进行升序排序。
*因为数据是以键值对形式存在的。
*所以要使用可以排序的Map集合，TreeMap.
*/
import java.util.Comparator;//导入集合中的类
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

//定义一个比较器实现Comparator借口并指定泛型
class StuNameComparator implements Comparator<Student> {
//覆写接口中的compare方法
public int compare(Student s1, Student s2) {
//对name属性进行比较
int num = s1.getName().compareTo(s2.getName());
//如果name相同，通过age属性进行比较
if (num ==  0) {
Integer a = new Integer(s1.getAge()).compareTo(new Integer(s2
.getAge()));
return new Integer(a);
}
return num;
}
}

public class MapTestDemo2 {
public static void main(String[] args) {
//定义集合容器用于存储集合中的元素，并将比较器作为参数传递到集合的构造函数中
TreeMap<Student, String> tm = new TreeMap<Student, String>(
new StuNameComparator());
//添加元素
tm.put(new Student("lisi", 21), "beijing");
tm.put(new Student("lisi", 23), "shanghai");
tm.put(new Student("lisi", 22), "tianjin");
tm.put(new Student("lisi", 24), "wuhan");

//用Map集合中的Map.Entry方法通过迭代器获取集合中的元素
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);
}

}

}

package javaStudy;

/**
*
* @author zhaocx1
* Map集合练习
*/
/*
* 练习：
* "asdbhcgnaahcgaahddfj"获取字符串中的字母出现的次数。
* 希望打印结果：a(3)c(2)..
*
* 通过结果发现，每一个字母都有对应的次数。
* 说明字母和次数之间都有映射关系。
*
* 注意了，当发现有映射关系时，可以选择map集合。
* 因为map集合中存放就是映射关系。
*
* 什么时候使用map集合呢？
* 当数据之间存在映射关系时，就要先想map集合。
*
* 思路：
* 1.将字符串转换成字符数组。因为要对每一个字母进行操作。
* 2.定义一个map集合，因为打印结果的字母有顺序，所以使用treeMap.
* 3.遍历字符数组。
*    将每一个字母作为键区查map集合。
*    如果返回null，将该字母和1存入到map集合中。
*    如果返回值不是null，说明该字母在map集合中已经存在并有对应的次数。
*    那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到map集合中，覆盖调用原来键所对应的值。
* 4.将map集合中的数据变成指定的字符串形式返回。
*
*/
import java.util.Iterator;//导入集合中的类包
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class MapTestDemo3 {

public static void main(String[] args) {
String s = charCount("asdbhcgnaahcgaahddfj");//声明一个
System.out.println(s);
}

public static String charCount(String str) {
char[] chs = str.toCharArray();//将字符串转成字符数组

//定义一个集合容器，用于存储集合中的元素，因为要求打印的字母有顺序，所以使用TreeMap
TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
//对数组中的元素进行遍历
for (int x = 0; x < chs.length; x++) {
//定义一个计数器，用于记录每次遍历元素的个数
int count = 0;
//对获取字母的转化成Integer类型
Integer value = tm.get(chs[x]);

if (value != null)
count = value;
count++;
tm.put(chs[x], count);

}
//定义一个StringBuilder容器
StringBuilder sb = new StringBuilder();
//通过Map集合的Map.Entry方法获取集合中的元素
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();
//将集合中的元素存放到StringBuilder容器中
sb.append(ch + "(" + value + ")");
}
//返回字符串
return sb.toString();
}

}