Map集合
该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
Map与Collection的不同
1.Map与Collection在集合框架中属并列存在
2.Map存储的是键值对
3.Map存储元素使用put方法,Collection使用add方法
4.Map集合没有直接取出元素的方法,而是先转成Set集合,在通过迭代获取元素
5.Map集合中键要保证唯一性
Map集合常见方法实例
Map集合常用类
1.Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
2.HashMap:底层是哈希表数据结构,允许使用 null 值和 null 键,该集合是不同步的。将hashtable替代,jdk1.2.效率高。
3.TreeMap:底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。
注意:Map和Set很像,其实Set底层就是使用了Map集合。
Map集合的两种取出方式:
1.Set<k> keySet:将map中所有的键存入到Set集合。因为set具备迭代器。所有可以迭代方式取出所有的键,在根据get方法。获取每一个键对应的值。
Map集合的取出原理:将map集合转成set集合。在通过迭代器取出。
2.Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到了set集合中,而这个关系的数据类型就是:Map.Entry,Entry其实就是Map中的一个static内部接口。
问题:Entry为什么要定义在内部呢?
因为只有有了Map集合,有了键值对,才会有键值的映射关系。
该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
Map与Collection的不同
1.Map与Collection在集合框架中属并列存在
2.Map存储的是键值对
3.Map存储元素使用put方法,Collection使用add方法
4.Map集合没有直接取出元素的方法,而是先转成Set集合,在通过迭代获取元素
5.Map集合中键要保证唯一性
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.Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
2.HashMap:底层是哈希表数据结构,允许使用 null 值和 null 键,该集合是不同步的。将hashtable替代,jdk1.2.效率高。
3.TreeMap:底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。
注意:Map和Set很像,其实Set底层就是使用了Map集合。
Map集合的两种取出方式:
1.Set<k> keySet:将map中所有的键存入到Set集合。因为set具备迭代器。所有可以迭代方式取出所有的键,在根据get方法。获取每一个键对应的值。
Map集合的取出原理:将map集合转成set集合。在通过迭代器取出。
2.Set<Map.Entry<k,v>> entrySet:将map集合中的映射关系存入到了set集合中,而这个关系的数据类型就是:Map.Entry,Entry其实就是Map中的一个static内部接口。
问题:Entry为什么要定义在内部呢?
因为只有有了Map集合,有了键值对,才会有键值的映射关系。
关系属于Map集合中的一个内部事物。
而且该事物在直接访问Map集合中的元素。
Map的取出方式实例:
Map练习
TreeMap
Map的取出方式实例:
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
* Map的取出方式
*/
public class MapDemo2 {
public static void main(String[] args) {
HashMap<String, String> hm = new HashMap<String, String>();
hm.put("001", "zhangsan");
hm.put("002", "lisi");
hm.put("003", "wangwu");
//通过键获取值
getMethod1(hm);
//通过映射关系键获取值
getMethod2(hm);
}
//通过键获取值
public static void getMethod1(HashMap<String, String> hm){
//先获取map集合的所有键的Set集合,keySet();
Set<String> keySet = hm.keySet();
//有了Set集合。就可以获取其迭代器。
Iterator<String> it = keySet.iterator();
while (it.hasNext()) {
//有了键可以通过map集合的get方法获取其对应的值。
System.out.println(hm.get(it.next()));
}
}
//通过映射关系键获取值
public static void getMethod2(HashMap<String, String> hm){
//将Map集合中的映射关系取出。存入到Set集合中。
Set<Map.Entry<String,String>> entrySet = hm.entrySet();
Iterator<Map.Entry<String,String>> it = entrySet.iterator();
while (it.hasNext()) {
Map.Entry<String,String> me = it.next();
System.out.println(me.getKey()+","+me.getValue());
}
}
}
Map练习
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
/*
需求:
每一个学生都有对应的归属地。学生Student,地址String。学生属性:姓名,年龄。
注意:姓名和年龄相同的视为同一个学生。保证学生的唯一性。
思路:
1.描述学生。
2.定义map容器。将学生作为键,地址作为值。存入。
3.获取map集合中的元素。
*/
class Student implements Comparable<Student>{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
Student(String name, int age) {
this.name = name;
this.age = age;
}
//保证学生的唯一性。
public int compareTo(Student s){
int num = this.name.compareTo(s.name);
if(num == 0){
return new Integer(s.age).compareTo(new Integer(s.age));
}
return num;
}
}
public class MapTest {
public static void main(String[] args) {
HashMap<Student, String> hm = new HashMap<Student, String>();
hm.put(new Student("张三", 20), "长沙");
hm.put(new Student("李四", 20), "衡阳");
hm.put(new Student("王五", 20), "深圳");
//通过键来获取值
getMethod1(hm);
}
//通过键来获取值
public static void getMethod(HashMap<Student, String> hm){
Set<Student> keySet =hm.keySet();
Iterator<Student> it = keySet.iterator();
while (it.hasNext()) {
Student stu = (Student)it.next();
System.out.println(stu.getName() + "," + stu.getAge());
}
}
//通过映射关系来获取值
public static void getMethod1(HashMap<Student, String> hm){
Set<Map.Entry<Student,String>> keySet =hm.entrySet();
Iterator<Map.Entry<Student,String>> it = keySet.iterator();
while (it.hasNext()) {
Student stu = it.next().getKey();
System.out.println(stu.getName() + "," + stu.getAge());
}
}
}
TreeMap
底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。
TreeMap实例:
TreeMap实例:
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
/*
需求:对学生对象的年龄进行升序排序。
因为数据是以键值对形式存在的。
所以要使用可以排序的Map集合。TreeMap。
*/
//比较器,对学生对象的年龄进行升序排序。
class MyComparator implements Comparator<Student>{
public int compare(Student s1, Student s2){
int num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
if(num == 0){
return s1.getName().compareTo(s2.getName());
}
return num;
}
}
class Student{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
Student(String name, int age) {
this.name = name;
this.age = age;
}
}
public class MapTest {
public static void main(String[] args) {
TreeMap<Student, String> hm = new TreeMap<Student, String>(new MyComparator());
hm.put(new Student("张三", 20), "长沙");
hm.put(new Student("李四", 22), "衡阳");
hm.put(new Student("王五", 21), "深圳");
//通过键来获取值
getMethod1(hm);
}
//通过键来获取值
public static void getMethod(TreeMap<Student, String> hm){
Set<Student> keySet =hm.keySet();
Iterator<Student> it = keySet.iterator();
while (it.hasNext()) {
Student stu = (Student)it.next();
System.out.println(stu.getName() + "," + stu.getAge());
}
}
//通过映射关系来获取值
public static void getMethod1(TreeMap<Student, String> hm){
Set<Map.Entry<Student,String>> keySet =hm.entrySet();
Iterator<Map.Entry<Student,String>> it = keySet.iterator();
while (it.hasNext()) {
Student stu = it.next().getKey();
System.out.println(stu.getName() + "," + stu.getAge());
}
}
}
什么使用map集合呢?
当数据之间存在这映射关系时,就要先想map集合。
实例:
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
/*
需求:
"sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。
希望打印结果:a(1)c(2).....
通过结果发现,每一个字母都有对应的次数。说明字母和次数之间都有映射关系。
注意了,当发现有映射关系时,可以选择map集合。因为map集合中存放就是映射关系。
什么使用map集合呢?
当数据之间存在这映射关系时,就要先想map集合。
思路:
1.将字符串转换成字符数组。因为要对每一个字母进行操作。
2.定义一个map集合,因为打印结果的字母有顺序,所以使用treemap集合。
3.遍历字符数组。
将每一个字母作为键去查map集合。
如果返回null,将该字母和1存入到map集合中。
如果返回不是null,说明该字母在map集合已经存在并有对应次数。
那么就获取该次数并进行自增。,然后将该字母和自增后的次数存入到map集合中。覆盖调用原理键所对应的值。
4.将map集合中的数据变成指定的字符串形式返回。
*/
class MyString{
public static void charCount(String str){
char arr[] = str.toCharArray();
TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
for (int i = 0; i < arr.length; i++) {
//判断是否是字母
if(!(arr[i]>='a' && arr[i]<='z' || arr[i]>='A' && arr[i]<='Z'))
continue;
Integer values = tm.get(arr[i]);
if(values!=null){
tm.put(arr[i],++values);
}else {
tm.put(arr[i],1);
}
}
Set<Character> keySet = tm.keySet();
Iterator<Character> it = keySet.iterator();
while (it.hasNext()) {
char Char = it.next();
System.out.print(Char +"("+ tm.get(Char)+")");
}
}
}
public class MapTest3 {
public static void main(String[] args) {
MyString.charCount("adsdfg11111hjsddasdaa");
}
}
Map扩展知识
Map集合被使用是因为具备映射关系。
实例:
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
public class Test{
public static void main(String[] args){
Map<String,String> chongci = new HashMap<String,String>();
chongci.put("01","张三");
chongci.put("02","李四");
Map<String,String> jiuye = new HashMap<String,String>();
jiuye.put("01","王五");
jiuye.put("02","赵六");
Map<String,Map<String,String>> czbk = new HashMap<String,Map<String,String>>();
czbk.put("就业班",chongci);
czbk.put("冲刺班",jiuye);
//取出某个班级的学生
//getStudentInfo(yure);
for(Iterator<String> it = czbk.keySet().iterator();it.hasNext();){
String roomName = it.next();
sop(roomName);
getStudentInfo(czbk.get(roomName));
}
}
public static void getStudentInfo(Map<String,String> roomMap){
for(Iterator<String> it = roomMap.keySet().iterator();it.hasNext();){
String key = it.next();
String value = roomMap.get(key);
sop(key+":"+value);
}
}
public static void sop(Object obj){
System.out.println(obj);
}
}