• 27.集合框架-Map接口及其子类和Collections类(3)[20220728]

    Map接口用来处理键值对数据的集合

    HashMap类

    1.HashMap 继承自AbstractMap
    2.数据保存是无序的
    3.重复的键被算作是一个数据。
    4.允许有null键，null值
    5.初始容量16
    6.扩容为原来的2倍
    7.根据key【键】的得到hashcode值，然后根据这个hashcode值计算元素在集合中的位置。
    8.非线程安全

    HashMap类的构造方法:
    HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。 
    HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。 
    HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。 
    HashMap(Map m) 构造一个新的 HashMap与指定的相同的映射 Map 。

    1. package com.wangxing.test1;
    2. import java.util.HashMap;
    3. import java.util.Hashtable;
    4. import java.util.Map;
    5. public class TestHashMapClass {
    6. 	public static void main(String[] args) {
    7. 		//构造方法
    8. 		//HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。 
    9. 		HashMap  hashmap1=new HashMap();
    10. 		Map  map1=new HashMap();
    11. 		//HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。 
    12. 		HashMap  hashmap2=new HashMap(36);
    13. 		Map  map2=new HashMap(36);
    14. 		//HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。 
    15. 		HashMap  hashmap3=new HashMap(36,0.5f);
    16. 		Map  map3=new HashMap(36,0.5f);
    17. 		//HashMap(Map m)将Map接口的子类转换成HashMap集合 。
    18. 		Hashtable table=new Hashtable();
    19. 		HashMap hashmap4=new HashMap(table);
    20. 		Map map4=new HashMap(table);
    21. 	}
    22. }

    HashMap类的实例方法:
    void    clear() 清空集合。 
    Object     put(Object key, Object value) 向集合中添加键值对数据
    boolean    containsKey(Object key) 判断集合中是否包含指定的键
    boolean    containsValue(Object value) 判断集合中是否包含指定的值
    Object     get(Object key) 根据指定的键得到该键对应的值
    boolean    isEmpty() 判断集合是否为空。
    int    size() 得到集合中键值对元素的个数
    V    remove(Object key)  根基指定的键删除对应的键值对数据值
    Set    keySet() 得到集合中所有的键保存到Set集合中
    Collection    values() 得到集合中所有的值保存到Collection集合中 
    Set>    entrySet() 得到集合中所有的键值对数据Set集合中

    1. package com.wangxing.test1;
    2. import java.util.Collection;
    3. import java.util.HashMap;
    4. import java.util.Iterator;
    5. import java.util.Map;
    6. import java.util.Set;
    7. public class TestHashMapClass2 {
    8. 	public static void main(String[] args) {
    9. 			HashMap<Object,Object>  map1=new HashMap<Object,Object>();
    10. 			//HashMap类中的实例方法:
    11. 			//Object put(Object key, Object value) 向集合中添加键值对数据
    12. 			map1.put("name", "zhangsan");
    13. 			map1.put("age",23);
    14. 			map1.put("address","西安");
    15. 			map1.put("height",168.5);
    16. 			map1.put("zhangsan", "name");
    17. 			map1.put(23,"age");
    18. 			map1.put("西安","address");
    19. 			map1.put(168.5,"height");
    20. 			//map1.put("name", "lisi");//重复的键算一个键值对数据
    21. 			//map1.put("myname","zhangsan");//可以有重复的值
    22. 			//map1.put(null,null); //允许有null键/null值
    23. 			//int	size() 得到集合中键值对元素的个数
    24. 			System.out.println("size=="+map1.size());
    25. 			//boolean	containsKey(Object key) 判断集合中是否包含指定的键
    26. 			System.out.println("containsKey=="+map1.containsKey("name"));
    27. 			//boolean	containsValue(Object value) 判断集合中是否包含指定的值
    28. 			System.out.println("containsValue=="+map1.containsValue("name"));
    29. 			//Object 	get(Object key) 根据指定的键得到该键对应的值
    30. 			System.out.println("get=="+map1.get("zhangsan"));
    31. 			//void	clear() 清空集合。 
    32. 			//map1.clear();
    33. 			//boolean	isEmpty() 判断集合是否为空。
    34. 			System.out.println("isEmpty=="+map1.isEmpty());
    35. 			//V	remove(Object key)根基指定的键删除对应的键值对数据值
    36. 			map1.remove("name");
    37. 			System.out.println("size=="+map1.size());
    38. 			
    39. 			//遍历HashMap集合
    40. 			//Set	keySet() 得到集合中所有的键保存到Set集合中
    41. 			Set keys=map1.keySet();
    42. 			for(Object obj:keys){
    43. 				System.out.println("所有的key---"+obj);
    44. 			}
    45. 			System.out.println("------------");
    46. 			Iterator iterator=keys.iterator();
    47. 			while(iterator.hasNext()){
    48. 				Object obj=iterator.next();
    49. 				System.out.println("所有的key---"+obj);
    50. 			}
    51. 			System.out.println("------------");
    52. 			//Collection	values() 得到集合中所有的值保存到Collection集合中 
    53. 			Collection collection=map1.values();
    54. 			for(Object obj:collection){
    55. 				System.out.println("所有的value---"+obj);
    56. 			}
    57. 			System.out.println("------------");
    58. 			Iterator iteratorvalue=collection.iterator();
    59. 			while(iteratorvalue.hasNext()){
    60. 				Object obj=iteratorvalue.next();
    61. 				System.out.println("所有的value---"+obj);
    62. 			}
    63. 			System.out.println("------------");
    64. 			//Set>	entrySet() 得到集合中所有的键值对数据Set集合中
    65. 			for(Map.Entry<Object,Object> entry:map1.entrySet()){
    66. 				System.out.println("集合中的键值对是=="+
    67. 				entry.getKey()+":"+entry.getValue());
    68. 			}
    69. 	}
    70. }

    Hashtable类

    1.Hashtable继承自Dictionary
    2.数据保存是无序的
    3.重复的键被算作是一个数据。
    4.不允许有null键，null值
    5.初始容量11
    6.扩容为原来的2n+1
    7.Hashtable的对象得到hashcode值，通过除数留余的计算方法来算出元素在集合中的位置
    8.线程安全

    Hashtable类的构造方法:
    Hashtable() 构造一个新的，空的散列表，默认初始容量（11）和负载因子（0.75）。 
    Hashtable(int initialCapacity) 构造一个新的,空的哈希表,具有指定的初始容量和默认负载因子0.75 
    Hashtable(int initialCapacity, float loadFactor) 构造一个新的，空的哈希表，具有指定的初始容量和指定的负载因子。 
    Hashtable(Map t) 构造一个与给定地图相同的映射的新哈希表。

    1. package com.wangxing.test2;
    2. import java.util.HashMap;
    3. import java.util.Hashtable;
    4. import java.util.Map;
    5. public class TestHashtableClass {
    6. 	public static void main(String[] args) {
    7. 		//构造方法
    8. 		//Hashtable() 构造一个新的，空的散列表，默认初始容量（11）和负载因子（0.75）。 
    9. 		Hashtable hashtable1=new Hashtable();
    10. 		Map  map1=new Hashtable();
    11. 		//Hashtable(int initialCapacity) 构造一个新的,空的哈希表,具有指定的初始容量和默认负载因子0.75 
    12. 		Hashtable hashtable2=new Hashtable(20);
    13. 		Map  map2=new Hashtable(20);
    14. 		//Hashtable(int initialCapacity, float loadFactor) 构造一个新的，空的哈希表，具有指定的初始容量和指定的负载因子。 
    15. 		Hashtable hashtable3=new Hashtable(20,0.5f);
    16. 		Map  map3=new Hashtable(20,0.5f);
    17. 		//Hashtable(Map t)将Map接口的子类转换成Hashtable。 
    18. 		HashMap  hashmap=new HashMap();
    19. 		Hashtable  table4=new Hashtable(hashmap);
    20. 		Map  map4=new Hashtable(hashmap);
    21. 	}
    22. }

    Hashtable类的实例方法:
    void    clear() 清空集合。 
    Object     put(Object key, Object value) 向集合中添加键值对数据
    boolean    containsKey(Object key) 判断集合中是否包含指定的键
    boolean    containsValue(Object value) 判断集合中是否包含指定的值
    Object     get(Object key) 根据指定的键得到该键对应的值
    boolean    isEmpty() 判断集合是否为空。
    int    size() 得到集合中键值对元素的个数
    V    remove(Object key)  根基指定的键删除对应的键值对数据值
    Set    keySet() 得到集合中所有的键保存到Set集合中
    Collection    values() 得到集合中所有的值保存到Collection集合中 
    Set>    entrySet() 得到集合中所有的键值对数据Set集合中

    1. package com.wangxing.test2;
    2. import java.util.Collection;
    3. import java.util.Hashtable;
    4. import java.util.Iterator;
    5. import java.util.Map;
    6. import java.util.Set;
    7. public class TestHashtableClass2 {
    8. 	public static void main(String[] args) {
    9. 			Hashtable<Object,Object> table=new Hashtable<Object,Object>();
    10. 			//Hashtable类中的实例方法:
    11. 			//Object 	put(Object key, Object value) 向集合中添加键值对数据
    12. 			table.put("name", "zhangsan");
    13. 			table.put("age", 23);
    14. 			table.put("height", 168.5);
    15. 			table.put("zhangsan","name");
    16. 			table.put(23,"age");
    17. 			table.put(168.5,"height");
    18. 			//table.put("name", "lisi"); //重复的键算一个
    19. 			//table.put("myname", "zhangsan");//可以有重复的值
    20. 			//table.put(null,"test");//不允许有null键
    21. 			//table.put("test",null);//不允许有null值
    22. 			Student stu1=new Student();
    23. 			table.put(stu1,"student类对象");
    24. 			//int	size() 得到集合中键值对元素的个数
    25. 			System.out.println("size=="+table.size());
    26. 			//boolean	containsKey(Object key) 判断集合中是否包含指定的键
    27. 			System.out.println("containsKey=="+table.containsKey(stu1));
    28. 			//boolean	containsValue(Object value) 判断集合中是否包含指定的值
    29. 			System.out.println("containsValue=="+table.containsValue("lisi"));
    30. 			//Object 	get(Object key) 根据指定的键得到该键对应的值
    31. 			System.out.println("get=="+table.get(stu1));
    32. 			//void	clear() 清空集合。 
    33. 			//table.clear();
    34. 			//boolean	isEmpty() 判断集合是否为空。
    35. 			System.out.println("isEmpty=="+table.isEmpty());
    36. 			//V	remove(Object key)  根基指定的键删除对应的键值对数据值
    37. 			table.remove(stu1);
    38. 			System.out.println("size=="+table.size());
    39. 			
    40. 			//遍历Hashtable
    41. 			//Set	keySet() 得到集合中所有的键保存到Set集合中
    42. 			Set setkeys=table.keySet();
    43. 			for(Object  keyobj:setkeys){
    44. 				System.out.println("所有键key==="+keyobj);
    45. 			}
    46. 			System.out.println("------------");
    47. 			Iterator iterator=setkeys.iterator();
    48. 			while(iterator.hasNext()){
    49. 				Object  keyObj=iterator.next();
    50. 				System.out.println("所有键key==="+keyObj);
    51. 			}
    52. 			System.out.println("------------");
    53. 			//Collection	values() 得到集合中所有的值保存到Collection集合中 
    54. 			Collection  collection=table.values();
    55. 			for(Object valueObj:collection){
    56. 				System.out.println("所有值value=="+valueObj);
    57. 			}
    58. 			System.out.println("------------");
    59. 			Iterator valueiterator=collection.iterator();
    60. 			while(valueiterator.hasNext()){
    61. 				Object  valueObj=valueiterator.next();
    62. 				System.out.println("所有值value==="+valueObj);
    63. 			}
    64. 			System.out.println("------------");
    65. 			//Set>	entrySet() 得到集合中所有的键值对数据Set集合中
    66. 			for(Map.Entry<Object,Object>  entry:table.entrySet()){
    67. 				System.out.println("键值对数据=="+
    68. 					entry.getKey()+":"+entry.getValue());
    69. 			}
    70. 	}
    71. }

    TreeMap类

    1.继承自AbstractMap
    2.数据保存是有序按照字母顺序排列
    3.重复的键被算作是一个数据。
    4.允许有null键，不允许null值，键最好是String类型
    5.没有初始容量
    6.没有扩容机制
    7.红黑树基于NavigableMap实现
    8.非线程安全

    TreeMap类构造方法
    TreeMap() 使用其键的自然排序构造一个新的空树状图。 
    TreeMap(Map m) 构造一个新的树状图，其中包含与给定地图相同的映射，根据其键的自然顺序进行排序 。

    TreeMap类实例方法:
    void    clear() 清空集合。 
    Object     put(Object key, Object value) 向集合中添加键值对数据
    boolean    containsKey(Object key) 判断集合中是否包含指定的键
    boolean    containsValue(Object value) 判断集合中是否包含指定的值
    Object     get(Object key) 根据指定的键得到该键对应的值
    boolean    isEmpty() 判断集合是否为空。
    int    size() 得到集合中键值对元素的个数
    V    remove(Object key)  根基指定的键删除对应的键值对数据值
    Set    keySet() 得到集合中所有的键保存到Set集合中
    Collection    values() 得到集合中所有的值保存到Collection集合中 
    Set>    entrySet() 得到集合中所有的键值对数据Set集合中

    ConcurrentHashMap类

    支持检索的完全并发性和更新的高预期并发性的哈希表。 这个类服从相同功能规范如Hashtable ，并且包括对应于每个方法的方法版本Hashtable 。 不过，尽管所有操作都是线程安全的，检索操作并不意味着锁定，并没有为防止所有访问的方式锁定整个表的任何支持。 这个类可以在依赖于线程安全性的程序中与Hashtable完全互Hashtable ，但不依赖于其同步细节。 

    如果需要线程安全的并发实现，那么建议使用ConcurrentHashMap代替Hashtable。 

    1.继承自AbstractMap
     2.数据保存是无序的
     3.重复的键被算作是一个数据。
     4.不允许有null键，null值
     5.初始容量16
     6.jdk8中，采用多线程扩容。整个扩容过程，通过CAS设置sizeCtl，transferIndex等变量协      
    调多个线程进行并发扩容。
          多线程无锁扩容的关键就是通过CAS设置sizeCtl与transferIndex变量，协调多个线程对table
    数组中的node进行迁移。
    7.如果需要线程安全的并发实现，那么建议使用ConcurrentHashMap代替Hashtable 。 
    8.线程安全

    ConcurrentHashMap类的构造方法
    ConcurrentHashMap()创建一个空的默认的初始容量大小为16的集合对象。  
    ConcurrentHashMap(int initialCapacity)创建一个指定初始容量的空的集合对象 
    ConcurrentHashMap(int initialCapacity, float loadFactor)根据给定的元素数(initialCapacity)
    和初始表密度(loadFactor)，创建一个空的集合对象 。  
    ConcurrentHashMap(Map m)将Map接口的子类转换成ConcurrentHashMap 

    ConcurrentHashMap类的实例方法:
    void    clear() 清空集合。 
    Object     put(Object key, Object value) 向集合中添加键值对数据
    boolean    containsKey(Object key) 判断集合中是否包含指定的键
    boolean    containsValue(Object value) 判断集合中是否包含指定的值
    Object     get(Object key) 根据指定的键得到该键对应的值
    boolean    isEmpty() 判断集合是否为空。
    int    size() 得到集合中键值对元素的个数
    V    remove(Object key)  根基指定的键删除对应的键值对数据值
    Set    keySet() 得到集合中所有的键保存到Set集合中
    Collection    values() 得到集合中所有的值保存到Collection集合中 
    Set>    entrySet() 得到集合中所有的键值对数据Set集合中

    Collections类 

    public class Collectionsextends Object
    专门给集合类库提供的一个，用来对集合进行排序、检索、线程安全等操作的帮助类
    Collections类中的方法都是静态方法 

    Collections类中的常用方法
    static void copy(List dest, List src) 将所有元素从一个列表复制到另一个列表中。  
    static T max(Collection coll) 返回给定集合的最大元素
    static T min(Collection coll) 返回给定集合的最小元素。  
    static void reverse(List list) 反转指定列表中元素的顺序。 
    static void sort(List list) 对指定的列表进行排序【默认升序排列】。 

    1. package com.wangxing.test1;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Collections;
    5.  
    6. public class TsetCollectionsClass {
    7. 	public  static  void  main(String args[]){
    8. 		//Collections类--专门给集合类库提供的一个，用来对集合进行排序、检索、线程安全等操作的帮助类
    9. 		//Collections类中的方法都是静态方法
    10. 		ArrayList  list1=new ArrayList();
    11. 		list1.add("zhangsan");
    12. 		list1.add("lisi");
    13. 		list1.add("wangwu");
    14. 		ArrayList  list2=new ArrayList();
    15. 		list2.add(890);
    16. 		list2.add(996);
    17. 		list2.add(768);
    18. 		list2.add(45);
    19. 		//static void copy(List dest, List src) 将所有元素从一个列表复制到另一个列表中。  
    20. 		//Collections.copy(list2, list1);
    21. 		/*
    22. 		for(Object obj:list2){
    23. 			System.out.println("list2--"+obj);
    24. 		}
    25. 		*/
    26. 		
    27. 		//static T max(Collection coll) 返回给定集合的最大元素
    28. 		System.out.println("得到list2中的最大元素=="+Collections.max(list2));
    29. 		//static T min(Collection coll) 返回给定集合的最小元素。
    30. 		System.out.println("得到list2中的最小元素=="+Collections.min(list2));
    31. 		//static void sort(List list) 对指定的列表进行排序。
    32. 		Collections.sort(list1);
    33. 		for(Object obj:list1){
    34. 			System.out.println("list1升序--"+obj);
    35. 		}
    36. 		System.out.println("------------");
    37. 		Collections.sort(list2);
    38. 		for(Object obj:list2){
    39. 			System.out.println("list2升序--"+obj);
    40. 		}
    41. 		System.out.println("------------");
    42. 		//static void reverse(List list) 反转指定列表中元素的顺序。 
    43. 		Collections.reverse(list1);
    44. 		for(Object obj:list1){
    45. 			System.out.println("list1降序--"+obj);
    46. 		}
    47. 	}
    48. }
  • 相关阅读:
    尚品汇电商项目总结
    rust智能指针
    网络规划设计师上午真题及解析（2019）
    iPortal如何灵活设置用户名及密码的安全规则
    Conditional GAN
    最全面的window dos/bat 常用命令
    深度学习 | Transformer 基本原理
    探索性测试的概念及方法
    C++-openssl-aes-cbc-pkcs5
    .NET科普：.NET简史、.NET Standard以及C#和.NET Framework之间的关系
  • 原文地址：https://blog.csdn.net/guizhaiteng/article/details/126037820