集合框架中Map接口

最新推荐文章于 2023-03-09 12:00:14 发布

满心欢喜！

最新推荐文章于 2023-03-09 12:00:14 发布

阅读量225

点赞数

分类专栏： java基础学习文章标签：链表列表 java hashmap

本文链接：https://blog.csdn.net/CBXdm/article/details/108182953

版权

学习同时被 2 个专栏收录

28 篇文章 0 订阅

订阅专栏

java基础

5 篇文章 0 订阅

订阅专栏

集合框架Map接口

一、HashMap类和Hashtable类的用法
Map接口–集合接口–主要处理的是键值对结构的数据

键值对结构的数据—就是一个完成的数据是由键和键所对应的值组合而成的数据
例如:
书的目录就是一种键值对结构
【标题----页码】
Map接口下的子类HashMap类
1.HashMap类–public class HashMap【基于哈希表的实现的Map接口】

2.允许null的值和null键

3.数据保存是无序的

4.不能有重复的键，重复的键被算作是一个数据。
构造方法:
1.HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。

2.HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。

3.HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。

4.HashMap(Map<? extends K,? extends V> m) 构造一个新的 HashMap与指定的相同的映射 Map 。
例如：

package com.HashMapgouzao;
import java.util.HashMap;
public class Test {
	public static void main(String[] args) {
		//1.HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。
		HashMap ap = new HashMap();
		//2.HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。 
		HashMap ap2 = new HashMap(30);
		//3.HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。 
		HashMap ap3 = new HashMap(20,0.6f);
		//4.HashMap(Map<? extends K,? extends V> m) 构造一个新的 HashMap与指定的相同的映射 Map 。 
		HashMap ap4 = new HashMap(ap);
	}
}

实例方法:
1.Object put(Object key, Object value) 向集合中添加键值对数据

2.boolean containsKey(Object key) 判断集合中是否包含指定的键

3.boolean containsValue(Object value) 判断集合中是否包含指定的值

4.Object get(Object key) 根据指定的键得到该键对应的值

5.boolean isEmpty() 判断集合是否为空。

6.int size() 得到集合中键值对元素的个数

7.V remove(Object key) 根据指定的键删除对应的键值对数据值

8.Set keySet() 得到集合中所有的键保存到Set集合中

9.Collection values() 得到集合中所有的值保存到Collection集合中

10.Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据Set集合中

11.void clear() 清空集合。
例如：

package com.HashMapyongfa;
import java.util.Collection;
import java.util.HashMap;
import java.util.Set;
public class Test {
	public static void main(String[] args) {
		HashMap ap = new HashMap();
		//1.Object 	put(Object key, Object value) 向集合中添加键值对数据
		ap.put("id", 1023);
		ap.put(1111, "zhangsan");
		ap.put("height", 180.5);
		ap.put(0, false);
		//不能有重复的键，重复的键算一个数据。
		//ap.put(1111, "lisi");
		//可以有重复的值
		ap.put("name", "zahngsan");
		//键和值都可以为null
		ap.put(null, 1111);
		ap.put(1, null);
		System.out.println(ap.size());
		//2.boolean	containsKey(Object key) 判断集合中是否包含指定的键
		System.out.println(ap.containsKey("id"));
		//3.boolean	containsValue(Object value) 判断集合中是否包含指定的值
        System.out.println(ap.containsValue(true));
        //4.Object 	get(Object key) 根据指定的键得到该键对应的值
        System.out.println(ap.get("id"));
        //5.boolean	isEmpty() 判断集合是否为空。
        System.out.println(ap.isEmpty());
        //6.int	size() 得到集合中键值对元素的个数
        System.out.println(ap.size());
        //7.V	remove(Object key)  根据指定的键删除对应的键值对数据值
        ap.remove(0);
        System.out.println(ap.size());
        //8.Set	keySet() 得到集合中所有的键保存到Set集合中
        Set et = ap.keySet();
        for(Object o:et) {
        	 System.out.println("遍历键=="+o);
        }
        //9.Collection	values() 得到集合中所有的值保存到Collection集合中 
        Collection values = ap.values();
        for(Object t:values) {
        	System.out.println("遍历值=="+t);
        }
        //10.Set<Map.Entry<K,V>>	entrySet() 得到集合中所有的键值对数据Set集合中
        Set set = ap.entrySet();
        for (Object ject:set) {
        	System.out.println(ject);
        }
        //11.void	clear() 清空集合。
        ap.clear();
        System.out.println(ap.size());
	}
}

执行结果：
在这里插入图片描述
遍历HashMap集合
例如：

	package com.HashMapbianli;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Test {
	public static void main(String[] args) {
		HashMap ap = new HashMap();
		ap.put("id", 1023);
		ap.put(1111, "zhangsan");
		ap.put("height", 180.5);
		ap.put(0, false);
		//Set<Map.Entry<K,V>>	entrySet() 得到集合中所有的键值对数据保存Set集合中
		Set<Map.Entry<Object,Object>> set = ap.entrySet();
		for ( Map.Entry<Object,Object> p:set) {
			Object key = p.getKey();
			Object vau = p.getValue();
			System.out.println(key+":"+vau);		
		}
	}
}

执行结果：
在这里插入图片描述
Hashtable类
1.Hashtable类–public class Hashtable<K,V> 该类实现了一个哈希表，它将键映射到值。

2.无序

3.不能有null键/null值

4.用作键的对象必须实现hashCode方法和equals方法。

5.不能有重复的键，重复的键被算作是一个数据。

6.线程安全
构造方法
1.Hashtable() 构造一个新的，空的散列表，默认初始容量（11）和负载因子（0.75）。

2.Hashtable(int initialCapacity) 构造一个新的，空的哈希表，具有指定的初始容量和默认负载因子（0.75）。

3.Hashtable(int initialCapacity, float loadFactor) 构造一个新的，空的哈希表，具有指定的初始容量和指定的负载因子。

4.Hashtable(Map<? extends K,? extends V> t) 构造一个与给定地图相同的映射的新哈希表。
例如：

package com.Hashtablegouzao;
import java.util.Hashtable;
public class Test {
	public static void main(String[] args) {
		//1.Hashtable() 构造一个新的，空的散列表，默认初始容量（11）和负载因子（0.75）。 
        Hashtable le = new Hashtable();
        //2.Hashtable(int initialCapacity) 构造一个新的，空的哈希表，具有指定的初始容量和默认负载因子（0.75）。 
        Hashtable le2 = new Hashtable(10);
        //3.Hashtable(int initialCapacity, float loadFactor) 构造一个新的，空的哈希表，具有指定的初始容量和指定的负载因子。
        Hashtable le3 = new Hashtable(10,0.6f);
        //4.Hashtable(Map<? extends K,? extends V> t) 构造一个与给定地图相同的映射的新哈希表。
        Hashtable le4 = new Hashtable(le);
	}
}

实例方法

1.Object put(Object key, Object value) 向集合中添加键值对数据

2.boolean containsKey(Object key) 判断集合中是否包含指定的键

3.boolean containsValue(Object value) 判断集合中是否包含指定的值

4.Object get(Object key) 根据指定的键得到该键对应的值

5.boolean isEmpty() 判断集合是否为空。

6.int size() 得到集合中键值对元素的个数

7.V remove(Object key) 根基指定的键删除对应的键值对数据值

8.Set keySet() 得到集合中所有的键保存到Set集合中

9.Collection values() 得到集合中所有的值保存到Collection集合中

10.Set<Map.Entry<K,V>> entrySet() 得到集合中所有的键值对数据Set集合中

11.Enumeration keys() 返回此散列表中键的枚举。

12.Enumeration elements() 返回此散列表中值的枚举。

13.void clear() 清空集合。
例如：

package com.Hashtableyongfa;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Map;
import java.util.Set;
public class Test {
	public static void main(String[] args) {
		Hashtable le = new Hashtable();
		//1.Object 	put(Object key, Object value) 向集合中添加键值对数据
		le.put("id", 1230);
		le.put(0, true);
		le.put(1320, "zhangsan");
		//不能有重复的键，重复的键算一个，值可以重复
        //le.put("id", 5262);
		le.put("name", "zhangsan");
		//不能null
		//le.put(null, false);错误
		//le.put(true, null);错误
        System.out.println(le.size());
        //2.boolean	containsKey(Object key) 判断集合中是否包含指定的键
        System.out.println(le.containsKey("id"));
        //3.boolean	containsValue(Object value) 判断集合中是否包含指定的值
        System.out.println(le.containsValue(true));
        //4.Object 	get(Object key) 根据指定的键得到该键对应的值
        System.out.println(le.get("id"));
        //5.boolean	isEmpty() 判断集合是否为空。
        System.out.println(le.isEmpty());
        //6.int	size() 得到集合中键值对元素的个数
        System.out.println(le.size());
        //7.V	remove(Object key)  根基指定的键删除对应的键值对数据值
        le.remove("id");
        System.out.println(le.size());
        //8.Set	keySet() 得到集合中所有的键保存到Set集合中
        Set st = le.keySet();
        for(Object o:st) {
        	System.out.println("遍历键=="+o);
        }
        //9.Collection	values() 得到集合中所有的值保存到Collection集合中
        Collection ct = le.values();
        for(Object ject:ct) {
        	System.out.println("遍历值=="+ject);
        }
        //10.Set<Map.Entry<K,V>>	entrySet() 得到集合中所有的键值对数据Set集合中
        Set<Map.Entry<Object,Object>> set = le.entrySet();
        for(Map.Entry<Object, Object> set1:set) {
        	Object key = set1.getKey();
        	Object vau = set1.getValue();
        	System.out.println(key+":"+vau);
        } 
        //11.Enumeration<K>	keys() 返回此散列表中键的枚举。 
        Enumeration er = le.keys();
        //12.Enumeration<V>	elements() 返回此散列表中值的枚举。 
        Enumeration er2 = le.elements();  
	}
}

执行结果:
在这里插入图片描述
遍历Hashtable类
例如

package com.Hashtablebianli;
import java.util.Hashtable;
import java.util.Map;
import java.util.Set;
public class Test {
	public static void main(String[] args) {
		Hashtable le = new Hashtable();
		//1.Object 	put(Object key, Object value) 向集合中添加键值对数据
		le.put("id", 1230);
		le.put(0, true);
		le.put(1320, "zhangsan");
        //Set<Map.Entry<K,V>>	entrySet() 得到集合中所有的键值对数据Set集合中
        Set<Map.Entry<Object,Object>> set = le.entrySet();
        for(Map.Entry<Object, Object> set1:set) {
        	Object key = set1.getKey();
        	Object vau = set1.getValue();
        	System.out.println(key+":"+vau);
        } 
	}
}

执行图片：
在这里插入图片描述 TreeMap类–红黑树基于NavigableMap实现【有序】
ConcurrentHashMap类—线程安全，支持高并发，哈希表
二、HashMap类与Hashtable类与TreeMap类与ConcurrentHashMap类的区别

HashMap类	Hashtable类
可以有null键/null值	不能有null键/null值
HashMap继承AbstractMap类	Hashtable继承Dictionary类
默认容量为16	默认容量为11
扩展后将容量变为原来的2倍	扩展后将容量变为原来的2倍加1
线程不安全	线程安全

HashMap底层实现原理
HashMap基于hashing原理，我们通过put()和get()方法储存和获取对象。当我们将键值对传递给put()方法时，它调用键对象的hashCode()方法来计算hashcode，然后找到bucket位置来储存值对象。当获取对象时，通过键对象的equals()方法找到正确的键值对，然后返回值对象。HashMap使用链表来解决碰撞问题，当发生碰撞了，对象将会储存在链表的下一个节点中。 HashMap在每个链表节点中储存键值对对象。当两个不同的键对象的hashcode相同时会发生什么？它们会储存在同一个bucket位置的链表中。键对象的equals()方法用来找到键值对。

HashMap类	ConcurrentHashMap类
线程不安全	线程安全

Hashtable类	ConcurrentHashMap类
线程安全高并发是效率低	线程安全高并发是效率高

HashTable里使用的是synchronized关键字，这其实是对对象加锁，锁住的都是对象整体，当Hashtable的大小增加到一定的时候，性能会急剧下降，因为迭代时需要被锁定很长的时间。

ConcurrentHashMap使用了分割，将一个map分成多个小的hashtable，对map的一部分进行上锁。保证同步的同时，有提高了性能。
在这里插入图片描述

三、认识Collections类【集合类的帮助类】
1.public class Collections----此类仅由静态方法组合或返回集合

2.此类中的方法都是静态方法，静态方法为了帮助我们更加方便的操作集合中的数据。
静态方法：
1.void sort(List list) 根据其元素的natural ordering对指定的列表进行排序。

2.static void reverse(List<?> list) 反转指定列表中元素的顺序。

3.static void copy(List<? super T> dest, List<?extends T> src) 将所有元素从一个列表复制到另一个列表中。

4.static <T extends Object & Comparable<? super T>>T max(Collection<? extends T> coll) 根据其元素的自然顺序返回给定集合的最大元素。

5.static <T extends Object & Comparable<? super T>>
T min(Collection<? extends T> coll)根据其元素的自然顺序返回给定集合的最小元素。
例如：

package com.Collectionsyongfa;
import java.util.ArrayList;
import java.util.Collections;
public class Test {
	public static void main(String[] args) {
		ArrayList  list = new ArrayList();
		list.add(2);
		list.add(3);
		list.add(1);
		list.add(4);
		list.add(5);
		//1.void	sort(List<T> list) 根据其元素的natural ordering对指定的列表进行排序。 
		Collections.sort(list);
		for(Object shuzi:list) {
			System.out.println("shuzi=="+shuzi);
		}
		System.out.println("___________");
		//2.static void	reverse(List<?> list) 反转指定列表中元素的顺序。
		Collections.reverse(list);
		for(Object shuzi2:list) {
			System.out.println("shuzi2=="+shuzi2);
		}
		System.out.println("___________");
        //3.static <T> void	copy(List<? super T> dest, List<?extends T> src) 将所有元素从一个列表复制到另一个列表中。
		ArrayList  arr1=new ArrayList();
		arr1.add("zhangsan");
		arr1.add("lisi");
		arr1.add("wangwu");
		arr1.add("zhaoliu");
		ArrayList  arr2=new ArrayList();
		arr2.add(123);
		arr2.add(23);
		arr2.add(4567);
		arr2.add(2);
		for(Object ject:arr2) {
			System.out.println(ject);
		}
		System.out.println("_________");
		Collections.copy(arr2, arr1);
		for(Object ject2:arr2) {
			System.out.println(ject2);
		}	
		//4.static <T extends Object & Comparable<? super T>>T	max(Collection<? extends T> coll) 根据其元素的 自然顺序返回给定集合的最大元素。 
		System.out.println(Collections.max(list));
		//5.static <T extends Object & Comparable<? super T>>T	min(Collection<? extends T> coll) 根据其元素的 自然顺序返回给定集合的最小元素。
		System.out.println(Collections.min(list));
	}
}

执行结果：
在这里插入图片描述注意与Arrays的比较

四、Collection接口与Collections类的区别

Collection接口	Collections类
Interface	Class
包含了一些集合的基本操作方法【增删改查】	集合框架的帮助类对集合的排序，搜索以及序列化的操作

满心欢喜！

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
集合框架中Map接口

集合框架Map接口一、HashMap类和Hashtable类的用法Map接口–集合接口–主要处理的是键值对结构的数据键值对结构的数据—就是一个完成的数据是由键和键所对应的值组合而成的数据例如:书的目录就是一种键值对结构【标题----页码】Map接口下的子类HashMap类1.HashMap类–public class HashMap【基于哈希表的实现的Map接口】2.允许null的值和null键3.数据保存是无序的4.不能有重复的键，重复的键被算作是一个数据。构造方法:1.Hash
复制链接

扫一扫