java--基础--9.6--集合--Map--Map使用和子类使用

勤径苦舟

于 2023-05-20 12:51:47 发布

阅读量195

点赞数

分类专栏： java基础文章标签： java 数据结构链表

本文链接：https://blog.csdn.net/zhou920786312/article/details/130780258

版权

java基础专栏收录该内容

78 篇文章 1 订阅

订阅专栏

java–基础–9.6–集合–Map–Map使用和子类使用

1、Map 接口

Map 接口

    ----|HashMap           -------------implements  Map
	
		----|LinkedHashMap -------------extends HashMap
	
	----|Hashtable         -------------implements  Map
	
	
		
    ----|treeMap           -------------implements Map
	
	 
	 
Map 接口
    ----|HashMap 线程不安全，效率高。
		允许null键和null值,是基于哈希表的Map接口实现。
		哈希表的作用是用来保证键的唯一性的
					
	    ----|LinkedHashMap:是基于Map接口的哈希表和链接列表实现，
				由哈希表保证键的唯一性
				由链表保证键盘的有序(存储和取出的顺序一致)
		
	----|Hashtable:线程安全，效率低。不允许null键和null值

    ----|treeMap    是基于红黑树的Map接口的实现。

2、Map

将键映射到值的对象。
key是唯一不重复，每一个key只能对应一个value

2.1、常用方法

2.1.1、添加或者修改功能

V put(K key,V value)：添加元素 /修改元素，并返回修改前元素的值

2.1.2、删除功能

void clear()：移除所有的键值对元素
V remove(Object key)：删除键对应的元素，并把值返回

2.1.3、判断功能

boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value)：判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空

2.1.4、获取功能

Set< Map.Entry< K,V>> entrySet()：遍历
V get(Object key)：根据键获取值
Set< K> keySet()：获取集合中所有键的集合
Collection< V> values()：获取集合中所有值的集合

2.1.5、长度功能

int size()：返回集合中的键值对的对数

2.2、案例

public static void main(String[] args) {

		Map<String, String> map=new HashMap<String,String>();

		// 添加元素
		System.out.println("-----------put-----------------");
		System.out.println(map.put("1", "11"));
		System.out.println(map.put("1", "111"));
		map.put("2", "2");
		map.put("3", "4");
		map.put("4", "4");
		map.put("5", "5");
		System.out.println(map);

	
		System.out.println("-----------containsKey判断集合是否包含指定的键-----------------");
		System.out.println(map.containsKey("1"));
		
		System.out.println("-----------containsValue判断集合是否包含指定的键-----------------");
		System.out.println(map.containsValue("111"));
		
		System.out.println("-----------isEmpty()判断集合是否为空-----------------");
		System.out.println(map.isEmpty());

		
		System.out.println("-----------size()：返回集合中的键值对的对数-----------------");
		System.out.println("size:"+map.size());
		
		
		
		System.out.println("-----------keySet：获取key的集合Set<T>-----------------");
		Set<String> set=map.keySet();
		for (String s : set) {
			System.out.print(s+":"+map.get(s)+"  ");
		}
		
		System.out.println();
		System.out.println("-----------values：获取value的Collection<T>-----------------");
		Collection<String>  value=map.values();
		for (String s : set) {
			System.out.print(s+":"+"  ");
		}
		System.out.println();
		
		System.out.println("-----------Set<Entry<String, String>>-----------------");
		Set<Entry<String, String>> entrySet = map.entrySet();
		for (Entry<String, String> entry : entrySet) {
			System.out.print(entry.getKey()+":"+	entry.getValue()+" ");
		}
		
		System.out.println();
		System.out.println("-----------remove根据键删除键值对元素，并把值返回-----------------");
		System.out.println("romove:"+map.remove("1"));
		System.out.println(map);
		
		
		System.out.println("-----------clear移除所有的键值对元素-----------------");
     	map.clear();
    	System.out.println(map);
	}

输出：
-----------put-----------------
null
11
{3=4, 2=2, 1=111, 5=5, 4=4}
-----------containsKey判断集合是否包含指定的键-----------------
true
-----------containsValue判断集合是否包含指定的键-----------------
true
-----------isEmpty()判断集合是否为空-----------------
false
-----------size()：返回集合中的键值对的对数-----------------
size:5
-----------keySet：获取key的集合Set<T>-----------------
3:4  2:2  1:111  5:5  4:4  
-----------values：获取value的Collection<T>-----------------
3:  2:  1:  5:  4:  
-----------Set<Entry<String, String>>-----------------
3:4 2:2 1:111 5:5 4:4 
-----------remove根据键删除键值对元素，并把值返回-----------------
romove:111
{3=4, 2=2, 5=5, 4=4}
-----------clear移除所有的键值对元素-----------------
{}

3、子类

HashMap
LinkedHashMap
Hashtable
treeMap
weakhashMap

4、HashMap

线程不安全
效率高。
允许null键和null值
是基于哈希表的Map接口实现。哈希表的作用是用来保证键的唯一性的。

4.1、构造方法

在这里插入图片描述

4.2、常用实例化方法

new HashMap< Object, Object>();

5、Hashtable:

线程安全
效率低
不允许null键和null值

6、LinkedHashMap

是基于Map接口的哈希表和链接列表实现,有序
由哈希表保证键的唯一性
由链表保证键盘的有序(存储和取出的顺序一致)

6.1、构造方法

在这里插入图片描述

6.2、常用实例化方法

new LinkedHashMap< Object, Object>();

6.3、案例

System.out.println("-----------LinkedHashMap唯一性 有序----------------");
//LinkedHashMap测试  由哈希表保证键的唯一性 由链表保证键盘的有序(存储和取出的顺序一致)
LinkedHashMap<String, String> lMap=new LinkedHashMap<String, String>();
// 创建并添加元素
lMap.put("11", "11");
lMap.put("22", "22");
lMap.put("33", "33");
lMap.put("44", "44");
lMap.put("55", "55");

// 遍历
Set<String> set2 = lMap.keySet();
for (String key : set2) {
	String value2 = lMap.get(key);
	System.out.println(key + "---" + value2);
}
输出：
-----------LinkedHashMap唯一性 有序----------------
11---11
22---22
33---33
44---44
55---55

7、treeMap

是基于红黑树的Map接口的实现。

7.1、构造方法

在这里插入图片描述

TreeMap() ：使用键的自然顺序构造一个新的、空的树映射。
TreeMap(Comparator< ? super K> comparator)：构造一个新的、空的树映射，该映射根据给定比较器进行排序

7.2、自然顺序

如果key是自定义的类，该类需要实现Comparator接口，基本类型都有实现该接口

		 
//构造方法摘要
//TreeMap()  使用键的自然顺序构造一个新的、空的树映射。
//TreeMap(Comparator<? super K> comparator) 构造一个新的、空的树映射，该映射根据给定比较器进行排序

System.out.println("--------------基本类型key自然排序----------------");		
TreeMap<String, String> tm=new TreeMap<String, String>();
tm.put("1", "1");
tm.put("2", "2");
tm.put("5", "5");
tm.put("4", "4");
tm.put("3", "3");
Set<String> set=tm.keySet();
for (String key : set) {
	String value=tm.get(key);
	System.out.println(key+"----"+value);
}


System.out.println("--------------自定义的类key自然排序----------------");		
TreeMap<Student, String> tm2=new TreeMap<Student, String>();
Student s1 = new Student("abc", 27);
Student s2 = new Student("abc", 29);
Student s3 = new Student("bcd", 23);
Student s4 = new Student("efd", 27);
Student s5 = new Student("cfd", 22);
Student s6 = new Student("cdf", 40);
Student s7 = new Student("bed", 22);
tm2.put(s1, "1");
tm2.put(s2, "2");
tm2.put(s3, "3");
tm2.put(s4, "4");
tm2.put(s5, "5");
tm2.put(s6, "6");
tm2.put(s7, "7");

Set<Student> set2=tm2.keySet();
for (Student key : set2) {
	String value=tm2.get(key);
	System.out.println(key+"----"+value);
}

输出：
--------------基本类型key自然排序----------------
1----1
2----2
3----3
4----4
5----5
--------------基本类型key自然排序----------------
Student [name=bed, age=22]----7
Student [name=cfd, age=22]----5
Student [name=bcd, age=23]----3
Student [name=abc, age=27]----1
Student [name=efd, age=27]----4
Student [name=abc, age=29]----2
Student [name=cdf, age=40]----6

7.3、比较排序：

System.out.println("--------------比较器排序----------------");
//TreeMap(Comparator<? super K> comparator) 构造一个新的、空的树映射，该映射根据给定比较器进行排序
TreeMap<Student, String> tm3=new TreeMap<Student, String>(new Comparator<Student>() {
	public int compare(Student s1, Student  s2) {
		//先按名字比较
		int num1=s1.getName().compareTo(s2.getName());
		//年龄比较
		int num2=num1==0?s1.getAge()-s2.getAge():num1;
		return num2;
	};
});
tm3.put(s1, "1");
tm3.put(s2, "2");
tm3.put(s3, "3");
tm3.put(s4, "4");
tm3.put(s5, "5");
tm3.put(s6, "6");
tm3.put(s7, "7");
Set<Student> set3=tm3.keySet();
for (Student key : set3) {
	String value=tm3.get(key);
	System.out.println(key+"----"+value);
}

输出：
--------------比较器排序----------------
Student [name=abc, age=27]----1
Student [name=abc, age=29]----2
Student [name=bcd, age=23]----3
Student [name=bed, age=22]----7
Student [name=cdf, age=40]----6
Student [name=cfd, age=22]----5
Student [name=efd, age=27]----4

Student 类

/*
 * 如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口
 */
public class Student implements Comparable<Student> {
	private String name;
	private int age;

	public Student() {
		super();
	}

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = 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;
	}

	@Override
	public int compareTo(Student s) {
		//按照年龄排序
		int num1= this.getAge()-s.getAge();
		如果年龄相同，按名字排序
		int num2=num1==0?(this.getName().compareTo(s.getName())):num1;
		return num2;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
}

8、weakhashMap

当对键的唯一引用来自散列表条目时，这一数据结构将和垃圾回收器协同工作一起删除键值

在这里插入图片描述

9、keySet和entrySet

@Test
	public void testMap1(){
		Map<Integer,String> map = new HashMap<Integer,String>();
		map.put(100,"jack");
		map.put(200,"marry");
		map.put(300,"sisi");
		Set<Integer> set = map.keySet();
		Iterator<Integer> it = set.iterator();
		while(it.hasNext()){
			Integer key = it.next();
			String value = map.get(key);
			System.out.println(key+"-"+value);
		}
	}
	@Test
	public void testMap2(){
		Map<Integer,String> map = new HashMap<Integer,String>();
		map.put(100,"jack");
		map.put(200,"marry");
		map.put(300,"sisi");
		Set<Entry<Integer,String>> set = map.entrySet();
		Iterator<Entry<Integer,String>> it = set.iterator();
		while(it.hasNext()){
			Entry<Integer,String> entry = it.next();
			Integer key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key+"<->"+value);
		}
	}

在这里插入图片描述

勤径苦舟

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java--基础--9.6--集合--Map--Map使用和子类使用

super K> comparator)：构造一个新的、空的树映射，该映射根据给定比较器进行排序。如果key是自定义的类，该类需要实现Comparator接口，基本类型都有实现该接口。当对键的唯一引用来自散列表条目时，这一数据结构将和垃圾回收器协同工作一起删除键值。TreeMap() ：使用键的自然顺序构造一个新的、空的树映射。
复制链接

扫一扫