java Map

最新推荐文章于 2022-03-21 14:14:17 发布

司天宏

最新推荐文章于 2022-03-21 14:14:17 发布

阅读量122

点赞数

本文链接：https://blog.csdn.net/qq_41532872/article/details/85267314

版权

java初级专栏收录该内容

78 篇文章 6 订阅

订阅专栏

Map

需求：
* 保存学生学号，学生姓名
* 每一次要保存这个学生的2个属性值
* s1001 张三映射关系 K (KEY) 键 V (VALUE) 值（键值对）
* s1002 李四
* s1003 王五
* s1004 李四
*
*
* 查找这个学生的时候，根据学号，找到对应的学生姓名
*
* List 单列集合
* add(s1001)
add(s1002) * add(s1003) * * Map:将键映射到值的对象。 * 一个映射不能包含重复的键； * 每个键最多只能映射到一个值。 * 实现类: HashMap, TreeMap,
Hashtable, * 从以下版本开始：1.2 * * 注意 *
1：当有重复的键的时候，后面的值会将前面的值覆盖 * 2:可以添加null键null值，但是只能添加一对 * 3:值可以重复

4：map集合主要是和键有关系，只要找到键，就能根据键找到值 * * Map集合其实就是由Set和List构成的 * key是Set集合不能有重复 * Value是List集合可以有重复 * * 集合常用方法 *
添加 put(k,v) * 删除 remove(k) * 清空 clear(); * 修改 ???
查询 get(k) 根据键查找值 * 长度：size(); * 判断 * containsKey 判断是否包含指定的键 * containsValue 判断是否包含指定的值 *
isEmpty 判断集合是否为空 * 遍历

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




public class Demo {
	
	
	public static void main(String[] args) {
		//1：创建Map集合
		HashMap<String, String> map = new HashMap<>();
		//2:给集合添加键值对
		map.put("邓", "俪");
		map.put("黄", "颖");
		map.put("文", "琍");
		map.put("文", "笛");
		map.put("宝", "蓉");
		map.put("宋", "马");
		
		map.put(null, null);
		map.put(null, null);
		System.out.println(map);
		
		//2：删除键值对  根据键删除键值对
		map.remove("文章");
		System.out.println("删除后:"+map);
		//3:清空键值对
		//map.clear();
		//System.out.println(map);
		//4:根据键查找值  如果此映射不包含该键的映射关系，则返回 null。
		System.out.println(map.get("邓超1"));
		//5:获取键值对的对数
		System.out.println(map.size());
		//6:判断是否包含指定的键
		System.out.println(map.containsKey("邓超"));
		//7:判断是否包含指定的值
		System.out.println(map.containsValue("孙俪"));
		//8  isEmpty  判断集合是否为空
		System.out.println(map.isEmpty());
		//9 返回所有的键的set集合
		/*System.out.println("---------------------");
		Set<String> set = map.keySet();
		for (String s : set) {
			System.out.println(s);
		}
		System.out.println("---------------------");
		//10 返回所有的值的Collection集合
		Collection<String> coll = map.values();
		for (String s : coll) {
			System.out.println(s);
		}*/
		System.out.println("---------------------");
		//11 遍历键值对1
		//11.1 现获取所有的键
		Set<String> set = map.keySet();
		//11.2 遍历所有的键
		for (String key : set) {
			//11.3 遍历一个键，然后在根据键获取值
			String value = map.get(key);
			System.out.println(key+":"+value);
		}
		System.out.println("---------------------");
		//12 遍历键值对2
		Set<Map.Entry<String, String>> entrySet = map.entrySet();
		for(Map.Entry<String, String> s:entrySet){
			System.out.println(s.getKey()+":"+s.getValue());
		}
		
		
		
		
		
	}
}

HashMap

HashMap:
* 基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（
* 此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
* 注意，此实现不是同步的。
* 父接口:Map
* 子类:LinkedHashMap
*
* 需求1：集合保存，<Integer,String>
* 注意：数字可以写10进制，8进制，16进制,2进制
* 2进制前缀是0b jdk1.8 新特性
* 8进制前缀是0
* 10进制直接写数字
* 16进制前缀是0x;
*
* ￥999,886,998

import java.util.HashMap;

public class Demo {

	public static void main(String[] args) {
		//int money = 100_123_456;
		
		//1:创建一个HashMap集合
		HashMap<Integer, String> hm = new HashMap<>();
		hm.put(0b000001100, "马云");
		hm.put(0x1, "马化腾");
		hm.put(0x2, "柳传志");
		hm.put(0x3, "雷军");
		hm.put(0x4, "李宏毅");
		hm.put(0x5, "求伯君");
		hm.put(0x6, "求伯君");
		hm.put(0x7, "求伯君");
		hm.put(0xff, "求伯君");
		//hm.put(08, "求伯君");
		
		System.out.println(hm);
	}

}


import java.util.HashMap;

public class Demo2 {
	
	/*
	 * 需求2：集合保存，<String,Student>
	 * 
	 */
	public static void main(String[] args) {
		HashMap<String, Student>  hm = new HashMap<>();
		
		hm.put("1001", new Student("张三", 20, "男"));
		hm.put("1002", new Student("张三", 20, "男"));
		hm.put("1003", new Student("李四", 30, "女"));
		hm.put("1003", new Student("王五", 25, "男"));
		
		System.out.println(hm);
	}

}


import java.util.HashMap;

public class Demo3 {

	/*
	 * 	 需求3：集合保存，<Student,String>
	 *   键的位置是自定义对象，如果要去重，那么自定义对象必须重写hashCode和equals方法
	 */
	
	public static void main(String[] args) {
		HashMap<Student, String>  hm = new HashMap<>();
		
		hm.put(new Student("张三", 20, "男"),"唐朝");
		System.out.println(hm.put(new Student("张三", 20, "男"),"宋朝"));
		hm.put(new Student("李四", 30, "女"),"明朝");
		hm.put(new Student("王五", 25, "男"),"唐朝");
		
		System.out.println(hm);
	}
}

public class Student {
	
	
	private  String name;
	private  Integer age;
	private String sex;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Student(String name, Integer age, String sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((age == null) ? 0 : age.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		result = prime * result + ((sex == null) ? 0 : sex.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age == null) {
			if (other.age != null)
				return false;
		} else if (!age.equals(other.age))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (sex == null) {
			if (other.sex != null)
				return false;
		} else if (!sex.equals(other.sex))
			return false;
		return true;
	}
	
	

}

LinkedhashMap

import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Set;

public class Demo {
	/*
	 * LinkedHashMap:Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。
	 * 父类：HashMap
	 * 注意，此实现不是同步的。
	 * 从以下版本开始： 1.4 
	 * 
	 */
	public static void main(String[] args) {
		LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();
		lhm.put("a", 1001);
		lhm.put("d", 1002);
		lhm.put("c", 1003);
		lhm.put("t", 1004);
		lhm.put("y", 1005);
		
		//1:获取所有的键的集合
		Set<String> set = lhm.keySet();
		//2:遍历键
		for (String key : set) {
		//3:根据键获取值
			Integer value = lhm.get(key);
			System.out.println(key+":"+value);
		}
		System.out.println("---------------");
		
		//1:获取集合的映射关系
		Set<Entry<String, Integer>> entrySet = lhm.entrySet();
		//2:遍历映射关系
		for(Entry<String, Integer> en:entrySet){
			//3:分别获取键和值
			System.out.println(en.getKey()+":"+en.getValue());
		}

		
		System.out.println(lhm);
		
		
	}
}

Treemap

TreeMap:基于红黑树（Red-Black tree）的 NavigableMap 实现。
* 1 该映射根据其键的自然顺序进行排序
* 2 根据创建映射时提供的 Comparator 进行排序
* 具体取决于使用的构造方法。
* 注意，此实现不是同步的。
* 从以下版本开始： 1.2
* TreeMap:底层是基于红黑树的二叉树
* 排序且唯一

import java.util.TreeMap;

public class Demo {

	public static void main(String[] args) {
		//1:创建TreeMap集合
		TreeMap<Integer, String> tm = new TreeMap<>();
		//2:添加键值对
		tm.put(10, "唐朝");
		tm.put(5, "宋朝");
		tm.put(7, "元朝");
		tm.put(2, "明朝");
		tm.put(1, "清朝");
		tm.put(10, "汉朝");
		
		System.out.println(tm);
	}

}


import java.util.Set;
import java.util.TreeMap;

public class Demo2 {
	
	/*
	 * 使用TreeMap 对自定义对象排序
	 */

	public static void main(String[] args) {
		TreeMap<Student, Integer> tm = new TreeMap<>();
		
		tm.put(new Student("张三", 20, "男"),1);
		tm.put(new Student("李四", 35, "女"),2);
		tm.put(new Student("王五", 20, "男"),3);
		tm.put(new Student("赵柳", 26, "女"),4);
		tm.put(new Student("马奇", 20, "男"),5);
		tm.put(new Student("张三", 20, "男"),6);
		
		System.out.println("学号\t姓名\t年龄\t性别");
		Set<Student> keySet = tm.keySet();
		for (Student stu : keySet) {
			Integer id = tm.get(stu);
			System.out.println(id+"\t"+stu.getName()+"\t"+stu.getAge()+"\t"+
			stu.getSex());
		}
		
	}
}


public class Student implements Comparable<Student> {
	
	private String name;
	private int age;
	private String sex;
	
	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;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Student(String name, int age, String sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public Student() {
		super();
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}
	@Override
	public int compareTo(Student s) {
		//主要条件，年龄从小到大
		int num = this.getAge()-s.getAge();
		//次要条件1：年龄相同，姓名不一定相同
		num = num==0?this.getName().compareTo(s.getName()):num;
		//次要条件2：年龄,姓名相同，性别不一定相同
		num = num==0?this.getSex().compareTo(s.getSex()):num;
		return num;
	}
	
	
	
}

Hashtable

Hashtable:此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。
* 父接口：Map
* 从以下版本开始： JDK1.0
* Hashtable 是同步的
*
* 面试题：HashMap和Hashtable的区别？
* 1 产生时间
* Hashtable jdk1.0
* HashMap jdk1.2
* 2 继承的父类不同
* Hashtable父类：Dictionary
* HashMap父类：AbstractMap
* 3 对外提供的接口不同
* Hashtable比HashMap多提供了elments() 和contains() 两个方法。
* 4 对Null key 和Null value的支持不同
* Hashtable 不支持null键和null值
* HashMap 支持
* 5 线程安全性不同
* Hashtable 同步
* HashMap 不同步
* 6 遍历方式的内部实现上不同
* Hashtable、HashMap都使用了 Iterator。
* 而由于历史原因，Hashtable还使用了Enumeration的方式。
* 7 初始容量大小和每次扩充容量大小的不同
* Hashtable默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。
* HashMap默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。


import java.util.Hashtable;

public class Demo {

	public static void main(String[] args) {
		Hashtable<String, String> ht = new Hashtable<>();
		ht.put(null, null);
		System.out.println(ht);
		
	}

}