新手小白学JAVA Set HashSet Map HashMap

墨蓝 2021-09-07 20:28 436阅读 0赞

# 1 Map接口 #

## 1.1 概述 ##

Java.util接口Map<K,V>  
类型参数 : K - 表示此映射所维护的键 V – 表示此映射所维护的对应的值  
也叫做哈希表、散列表. 常用于键值对结构的数据.其中键不能重复,值可以重复  
![在这里插入图片描述][20210520135311402.png]

## 1.2 特点 ##

1.  Map可以根据键来提取对应的值
2.  Map的键不允许重复,如果重复,对应的值会被覆盖
3.  Map存放的都是无序的数据
4.  Map的初始容量是16,默认的加载因子是0.75  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70]

> TIPS:源码摘抄:  
> static final int DEFAULT\_INITIAL\_CAPACITY = 1 << 4;  
> 初始容量1<<4,相当于1\*(2^4),也就是16  
> static final float DEFAULT\_LOAD\_FACTOR = 0.75f;  
> 默认的加载因子是0.75f,也就是存到75%开始扩容,按照2的次幂进行扩容

## 1.3 继承结构 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 1]

## 1.4 常用方法 ##

学习Map接口中的方法即可

> void clear() 从此映射中移除所有映射关系（可选操作） boolean containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true  
> boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true  
> Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图  
> boolean equals(Object o) 比较指定的对象与此映射是否相等  
> V get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null  
> int hashCode() 返回此映射的哈希码值  
> boolean isEmpty() 如果此映射未包含键-值映射关系，则返回 true  
> Set keySet() 返回此映射中包含的键的 Set 视图  
> V put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）  
> void putAll(Map<? extends K,? extends V> m)从指定映射中将所有映射关系复制到此映射中（可选操作）  
> V remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）  
> int size() 返回此映射中的键-值映射关系数  
> Collection values() 返回此映射中包含的值的 Collection 视图

## 1.5 练习：Map常用方法测试 ##

创建包: cn.tedu.collection  
创建类: TestMap.java

package cn.tedu.list;
    
    import java.util.*;
    
    /**本类用于测试Map接口*/
    public class TestMap { 
        public static void main(String[] args) { 
            //1.创建Map对象
            /**Map中的数据要符合映射规则，一定注意要同时指定K和V的数据类型 * 至于这个K和V具体要指定成什么类型，取决于具体的业务需求*/
            Map<Integer,String> map = new HashMap<>();//注意导包：java.util
            //2.向map集合存入数据，注意方法是put(),并且需要存入一对<K,V>的值
            map.put(9527,"白骨精");
            map.put(9528,"黑熊精");
            map.put(9529,"鲤鱼精");
            map.put(9530,"黄毛怪");
            map.put(9531,"黑熊精");
            map.put(9527,"女儿国国王");
            /**1.map中存放着的都是无序的数据 * 2.map中的value可以重复-比如我们可以存两个黑熊精 * 3.map中的key不允许重复，如果重复，后面的value会把前面的value覆盖掉 * 比如女儿国国王和白骨精都是9527，白骨精就被覆盖掉了*/
            System.out.println(map);//查看map集合中的数据是否存入成功
    
            //3.进行方法测试
            //map.clear();//清空集合
            System.out.println(map.hashCode());//获取集合的哈希码
            System.out.println(map.equals("黄毛怪"));//判断“黄毛怪”是否与集合对象相等
            System.out.println(map.isEmpty());//判断集合是否为空
            System.out.println(map.size());//获取集合中元素的个数
    
            //判断当前map集合中是否包含指定的Key键
            System.out.println(map.containsKey(9527));//true
            //判断当前map集合中是否包含指定的Value
            System.out.println(map.containsValue("白骨精"));//false,因为已被覆盖
            //根据key值获取到对应的value值
            System.out.println(map.get(9530));
            //根据此key值对应的键值对，K与V都删了
            System.out.println(map.remove(9529));
            System.out.println(map.containsKey(9529));
            System.out.println(map.containsValue("鲤鱼精"));
    
            //将map集合中的所有value取出，放入Collection集合中
            //Collection<Type>中Type的类型，取决于map中value的类型
            Collection<String> values = map.values();
            System.out.println(values);//[女儿国国王, 黑熊精, 黄毛怪, 黑熊精]
    
            //4.map集合的迭代方式一
            /**方式一： * 遍历map中的数据，但是map本身没有迭代器，所以需要先转换成set集合 * Set<Key>:把map中的所有key值存入到set集合当中--keySet()*/
            //4.1将map集合中的key值取出存入set集合中，集合的泛型就是key的类型Integer
            Set<Integer> keySet = map.keySet();
            //4.2想要遍历集合就需要获取集合的迭代器
            Iterator<Integer> it = keySet.iterator();
            //4.3循环迭代集合中的所有元素
            while(it.hasNext()){ //判断是否有下一个元素可以迭代
                Integer key = it.next();//拿到本轮循环中获取到的map的key
                String value = map.get(key);
                System.out.println("{"+key+","+value+"}");
            }
    
            /**方式二： * 遍历map集合，需要把map集合先转成set集合 * 是把map中的一对键值对key&value作为一个Entry<K,V>整体放入set * 一对K,V就是一个Entry*/
            Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
            //获取迭代器
            Iterator<Map.Entry<Integer, String>> it2 = entrySet.iterator();
            while(it2.hasNext()){ //判断是否有下一个元素可迭代
                //本轮遍历到的一个Entry对象
                Map.Entry<Integer, String> entry = it2.next();
                Integer key = entry.getKey();//获取Entry中的key
                String value = entry.getValue();//获取Entry中的value
                System.out.println("{"+key+","+value+"}");
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 2]

# 2 HashMap #

## 2.1 前言 ##

HashMap的键要同时重写hashCode()和equlas()  
hashCode()用来判定二者的hash值是否相同,重写后根据属性生成  
equlas()用来判断属性的值是否相同,重写后,根据属性判断  
–equlas()判断数据如果相等,hashCode()必须相同  
–equlas()判断数据如果不等,hashCode()尽量不同

## 2.2概述 ##

HashMap底层是一个Entry\[ \]数组,当存放数据时,会根据hash算法来计算数据的存放位置  
算法:hash(key)%n , n就是数组的长度,其实也就是集合的容量  
当计算的位置没有数据的时候,会直接存放数据  
当计算的位置,有数据时,会发生hash冲突/hash碰撞,解决的办法就是采用链表的结构,在数组中指定位置处已有元素之后插入新的元素,也就是说数组中的元素都是最早加入的节点  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 3]

## 2.3 练习：获取HashMap的数据 ##

创建包: cn.tedu.collection  
创建类: TestHashMap.java

package cn.tedu.collection;
    
    import java.util.HashMap;
    
    /**本类用于HashMap的练习*/
    public class TestHashMap { 
    	public static void main(String[] args) { 
    		//创建HashMap对象
    		HashMap<Integer,String> map = new HashMap();
    		/** * 源码摘抄: * static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 * 初始容量为1<<4,相当于1*(2^4)=16 * static final float DEFAULT_LOAD_FACTOR = 0.75f; * 默认的加载因子是0.75,也就是说存到75%开始扩容,按照2的次幂进行扩容 */
    		/* * 达到容量的加载因子后,就会重新开辟空间,重新计算所有对象的存储位置,也叫做rehash * 设置初始容量与加载因子要讲求相对平衡,如果加载因子过低,则rehash过于频繁,影响性能 * 如果初始容量设置太高或者加载因子设置太高,影响查询效率 */
    	}
    }

## 2.4 练习：字符串中字符统计 ##

创建包: cn.tedu.collection  
创建类: TestMap2.java

package cn.tedu.collection;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Scanner;
    
    /** * 本类用来完成Map集合相关练习 * 需求:提示并接收用户输入的一串字符,并且统计出每个字符出现的次数 * */
    public class TestMap2 { 
    	public static void main(String[] args) { 
    		//1.提示用户输入要统计的字符串
    		System.out.println("请输入您要统计的字符串");
    		//2.接收用户输入的要统计的字符串
    		String input = new Scanner(System.in).nextLine();
    		//3.获取到用户输入的每个字符,String底层维护的是char[]
    		//创建map集合存放数据,格式:{b=2,d=4,g=3}
    		/**统计的是每个字符出现的次数,所以字符是char类型,次数是int,但是不可以使用基本类型,需要使用包装类型*/
    		Map<Character,Integer> map = new HashMap();
    		
    		//开始位置:0 - 数组的第一个元素
    		//结束位置:<input.length() 或者 <=input,length()-1
    		//如何变化:++
    		for (int i = 0; i < input.length(); i++) { 
    			char key = input.charAt(i);//获取一串字符中指定位置上的字符
    			System.out.println("获取到的第"+(i+1)+"个字符:"+key);
    			
    			//4.统计每个字符出现的个数,存起来,存到map
    			Integer value = map.get(key);//要先拿着key到map中找是不是有value
    			if(value == null) { //如果判断为null,说明之前没有存过这个字符
    				map.put(key, 1);//把当前的字符作为key存入,次数存1
    			}else { 
    				map.put(key,value+1);//如果存过值,给之前的次数+1
    			}
    		}
    		System.out.println("各个字符出现的频率为:");
    		System.out.println(map);
    	}
    }

# 3 set接口 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 4]

## 3.1 概述 ##

1.  Set是一个不包含重复数据的Collection
2.  Set集合中的数据是无序的(因为Set集合没有下标)
3.  Set集合中的元素不可以重复 – 常用来给数据去重

## 3.2 Set集合的特点 ##

1.  数据无序且数据不允许重复
2.  HashSet : 底层是哈希表，包装了HashMap，相当于向HashSet中存入数据时，会把数据作为K，存入内部的HashMap中。当然K仍然不许重复。
3.  TreeSet : 底层是TreeMap,也是红黑树的形式,便于查找数据

## 3.3 常用方法 ##

学习Collection接口中的方法即可

## 3.4 HashSet ##

### 3.4.1 概述 ###

底层是哈希表,包装了HashMap,相当于向HashSet中存入数据时,会把数据作为K存入内部的HashMap中,其中K不允许重复,允许使用null.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 6]

## 3.5 练习: Set相关测试 ##

创建包: cn.tedu.collection  
创建类: TestSet.java

package cn.tedu.list;
    
    import java.util.HashSet;
    import java.util.Set;
    
    /**本类用于测试Set接口*/
    public class TestSet { 
        public static void main(String[] args) { 
            //1.创建对象
            //Set s = new Set();//父接口不可直接创建对象
            Set<String> set = new HashSet<String>();
            //2.存入数据
            set.add("牛气冲天");
            set.add("虎虎生威");
            set.add("虎虎生威");
            set.add(null);//向集合中存入null值
            set.add(null);
            set.add("null");//向集合中存入字符串null
            System.out.println(set);
            /**总结1：set集合中的元素都是无序的 * 总结2：set集合中的元素不能重复 * 总结3：set集合可以存放null,也只允许最多存1个 * 总结4：自定义对象(如Student)如果想要去重 * 需要添加重写的hashCode()与equals()*/
            Set<Student> set2 = new HashSet();
            Student s1 = new Student("张三",3);
            Student s2 = new Student("李四",4);
            Student s3 = new Student("李四",4);
            set2.add(s1);
            set2.add(s2);
            set2.add(s3);
            System.out.println(set2);
    
    		//3.set集合常用方法测试
    		//set.clear();//清空Set集合
    		System.out.println(set.contains("小兔纸"));//false,判断set集合中是否包含指定元素"小兔纸"
    		System.out.println(set.equals("牛气冲天"));//false,判断set集合对象与指定元素是否相等
    		System.out.println(set.hashCode());//1961052313,获取当前set集合对象的哈希码
    		System.out.println(set.isEmpty());//false,判断当前集合是否为空
    		System.out.println(set.remove("null"));//false,移除指定元素,没有"null"元素,所以返回false
    		System.out.println(set.remove(null));//true,成功移除指定元素null,所以返回true
    		System.out.println(set);
    		System.out.println(set.size());//2,获取当前set集合的元素个数,类似数组长度
    		Object[] array = set.toArray();//把集合中的元素放入数组中
    		System.out.println(Arrays.toString(array));//使用数组工具类查看数组中的元素
    		
    		//4.集合间的操作
    		Set<String> set2 = new HashSet();
    		set2.add("小老鼠");//给set2集合添加指定元素
    		set2.add("小牛犊");//给set2集合添加指定元素
    		set2.add("小脑斧");//给set2集合添加指定元素
    		set2.add("小兔纸");//给set2集合添加指定元素
    		System.out.println(set2);//查看set2集合中的元素
    		
    		System.out.println(set.addAll(set2));//true,把集合set2中的元素添加到set集合中,成功返回true
    		System.out.println(set.containsAll(set2));//true,判断set集合中是否包含set2集合中的所有元素,如果包含返回true
    		System.out.println(set.removeAll(set2));//ture,移除set集合中属于set2集合的所有元素
    		System.out.println(set.retainAll(set2));
    	
    		//5.集合的迭代
    		Iterator<String> it = set2.iterator();//5.1获取集合的迭代器
    		while(it.hasNext()) { //5.2判断集合是否有下个元素
    			String s = it.next();//5.3如果有,进循环获取当前遍历到的元素
    			System.out.println(s);
    		}
        }
    }

# 4 拓展 #

HashMap扩容  
成长因子：  
static final float DEFAULT\_LOAD\_FACTOR = 0.75f;  
前面的讲述已经发现，当你空间只有仅仅为10的时候是很容易造成2个对象的hashcode 所对应的地址是一个位置的情况。这样就造成 2个 对象会形成散列桶（链表）。这时就有一个加载因子的参数，值默认为0.75 ，如果你hashmap的 空间有 100那么当你插入了75个元素的时候 hashmap就需要扩容了，不然的话会形成很长的散列桶结构，对于查询和插入都会增加时间，因为它要一个一个的equals比较。但又不能让加载因子很小，如0.01，这样显然是不合适的，频繁扩容会大大消耗你的内存。这时就存在着一个平衡，jdk中默认是0.75，当然负载因子可以根据自己的实际情况进行调整。

[20210520135311402.png]: /images/20210827/c99b2015e3604b3ab79691ed8d97a3ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70]: /images/20210827/898342eee77243c482f57e95c04a7a4d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 1]: /images/20210827/f852c1f31c1b4578919195d8a35e9bdf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 2]: /images/20210827/f9c97848cde64e46965c8a9dffd509ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 3]: /images/20210827/ae81acfd19e146b599a3c7211b71af08.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 4]: /images/20210827/6736c05060ac45e3bca4446e81db7ead.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 5]: /images/20210827/af82ebda3ffd4af9af168e8a62de9db4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70 6]: /images/20210827/74f182eb91444337b99cc4c96d12654d.png