Set:
Set集合的功能上基本上与Collection的API一致
1.HashSet1.7版本原理解析:数组+链表(结合哈希算法)
因为是数组+链表的组成方式,所以哈希表是一种对于增删改查数据性能都较好的结构
2.JDK1.8版本开始HashSet原理解析:数组,链表,红黑树(结合哈希算法)
Set集合去重复规则:先判断哈希值,再判断equals
如果希望Set集合认为两个内容一样的对象是重复的,必须重写对象的HashCode()和equals()方法:
public class SetDemo3 {
public static void main(String[] args) {
Set<Student> sets = new HashSet<>();
Student s1 = new Student("无恙",15);
Student s2 = new Student("无恙",15);
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
sets.add(s1);
sets.add(s2);
System.out.println(sets);
}
}
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
关于重写后的hashCode方法:
不用管Objects.hash(name, age)内部是怎么实现的,只需要知道,两个内容相同的对象给hash方法传入的参数一定是一模一样的,那么无所谓hash方法内部怎么实现,反正最后结果一定一样
存储和取出的元素顺序一致的原理:底层数据结构依然是哈希表,只是每个元素又额外多了一个双链表机制记录存储的顺序
解释一下可排序:
TreeSet集合默认的规则:
对于数值类型:Integer,Double,官方默认按照大小进行升序排序
对于字符串类型:默认按照首字符的编号升序排序("a"是97,"A"是65,中文字符好像都是好几万)
Set<String> sets1 = new TreeSet<>();
sets1.add("angela");
sets1.add("情话");
sets1.add("Java");
System.out.println(sets1);//输出[Java, angela, 情话]
对于自定义类型如Student对象,TreeSet无法直接排序(运行会报ClassCastException异常)
TreeSet集合存储对象时有2种方式可以自定义比较规则:
public class SetDemo5 {
public static void main(String[] args) {
// 方式二:集合自带比较器对象进行规则定制
// Set apples = new TreeSet<>(new Comparator() {
// @Override
// public int compare(Apple o1, Apple o2) {
// return o2.getWeight() - o1.getWeight() >= 0 ? 1 : -1;//保留重量重复的元素(降序排序)
// }
// });
//方式二的Lambda表达式写法
Set<Apple> apples = new TreeSet<>((o1, o2) -> o2.getWeight() - o1.getWeight() >= 0 ? 1 : -1);
apples.add(new Apple("红富士", 500));
apples.add(new Apple("绿苹果", 400));
apples.add(new Apple("黄苹果", 500));
System.out.println(apples);
}
}
public class Apple implements Comparable<Apple>{
private String name;
private int weight;
public Apple(String name, int weight) {
this.name = name;
this.weight = weight;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
@Override
public String toString() {
return "Apple{" +
"name='" + name + '\'' +
", weight=" + weight +
'}';
}
//方式一:类自定义比较规则
@Override
public int compareTo(Apple o) {
// return this.weight - o.weight ; // 去重重量重复的元素
return this.weight - o.weight >= 0 ? 1 : -1;//保留重量重复的元素(升序排序)
}
}
可变参数概述:
可变参数的作用:
可变参数的注意事项:
public class MethodDemo {
public static void main(String[] args) {
sum(); // 1、不传参数
sum(10); // 2、可以传输一个参数
sum(10, 20, 30); // 3、可以传输多个参数
sum(new int[]{10, 20, 30, 40, 50}); // 4、可以传输一个数组
}
public static void sum(int...nums){
// 注意:可变参数在方法内部其实就是一个数组
System.out.println("元素个数:" + nums.length);
System.out.println("元素内容:" + Arrays.toString(nums));
}
}
在util包下,是用来操作集合的工具类:
方法名称 | 说明 |
---|---|
public static boolean addAll(Collection super T> c, T…elements) | 给集合对象批量添加元素 |
public static void shuffle(list> list) | 打乱List集合元素的顺序 |
1.关于addAll(Collection super T> c, T…elements):
2.关于shuffle:
看方法源码会发现底层原理就是遍历数组,每次遍历随机出来一个索引,将此时遍历到的某一元素与随机出来的索引位置的元素交换位置
为什么不能对Set集合使用只能对List集合使用呢,因为List集合底层是数组,而Set集合底层是根据一些算法得到将元素存放到数组的特定位置(后面还有两个排序的API,同理)
public class CollectionsDemo01 {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
Collections.addAll(names, "gg");
Collections.addAll(names, new String[] {"楚留香","胡铁花"});
System.out.println(names);//[gg, 楚留香, 胡铁花]
Collections.shuffle(names);
System.out.println(names);//[楚留香, gg, 胡铁花](每次运行程序可能结果都不一样)
}
}
Collections相关排序API只能适用于对List集合的排序:
排序方式一(不可以直接对自定义类型的List集合排序,否则编译阶段报错,除非自定义类型实现了比较规则Comparable接口):
方法名称 | 说明 |
---|---|
public static void sort(List list) | 将集合中元素按照默认规则排序 |
排序方式二:
方法名称 | 说明 |
---|---|
public static void sort(List list, Comparator super T> c) | 将集合中元素按照指定规则排序 |
public class CollectionsDemo02 {
public static void main(String[] args) {
List<Apple> apples = new ArrayList<>(); // 可以重复!
apples.add(new Apple("红富士", 500));
apples.add(new Apple("绿苹果", 400));
apples.add(new Apple("黄苹果", 500));
//方式二:sort方法自带比较器对象
// Collections.sort(apples, new Comparator() {
// @Override
// public int compare(Apple o1, Apple o2) {
// return Double.compare(o2.getWeight() , o1.getWeight());
// }
// });
//方式二的Lambda表达式写法
//注意:定制排序规则时不用像TreeSet那样强制保留大小相同的元素,因为List集存储相同大小的元素时会自动保留
Collections.sort(apples, (o1, o2) -> o2.getWeight() - o1.getWeight());
System.out.println(apples);
}
}
public class Apple implements Comparable<Apple>{
private String name;
private int weight;
public Apple(String name, int weight) {
this.name = name;
this.weight = weight;
}
public int getWeight() {
return weight;
}
@Override
public String toString() {
return "Apple{" +
"name='" + name + '\'' +
", weight=" + weight +
'}';
}
//方式一:类自定义比较规则
@Override
public int compareTo(Apple o) {
// 按照重量进行比较的
return this.weight - o.weight ;//TreeSet:return this.weight - o.weight >= 0 ? 1 : -1;
//这里不用像TreeSet那样强制保留大小相同的元素,因为List集存储相同大小的元素时会自动保留
}
}
注意事项:
Map集合的键无序,不重复(后面重复的键对应的元素会覆盖前面重复的整个元素)
Map集合的值不做要求,可以重复
Map集合的键值对都可以为null
public class MapDemo1 {
public static void main(String[] args) {
Map<String, Integer> maps = new LinkedHashMap<>();
maps.put(null, null);
System.out.println(maps);//输出{null=null}
}
}
方法名称 | 说明 |
---|---|
V put(K key, V value) | 添加元素 |
V remove(K key, V value) | 根据键删除键值对元素,返回删除的键值对的值 |
void clear() | 移除所有的键值对元素 |
boolean containsKey(Object key) | 判断集合是否包含指定的键 |
boolean containsValue(Object value) | 判断集合是否包含指定的值 |
boolean isEmpty() | 判断集合是否为空 |
int size() | 集合的长度,也就是集合中键值对的个数 |
Set keySet() | 获取全部建的集合 |
Collection values() | 获取全部值的集合 |
V get(Object key) | 根据键获取对应值 |
void putAll(Map extends K, ? extends V> m); | 合并其他Map集合 |
关于Set keySet():
关于Collection values():
public class MapDemo {
public static void main(String[] args) {
// 1.添加元素: 无序,不重复,无索引。
Map<String , Integer> maps = new HashMap<>();
maps.put("iphoneX",10);
maps.put("娃娃",20);
maps.put("iphoneX",100);//Map集合后面重复的键对应的元素会覆盖前面重复的整个元素!
maps.put("huawei",200);
maps.put("生活用品",50);
System.out.println(maps);//{huawei=200, 生活用品=50, iphoneX=100, 娃娃=20}
// 2.清空集合
// maps.clear();
// 3.判断集合是否为空
System.out.println(maps.isEmpty());//false
// 4.根据键获取对应值
Integer key = maps.get("huawei");
System.out.println(key);//200
System.out.println(maps.get("生活用品"));//50
System.out.println(maps.get("生活用品2"));//null
// 5.根据键删除整个元素
System.out.println(maps.remove("iphoneX"));//100
System.out.println(maps);//{huawei=200, 生活用品=50, 娃娃=20}
// 6.判断是否包含某个键
System.out.println(maps.containsKey("娃娃"));// true
System.out.println(maps.containsKey("娃娃2"));// false
// 7.判断是否包含某个值
System.out.println(maps.containsValue(200));//true
// 8.获取全部键的集合
Set<String> keys = maps.keySet();
System.out.println(keys);//[huawei, 生活用品, 娃娃],注意顺序:和HashMap中元素顺序一致
// 9.获取全部值的集合
Collection<Integer> values = maps.values();
System.out.println(values);//[200, 50, 20],注意顺序:和HashMap中元素顺序一致
// 10.集合的大小
System.out.println(maps.size());//3
// 11.合并其他Map集合
Map<String , Integer> map1 = new HashMap<>();
map1.put("java1", 1);
map1.put("java2", 100);
Map<String , Integer> map2 = new HashMap<>();
map2.put("java2", 1);
map2.put("java3", 100);
map1.putAll(map2); // 把集合map2的元素拷贝一份到map1中去
System.out.println(map1);//{java3=100, java2=1, java1=1}
System.out.println(map2);//{java3=100, java2=1}
}
}
键找值涉及到的API:
方法名称 | 说明 |
---|---|
Set keySet() | 获取全部建的集合 |
V get(Object key) | 根据键获取对应值 |
public class MapDemo01 {
public static void main(String[] args) {
Map<String , Integer> maps = new HashMap<>();
maps.put("娃娃",30);
maps.put("iphoneX",100);
System.out.println(maps);
Set<String> keys = maps.keySet();
for (String key : keys) {
int value = maps.get(key);//自动拆箱
System.out.println(key + "===>" + value);
}
}
}
键值对涉及到的API:
方法名称 | 说明 |
---|---|
Set | 获取所有键值对对象的集合 |
K getKey() | 获取某一个键值对元素的键 |
V get(Object key) | 根据键获取对应值 |
public class MapDemo02 {
public static void main(String[] args) {
Map<String , Integer> maps = new HashMap<>();
maps.put("娃娃",30);
maps.put("iphoneX",100);
System.out.println(maps);
Set<Map.Entry<String, Integer>> entries = maps.entrySet();//这一步的底层原理以后再研究
for(Map.Entry<String, Integer> entry : entries){
String key = entry.getKey();
int value = entry.getValue();
System.out.println(key + "====>" + value);
}
}
}
Map结合Lambda遍历的API
方法名称 | 说明 |
---|---|
default void forEach(BiConsumer super K, ? super V> action) | 结合Lambda遍历Map集合 |
public class MapDemo03 {
public static void main(String[] args) {
Map<String , Integer> maps = new HashMap<>();
maps.put("娃娃",30);
maps.put("iphoneX",100);
System.out.println(maps);
//方式三
maps.forEach(new BiConsumer<String, Integer>() {
@Override
public void accept(String key, Integer value) {
System.out.println(key + "--->" + value);
}
});
//方式三的Lambda表达式简化
maps.forEach((k, v) -> {
System.out.println(k + "--->" + v);
});
}
}
点进去forEach看源码会发现这其实就是一个换壳简化,实际上还是用了方式二的这种方法
default void forEach(BiConsumer<? super K, ? super V> action) {
Objects.requireNonNull(action);
for (Map.Entry<K, V> entry : entrySet()) {
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch(IllegalStateException ise) {
throw new ConcurrentModificationException(ise);
}
action.accept(k, v);
}
}
某个班80名学生,现在需要组成秋游活动,班长提供了四个景点依次是(A,B,C,D),每个学生只能选择一个景点,请统计最终哪个景点想去的人数最多
public class MapTest1 {
public static void main(String[] args) {
// 1、把80个学生选择的数据拿进来。
String[] selects = {"A" , "B", "C", "D"};
StringBuilder sb = new StringBuilder();
Random r = new Random();
for (int i = 0; i < 80; i++) {
sb.append(selects[r.nextInt(selects.length)]);
}
System.out.println(sb);
// 2、定义一个Map集合记录最终统计的结果: A=30 B=20 C=20 D=10 键是景点 值是选择的数量
Map<Character, Integer> infos = new HashMap<>(); //
// 3、遍历80个学生选择的数据
for (int i = 0; i < sb.length(); i++) {
// 4、提取当前选择景点字符
char ch = sb.charAt(i);
// 5、判断Map集合中是否存在这个键
if(infos.containsKey(ch)){
// 让其值 + 1
infos.put(ch , infos.get(ch) + 1);
}else {
// 说明此景点是第一次被选
infos.put(ch , 1);
}
}
// 4、输出集合
System.out.println(infos);
}
}
HashMap是Map里面的一个实现类,特点都是由键决定的:无序,不重复,无索引
没有额外需要学习的方法,直接使用Map里面的方法就可以了
HashMap跟HashSet底层原理一模一样,都是哈希表结构,增删改查性能都比较好,只是HashMap的每个元素包含两个值而已
实际上,Set系列的集合的底层就是Map实现的,只是Set集合中的元素只要键数据,不要值数据而已,所以Map底层直接去看1.2和1.3就可以了,学到这里了顺便纠正一下,1.2和1.3讲解的底层严格意义上来讲不应该算是Set的底层而应该算是Map的底层,然后Set进行调用,说白了Set的底层实现是依据Map例如:
public HashSet() {
map = new HashMap<>();
}
LinkedHashSet底层就是依据LinkedHashMap做的
有序,不重复,无索引(这里的有序指的是保证存储和取出的元素顺序一致)
原理:底层数据结构依然是哈希表,只是每个键值对元素又额外多了一个双链表的机制记录存储的顺序
TreeSet底层就是依据TreeMap做的
不重复,无索引,可排序
某个班80名学生,现在需要组成秋游活动,班长提供了四个景点依次是(A,B,C,D),每个学生可以选择景点,请统计最终哪个景点想去的人数最多
public class MapTest4 {
public static void main(String[] args) {
// 1、要求程序记录每个学生选择的情况,使用一个Map集合存储
Map<String, List<String>> data = new HashMap<>();
// 2、把学生选择的数据存入进去。
List<String> selects = new ArrayList<>();
Collections.addAll(selects, "A", "C");
data.put("罗勇", selects);
List<String> selects1 = new ArrayList<>();
Collections.addAll(selects1, "B", "C" , "D");
data.put("胡涛", selects1);
List<String> selects2 = new ArrayList<>();
Collections.addAll(selects2 , "A", "B", "C" , "D");
data.put("刘军", selects2);
System.out.println(data);//{刘军=[A, B, C, D], 胡涛=[B, C, D], 罗勇=[A, C]}
// 3、统计每个景点选择的人数。
Map<String, Integer> infos = new HashMap<>(); // {}
// 4、提取所有人选择的景点的信息。
Collection<List<String>> values = data.values();
System.out.println(values);//[[A, B, C, D], [B, C, D], [A, C]]
for (List<String> value : values) {
for (String s : value) {
// 有没有包含这个景点
if(infos.containsKey(s)){
infos.put(s, infos.get(s) + 1);
}else {
infos.put(s , 1);
}
}
}
System.out.println(infos);//{A=2, B=2, C=3, D=2}
}
}