目录
前情回顾
1 set接口
1.1 概述
1.2 Set集合的特点
1.3 常用方法
1.4练习1: Set接口测试
2 HashSet
2.1 概述
2.2练习2: HashSet测试
2.3练习3-1: Set自定义对象去重_创建学生类
2.4练习3-2: Set自定义对象去重_测试
3 Map接口
3.1 概述
3.2 特点
3.3 继承结构
3.4 常用方法
3.5 练习4-1:Map常用方法测试
3.6 练习4-2:Map集合迭代测试
5 HashMap
5.1 前言
5.2概述
5.3 练习5:获取HashMap的数据
5.4 练习6:字符串中字符统计
6拓展
HashMap扩容
Day15
前情回顾
说明: C:\Users\Admin\Desktop\JAVA常用集合关系2.png
1 set接口
1.1 概述
-
Set是一个不包含重复数据的Collection
-
Set集合中的数据是无序的(因为Set集合没有下标)
-
Set集合中的元素不可以重复 – 常用来给数据去重
1.2 Set集合的特点
-
数据无序且数据不允许重复
-
HashSet : 底层是哈希表,包装了HashMap,相当于向HashSet中存入数据时,会把数据作为K,存入内部的HashMap中。当然K仍然不许重复。
-
TreeSet : 底层是TreeMap,也是红黑树的形式,便于查找数据
1.3 常用方法
学习Collection接口中的方法即可
1.4练习1: Set接口测试
创建Java工程: DAY15
创建包: cn.tedu.collection
创建类: Test1_Set.java
package cn.tedu.collection;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/*这个类用来测试Set接口的方法/
public class Test1_Set {
public static void main(String[] args) {
//1.创建对象
//Set s = new Set();//报错,Set是接口,接口不可以实例化,也就是创建对象
Set<String> set = new HashSet<String>();
//2.set集合数据存放测试
set.add("牛气冲天");//向set集合添加数据
set.add("牛气冲天");//向set集合添加重复的数据
set.add("牛气冲天");//向set集合添加重复的数据
set.add("虎虎生威");//向set集合添加数据
//set.add("null");//向set集合添加字符串类型的null数据
set.add(null);//向set集合添加数据null
/**总结1:set集合中的元素都是无序的*/
/**总结2:set集合中的元素不能重复*/
/**总结3:set集合中可以存放null元素,也只允许存放0-1个*/
System.out.println(set);//查看set集合中的元素
//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.containsAll(set2));//false,判断set集合中是否包含set2集合中的所有元素,不包含返回false
System.out.println(set.retainAll(set2));
/**retainAll()方法是取两个集合直接的公共部分,谁调用,影响谁*/
// set.add(“小海滕”);
// set2.add(“小海滕”);
// System.out.println(set.retainAll(set));//set没变
// System.out.println(set.retainAll(set2));//set剩set与set2的交集
// System.out.println(set2.retainAll(set));//set2剩set2与set的交集
// System.out.println(set);
// System.out.println(set2);
//5.集合的迭代
Iterator<String> it = set2.iterator();//5.1获取集合的迭代器
while(it.hasNext()) {//5.2判断集合是否有下个元素
String s = it.next();//5.3如果有,进循环获取当前遍历到的元素
System.out.println(s);
}
}
}
2 HashSet
2.1 概述
底层是哈希表,包装了HashMap,相当于向HashSet中存入数据时,会把数据作为K存入内部的HashMap中,其中K不允许重复,允许使用null.
2.2练习2: HashSet测试
创建Java工程: DAY15
创建包: cn.tedu.collection
创建类: Test2_HashSet.java
package cn.tedu.collection;
import java.util.HashSet;
import java.util.Iterator;
/*本类用于测试HashSet的用法/
public class Test2_HashSet {
public static void main(String[] args) {
//1.创建HashSet对象
HashSet<Integer> set = new HashSet();
//2.向HashSet集合添加元素
set.add(100);
set.add(200);
set.add(300);
set.add(200);
set.add(200);
/**总结1:HashSet中的元素没有顺序,且不允许重复*/
System.out.println(set);
//3.测试常用方法
//set.clear();//清空set集合
System.out.println(set.contains(200));//true,判断集合是否包含指定元素
System.out.println(set.isEmpty());//false,判断集合是否为空
System.out.println(set.remove(100));//true,移除集合中的指定元素
System.out.println(set.size());
//4.迭代set集合
Iterator<Integer> it = set.iterator();//获取集合的迭代器用来遍历
while(it.hasNext()) {//判断集合中是否有下一个元素,没有则跳出循环
Integer num = it.next();//获取当前遍历到的元素
System.out.println(num);//打印当前遍历到的元素
}
}
}
2.3练习3-1: Set自定义对象去重_创建学生类
创建Java工程: DAY15
创建包: cn.tedu.collection
创建类: Student.java
package cn.tedu.collection;
/*本类用来测试给set自定义对象去重/
public class Student {
//1.提供对应对象的属性并进行封装
private String name;
private int age;
private String addr;
/**注意1:如果提供了含参/全参构造,需要手动添加无参构造,否则创建对象时必须传参*/
/**注意2:我们可以通过快捷方式生成构造方法:右键--Source--Generate Constructor using fields...*/
/**注意3:给对象的属性赋值,可以通过构造方法[创建对象时直接赋值]/set()[创建对象后调用公共的设置方法赋值]*/
//2.1提供无参构造
public Student() {
System.out.println("我是无参构造");
}
//2.2提供含参构造
public Student(String name, int age, String addr) {
super();
this.name = name;
this.age = age;
this.addr = addr;
System.out.println("我是全参构造");
}
/**注意4:以通过快捷方式生成:右键--Source--Generate Getters and Setters --Select All*/
//3.提供公共的get()/set()
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 getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
/**注意5:重写是为了能够看到对象的属性值
* 我们可以通过快捷方式生成:右键--Source--Generate to String()...*/
//4.重写toString()
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", addr=" + addr + "]";
}
//5.重写hashCode() & equlas()
//重写hashCode():我们并不想使用自动计算出的哈希值,而是要根据对象的属性值进行计算,如果两个对象的属性值都相同,想生成同一个哈希码
//重写equals():我们想比较的不是对象的地址值(==),而是如果两个对象的属性值都一样,则返回true
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((addr == null) ? 0 : addr.hashCode());
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.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 (addr == null) {
if (other.addr != null)
return false;
} else if (!addr.equals(other.addr))
return false;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
2.4练习3-2: Set自定义对象去重_测试
创建Java工程: DAY15
创建包: cn.tedu.collection
创建类: Test3_HashSet2.java
package cn.tedu.collection;
import java.util.HashSet;
import java.util.Set;
/*本类用于给自定义对象去重测试/
//总结:
//1.如果想用set集合给自定义的对象去重,那么需要在自己的类中同时提供重写的hashCode()与equals()
//底层源码: if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
//重写hashCode():我们并不想使用自动计算出的哈希值,而是要根据对象的属性值进行计算,如果两个对象的属性值都相同,想生成同一个哈希码
//重写equals():我们想比较的不是对象的地址值(==),而是如果两个对象的属性值都一样,则返回true
public class Test3_HashSet2 {
public static void main(String[] args) {
//1.创建set集合对象
Set<Student> set = new HashSet<Student>();
//新版JDK中后面的泛型类型与尖括号都可以不写,三种方式皆可,想用哪个用哪个
// Set set = new HashSet<>();
// Set set = new HashSet();
//2.1创建自定义对象
Student s1 = new Student("tony",38,"BeiJing");
Student s2 = new Student("susan",20,"ShangHai");
Student s3 = new Student("Jack",3,"ShenZhen");
//创建对象,与之前对象的属性值完全一致
Student s4 = new Student("susan",20,"ShangHai");
Student s5 = new Student("Jack",3,"ShenZhen");
//3.查看两个对象的哈希码
System.out.println("s2对象的哈希码:"+s2.hashCode());
System.out.println("s4对象的哈希码:"+s4.hashCode());
//2.2把自定义的student对象添加到set集合中
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
/**总结:
* 重复的给set集合添加了属性相同的对象,为什么没有像之前那样去重呢?
* 翻阅源码,得知:需要保证两个条件:
* 1.保证对象拥有相同的哈希码值
* --底层默认使用的是Object提供的hashCode()来计算哈希码值,每次new对象,默认的哈希码值是不同的
* 解决方案:如果想根据两个对象的属性值来计算哈希值,就需要重写hashCode()
* 2.保证两个对象的equals()返回true
* --底层默认使用的是Object提供的逻辑,==比较,也就是说当地址值相同时,才返回true
* 解决方案:重写equals()
* */
System.out.println(set);
}
}
说明: C:\Users\Admin\AppData\Roaming\Tencent\Users\2851318847\QQEIM\WinTemp\RichOle\PBR8F@~%1TIW@7{52TBF6%Q.png
说明: C:\Users\Admin\AppData\Roaming\Tencent\Users\2851318847\QQEIM\WinTemp\RichOle\OYXHGJUPFP79CGH]N)]UU[U.png
3 Map接口
3.1 概述
Java.util接口Map<K,V>
类型参数 : K - 表示此映射所维护的键 V – 表示此映射所维护的对应的值
也叫做哈希表、散列表. 常用于键值对结构的数据.其中键不能重复,值可以重复
说明: fc2fe4853a9fdd98b2b5c058978ad25
3.2 特点
1. Map可以根据键来提取对应的值
2. Map的键不允许重复,如果重复,对应的值会被覆盖
3. Map存放的都是无序的数据
4. Map的初始容量是16,默认的加载因子是0.75
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的次幂进行扩容
3.3 继承结构
3.4 常用方法
学习Collection接口中的方法即可
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 视图。
3.5 练习4-1:Map常用方法测试
创建Java工程: DAY15
创建包: cn.tedu.collection
创建类: Test4_Map.java
package cn.tedu.collection;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
/*本类用于测试Map接口/
public class Test4_Map {
public static void main(String[] args) {
//1.创建Map对象
//map中的数据要符合映射规则,一定注意要同时指定K和V的数据类型
//至于K和V需要指定成什么类型的数据,取决于你的具体需求
Map<Integer,String> map = new HashMap();//注意导包:java.util
//2.常用方法测试
//添加数据,需要同时指定K和V
map.put(9527, "白骨精");//向map集合添加数据
map.put(9528, "黑熊精");//向map集合添加数据
map.put(9528, "唐三藏");
map.put(9529, "者行孙");
/**
* 总结1:Map存放的都是无序数据
* 总结2:Map中的key不可以重复,如果重复,此Key对应的值会被覆盖
*map打印结果: {9527=白骨精, 9528=唐三藏, 9529=者行孙}
*/
//查看map集合中的元素
System.out.println(map);
//map.clear();//清空map集合
System.out.println(map.containsKey(9527));//true,判断当前map集合是否包含指定的key
System.out.println(map.containsValue("土地老儿"));//false,判断当前map集合是否包含指定的value
System.out.println(map.equals("者行孙"));//false,判断"者行孙"与map是否相等
System.out.println(map.get(9529));//者行孙,根据对应的key来获取对应的value
System.out.println(map.hashCode());//84598429,获取当前map集合的哈希码
System.out.println(map.isEmpty());//false,判断当前map集合是否为空
System.out.println(map.remove(9529));//者行孙,删除map中key对应的value,正确删除后返回被删除元素
System.out.println(map.get(9529));//null,没有拿到任何元素,根据指定的key获取对应value
System.out.println(map.size());//2,获取集合中元素的个数
Collection<String> values = map.values();//把map中的所有value收集起来放到collection中
System.out.println(values);//[白骨精, 唐三藏]
}
}
说明: C:\Users\Admin\Desktop\Map集合迭代方式.png
3.6 练习4-2:Map集合迭代测试
创建Java工程: DAY15
创建包: cn.tedu.collection
创建类: Test4_Map.java
package cn.tedu.collection;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/*本类用于测试Map接口/
public class Test4_Map {
public static void main(String[] args) {
//1.创建Map对象
//map中的数据要符合映射规则,一定注意要同时指定K和V的数据类型
//至于K和V需要指定成什么类型的数据,取决于你的具体需求
Map<Integer,String> map = new HashMap();//注意导包:java.util
//2.常用方法测试
//添加数据,需要同时指定K和V
map.put(9527, "白骨精");//向map集合添加数据
map.put(9528, "黑熊精");//向map集合添加数据
map.put(9528, "唐三藏");
map.put(9529, "者行孙");
/**
* 总结1:Map存放的都是无序数据
* 总结2:Map中的key不可以重复,如果重复,此Key对应的值会被覆盖
*map打印结果: {9527=白骨精, 9528=唐三藏, 9529=者行孙}
*/
//查看map集合中的元素
System.out.println(map);
//map.clear();//清空map集合
System.out.println(map.containsKey(9527));//true,判断当前map集合是否包含指定的key
System.out.println(map.containsValue("土地老儿"));//false,判断当前map集合是否包含指定的value
System.out.println(map.equals("者行孙"));//false,判断"者行孙"与map是否相等
System.out.println(map.get(9529));//者行孙,根据对应的key来获取对应的value
System.out.println(map.hashCode());//84598429,获取当前map集合的哈希码
System.out.println(map.isEmpty());//false,判断当前map集合是否为空
System.out.println(map.remove(9529));//者行孙,删除map中key对应的value,正确删除后返回被删除元素
System.out.println(map.get(9529));//null,没有拿到任何元素,根据指定的key获取对应value
System.out.println(map.size());//2,获取集合中元素的个数
Collection<String> values = map.values();//把map中的所有value收集起来放到collection中
System.out.println(values);//[白骨精, 唐三藏]
//对map集合进行迭代
/**方式一
* 遍历map中的数据,需要把map集合转换成set集合
* Set<K> keySet() : 把map集合中的所有的key存到set集合中
* */
Set<Integer> keySet = map.keySet();
//想要遍历set集合,需要先拿到集合的迭代器对象
Iterator<Integer> it = keySet.iterator();
while(it.hasNext()) {//判断集合中是否有下个元素,如果有,继续迭代,如果没有,跳出循环
Integer key = it.next();//依次获取/set集合中的每一个key
String value = map.get(key);//通过key获取对应的value
System.out.println("{" + key + "," + value + "}");
}
/**方式二
* 遍历map中的数据,需要把map集合转换成set集合
* Set<Entry<Integer,String>> entrySet() : 把map集合中的一组key&value数据整体放入set中
* 一对儿 K,V 是一个Entry
*/
Set<Entry<Integer, String>> entrySet = map.entrySet();
//遍历set集合,得到每个Entry对象
//获取此set集合对应的迭代器对象it2
Iterator<Entry<Integer, String>> it2 = entrySet.iterator();
while(it2.hasNext()) {
Entry<Integer, String> entry = it2.next();
Integer key = entry.getKey();
String value = entry.getValue();
System.out.println("[" + key + ":" + value + "]");
}
}
}
5 HashMap
5.1 前言
HashMap的键要同时重写hashCode()和equlas()
hashCode()用来判定二者的hash值是否相同,重写后根据属性生成
equlas()用来判断属性的值是否相同,重写后,根据属性判断
–equlas()判断数据如果相等,hashCode()必须相同
–equlas()判断数据如果不等,hashCode()尽量不同
5.2概述
HashMap底层是一个Entry[ ]数组,当存放数据时,会根据hash
算法来计算数据的存放位置
算法:hash(key)%n , n就是数组的长度,其实也就是集合的容量
当计算的位置没有数据的时候,会直接存放数据
当计算的位置,有数据时,会发生hash冲突/hash碰撞,解决的办法就
是采用链表的结构,在对应的数据位置存放链表的头节点,对于
这个链表来说,每次新加的节点会从头部位置开始加入,也就是说,
数组中的永远是新节点.
说明: C:\Users\Admin\Desktop\hashMap图解.png
5.3 练习5:获取HashMap的数据
创建Java工程: DAY15
创建包: cn.tedu.collection
创建类: Test5_HashMap.java
package cn.tedu.collection;
import java.util.HashMap;
/*本类用于HashMap的练习/
public class Test5_HashMap {
public static void main(String[] args) {
//1.创建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过于频繁,影响性能
* 如果初始容量设置太高或者加载因子设置太高,影响查询效率
*/
}
}
5.4 练习6:字符串中字符统计
创建Java工程: DAY15
创建包: cn.tedu.collection
创建类: Test6_MapTest.java
package cn.tedu.collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
/**
-
本类用来完成Map集合相关练习
-
需求:提示并接收用户输入的一串字符,并且统计出每个字符出现的次数
-
*/
public class Test6_MapTest {
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);
}
}
6拓展
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,当然负载因子可以根据自己的实际情况进行调整。