【韩顺平讲Java】Java集合专题 视频地址
Java集合
集合的理解和好处
数组的不足之处
/**
* @author hejh7
* @date 2022/11/1 0001 17:00
* @describe
* 数组的不足
* 1.长度开始必须指定,而且一旦指定,不能修改
* 2.保存的必须为同一类型的元素
* 3.使用数组添加元素比较麻烦
*
*/
public class ArrayExample {
public static void main(String[] args) {
Person[] peoples = new Person[3];
peoples[0] = new Person("小米",13);
peoples[1] = new Person("小明",15);
peoples[2] = new Person("小红",22);
for (Person people : peoples) {
System.out.println(people);
}
System.out.println("-----扩容后----------");
Person[] personAdd = new Person[5];
for (int i = 0; i < peoples.length; i++) {
personAdd[i] = peoples[i];
}
personAdd[3] = new Person("梅梅",15);
personAdd[4] = new Person("兰兰",18);
for (Person person : personAdd) {
System.out.println(person);
}
}
}
集合的好处
(1)可以动态保存任意多个对象,使用比较方便
(2)提供了一系列方便的操作对象的方法:add、remove、set、get等
(3)使用集合添加,删除新元素更加简洁
Collection 接口图
Map接口图
1.集合主要是两组(单列集合、双列集合)
2.Collection接口有两个重要的子接口List Set 它们的实现子类都是单列集合
3.Map接口的实现子类 是双列集合,存放的 Key-Value
Collection接口实现类的特点
public interface Collection extends Iterable
(1)Collection实现子类可以存放多个元素,每个元素可以是Object
(2)有些Collection的实现类,可以存放重复的元素,有些不可以
(3)有些Collection的实现类是有序的(List),有些是无序的(Set)–这里说的有序和无序是指取出的顺序是否和放入顺序一致
(4)Collection接口没有直接的实现子类,是通过它的子接口Set和List来实现的
示例:
/**
* @author hejh7
* @date 2022/11/1 0001 18:02
* @describe
*/
@SuppressWarnings("all")
public class CollectionExa {
public static void main(String[] args) {
List list = new ArrayList();
//添加元素
list.add("jack");
list.add(10);
list.add(true);
list.add(new Integer(33));
list.add(new String("tom"));
System.out.println("list=" + list);
//删除元素
list.remove(0);//按照索引删除第一个元素
list.remove("jack");//删除指定的元素
System.out.println("list="+list);
//查找元素
System.out.println(list.contains(true));
System.out.println(list.contains("jack"));
//获取元素个数
System.out.println(list.size());
//集合是否为空
System.out.println(list.isEmpty());
//清空
list.clear();
System.out.println("list=" + list);
//添加集合 多个元素
List list2 = new ArrayList();
list2.add("兰兰");
list2.add(false);
list2.add(22);
list.addAll(list2);
System.out.println("list=" + list);
//查找多个元素是否存在
System.out.println(list.containsAll(list2));
//删除多个元素
list.add(22.67);
list.removeAll(list2);
System.out.println("list=" + list);
}
}
使用迭代器Iterator(迭代器)
(1)Itrator对象称为迭代器,只要用于遍历Collection集合中的元素。
(2)所有实现了Collection接口的集合类都有一个Iterator()方法,用以返回一个实现了Iterator接口的对象,即可以返回一个迭代器
(3)Iterator仅用于遍历集合,Iterator本身并不存放对象
Itrator接口的方法
示例:
package com.ItratorExercise;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* @author wty
* @date 2022/10/4 11:45
*/
public class ItratorExercise {
@Test
@SuppressWarnings({"all"})
public void getItrator() {
Collection arrayList = new ArrayList();
arrayList.add(new Book("三国演义", "罗贯中", 42.99));
arrayList.add(new Book("西游记", "吴承恩", 38.5));
arrayList.add(new Book("水浒传", "施耐庵", 66.66));
System.out.println("直接输出:" + arrayList);
System.out.println("------------------");
// 先得到对应的迭代器
Iterator iterator = arrayList.iterator();
// 快捷键itit
// ctrl + j :所有快捷键的快捷键
while (iterator.hasNext()) { // 判断是否还有数据
// 返回下一个元素,类型是Object
Object next = iterator.next();
System.out.println(next);
}
// 当退出while循环后,这时迭代器指向最后一个元素
//报错 iterator.next(); // java.util.NoSuchElementException
// 如果希望再次遍历,需要重置迭代器
arrayList.add("今天天气不错");
System.out.println("重置迭代器之后………………");
iterator = arrayList.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
}
}
class Book {
private String name;
private String author;
private double price;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Book(String name, String author, double price) {
this.name = name;
this.author = author;
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price=" + price +
'}';
}
}
for循环增强遍历
增强for循环,可以替代itrator迭代器,特点:增强for就是简化版的iterator,本质一样。只能用于遍历集合或者数组
基本语法:
for(元素类型 元素名:集合名或数组名){
访问元素
}
示例:
package com.StrongFor;
import org.junit.Test;
import java.util.ArrayList;
/**
* @author wty
* @date 2022/10/4 14:18
*/
public class StrongFor {
@Test
public void strongFor() {
ArrayList arrayList = new ArrayList();
arrayList.add(new Teacher("王老师", 45, 1.68));
arrayList.add(new Teacher("李老师", 25, 1.58));
arrayList.add(new Teacher("刘老师", 27, 1.78));
// 使用增强for循环,在Collection集合
// 底层仍然是迭代器
// 增强for循环,可以理解成简化版的迭代器
// I快捷键
for (Object o : arrayList) {
System.out.println(o);
}
// 增强for循环也可以在数组使用
int[] nums = {1, 8, 9, 10};
for (int num : nums) {
System.out.println(num);
}
}
}
class Teacher {
private String name;
private int age;
private double height;
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 double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public Teacher(String name, int age, double height) {
this.name = name;
this.age = age;
this.height = height;
}
@Override
public String toString() {
return "Teacher{" +
"name='" + name + '\'' +
", age=" + age +
", height=" + height +
'}';
}
}
课堂练习:
编写程序CollectionExercise
(1)创建3个Dog{name,age}对象,放入到ArrayList中,赋给List使用
(2)用迭代器和增强for循环两种方式来遍历
(3)重写Dog的toString方法,输出name和age
/**
* @author hejh7
* @date 2022/11/5 0005 12:53
* @describe
*/
@SuppressWarnings({"all"})
public class CollectionExercise {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Dog("大黄",3));
list.add(new Dog("小黑",15));
list.add(new Dog("大壮",6));
System.out.println("-----------迭代器遍历------------------");
Iterator iterator = list.iterator();
while (iterator.hasNext()){
Object next = iterator.next();
System.out.println(next);
}
System.out.println("-------------增强for循环------------------");
for (Object obj : list) {
System.out.println(obj);
}
}
}
class Dog{
private String name;
private int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Dog{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
List接口和常用方法
List接口是Collection接口的子接口
(1)List集合类中元素有序(即添加顺序和取出顺序一致)、并且可以重复
(2)List集合中的每个元素都有其对应的顺序索引,即支持索引
(3)List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
(4)List接口的常用实现类有:ArrayList、LinkedList和Vector
List接口和常用方法
(1)add 在index位置插入元素
(2)addAll 从index位置开始将所有元素添加进来
(3)get 获取指定index位置的元素
(4)indexOf 返回在集合中首次出现的位置
(5)lastIndexOf 返回在当前集合中末次出现的位置
(6)remove 移除index位置的元素,并返回此元素
(7)set 设置指定index位置的元素(替换)
(8)subList 返回一个范围位置中的子集合
示例:
package com.ListExercise;
import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
/**
* @author wty
* @date 2022/10/4 15:04
*/
public class ListMethod {
@Test
public void ListMethodExercise() {
List list = new ArrayList();
list.add("张三丰");
list.add("贾宝玉");
// 插入一个元素
list.add(1, "林黛玉");
System.out.println(list);
// 插入一个集合
List list2 = new ArrayList();
list2.add("Jack");
list2.add("Tom");
list.addAll(1, list2);
System.out.println(list);
// 获取集合中索引的值
System.out.println("get(2):" + list.get(2)); // Tom
// 返回首个出现的位置
System.out.println(list.indexOf("林黛玉")); // 3
// 返回末次出现的位置
list.add("林黛玉");
System.out.println(list.lastIndexOf("林黛玉")); // 5
// 移除元素并且输出该元素
list.remove(5);
System.out.println(list);
// 替换
list.set(1, "王宝强");
System.out.println(list);
// 返回范围值内的子集合[0,3)所以只有0,1,2三个元素
List listReturn = list.subList(0, 3);
System.out.println(listReturn);
}
}
练习:
package com.ListExercise;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* @author wty
* @date 2022/10/4 15:17
*/
public class ListExercise02 {
@Test
public void ListExer02() {
List list = new ArrayList();
list.add("1 你好");
list.add("2 hello world");
list.add("3 10");
list.add("4 今天天气不错");
list.add("5 开心");
list.add("6 难过");
list.add("7 悲伤");
list.add("8 喜悦");
list.add("9 幸福");
list.add("10 自豪");
System.out.println(list);
list.add(1, "韩顺平教育");
System.out.println("在2号位置插入:" + list);
System.out.println("获取第5个元素:" + list.get(4));
list.remove(5);
System.out.println("删除第6个元素后:" + list);
list.set(6, "很悲伤");
System.out.println("修改第7个元素后:" + list);
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
}
}
List的三种遍历方式
(1)方式一:使用迭代器
(2)方式二:增强for循环
(3)方式三:使用普通for循环
package com.ListExercise;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
/**
* @author wty
* @date 2022/10/4 18:08
*/
public class Bianli {
@Test
public void getBianli() {
List list = new ArrayList();
list.add("Jack");
list.add("Tom");
list.add("鱼香肉丝");
list.add("北京烤鸭");
// 迭代器遍历
System.out.println("-----迭代器遍历:-----");
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
// 增强for循环遍历
System.out.println("------增强for循环遍历:-------");
for (Object o : list) {
System.out.println(o);
}
// 普通for循环遍历(类似数组)
System.out.println("-----普通for循环遍历:-------");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
@Test
public void getBianli02() {
List vector = new Vector();
vector.add("Jack");
vector.add("Tom");
vector.add("鱼香肉丝");
vector.add("北京烤鸭");
// 迭代器遍历
System.out.println("-----迭代器遍历:-----");
Iterator iterator = vector.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
// 增强for循环遍历
System.out.println("------增强for循环遍历:-------");
for (Object o : vector) {
System.out.println(o);
}
// 普通for循环遍历(类似数组)
System.out.println("-----普通for循环遍历:-------");
for (int i = 0; i < vector.size(); i++) {
System.out.println(vector.get(i));
}
}
}
课堂练习2
package com.he.list_;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* @author hejh7
* @date 2022/11/6 0006 10:47
* @describe
*/
@SuppressWarnings({"all"})
public class ListExercise03 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Book("红楼梦","曹雪芹",100));
list.add(new Book("西游记","吴承恩",45));
list.add(new Book("水浒传","施耐庵",12));
list.add(new Book("三国志","罗贯中",26));
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
System.out.println("================排序后=======================");
Sort(list);
Iterator iterator1 = list.iterator();
while (iterator1.hasNext()) {
Object obj = iterator1.next();
System.out.println(obj);
}
}
public static void Sort(List list){
int listSize = list.size();
for (int i = 0; i < listSize - 1; i++) {
for (int j = 0; j < listSize-1-i; j++) {
Book book1 = (Book)list.get(j);
Book book2 = (Book)list.get(j+1);
if (book1.getPrice() > book2.getPrice()){
list.set(j,book2);
list.set(j+1,book1);
}
}
}
}
}
ArrayList底层结构和源码分析
(1).ArrayList可以放所有的元素甚至是空元素,可以放入多个空值。
(2).ArrayList是由数组来实现数据存储的。
(3).ArrayList基本等同于Vector,除了ArrayList是线程不安全(执行效率高),在多线程下,不建议用ArrayList。
(4).ArrayList中维护了一个Object类型的数组elementData
transient Object[] elementData
transient:短暂的,瞬间的,表示该属性不会被序列化
(5).当创建ArrayList对象时,如果使用的是无参构造器,则初始elementData容量是0,第1次添加,则扩容elementData为10,如需再次扩容,则扩容elementData为1.5倍
(6).如果使用的是指定大小的构造器,则初始elementData容量为指定大小,如果需要扩容,则直接扩容elementData为1.5倍
源码分析:
1.无参构造ArrayList集合
1.有参构造ArrayList集合
Vector底层机构和源码剖析
Vector的基本介绍
(1)Vector类的定义说明:
public class Vector extends AbstractList
implements List, RandomAccess, Cloneable,Serializable
(2)Vector底层也是一个对象数组,protected Object[] elementData
(3)Vector 是线程同步的,即线程安全,Vector类的操作方法带有synchronized
(4)在开发中,需要线程同步安全时,优先考虑用Vector
package com.he.list_;
import java.util.Vector;
/**
* @author hejh7
* @date 2022/11/6 0006 18:11
* @describe
*/
@SuppressWarnings({"all"})
public class Vector_ {
public static void main(String[] args) {
Vector vector = new Vector();
for (int i = 1; i <= 10; i++) {
vector.add(i);
}
vector.add(100);
//源码解读
/**
* 1.无参构造 初始化为10
* public Vector(int initialCapacity) {
* this(initialCapacity, 0);
* }
* 2.添加元素
* public synchronized boolean add(E e) {
* modCount++;
* ensureCapacityHelper(elementCount + 1);
* elementData[elementCount++] = e;
* return true;
* }
* 3.添加的元素大于集合的容量进行扩容 扩大到原来的两倍
* int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
* private void grow(int minCapacity) {
* // overflow-conscious code
* int oldCapacity = elementData.length;
* int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
* capacityIncrement : oldCapacity);
* if (newCapacity - minCapacity < 0)
* newCapacity = minCapacity;
* if (newCapacity - MAX_ARRAY_SIZE > 0)
* newCapacity = hugeCapacity(minCapacity);
* elementData = Arrays.copyOf(elementData, newCapacity);
* }
*/
}
}
Vector和List比较
LinkedList底层结构
(1)LinkedList实现了双向链表和双端队列特点
(2)可以添加任意元素(元素可以重复),包括null
(3)线程不安全,没有实现同步
LinkedList的底层操作机制
(1)LinkedList底层维护了一个双向链表
(2)LinkedList中维护了两个属性first和last分别指向首节点和尾节点
(3)每个节点(Node对象),里面又维护了prev,next,item三个属性,其中通过prev指向前一个,通过next指向后一个节点 ,最终实现双向链表。
(4)所以LinkedList的元素的添加和删除,不是通过数组完成的,相对来说效率较高
模拟一个双向链表简单示例:
package com.he.list_;
/**
* @author hejh7
* @date 2022/11/7 0007 12:32
* @describe
*/
@SuppressWarnings({"all"})
public class LinkedList_ {
public static void main(String[] args) {
Node jack = new Node("jack");
Node tom = new Node("tom");
Node hjh = new Node("hjh");
jack.next = tom;
tom.next = hjh;
hjh.pre = tom;
tom.pre = jack;
//定义头结点
Node first = jack;
//定义尾结点
Node last = hjh;
System.out.println("===从头到尾遍历====");
while (true){
if (first == null){
break;
}
System.out.println(first);
first = first.next;
}
System.out.println("===从尾到头遍历====");
while (true){
if (last == null){
break;
}
System.out.println(last);
last = last.pre;
}
//插入元素
System.out.println("===插入元素从尾到头遍历====");
Node rose = new Node("rose");
jack.next = rose;
tom.pre = rose;
rose.pre = jack;
rose.next = tom;
//遍历插入元素后
first = jack;
while (true){
if (first == null){
break;
}
System.out.println(first);
first = first.next;
}
}
}
class Node{
public Object name;
public Node pre;
public Node next;
public Node(Object name) {
this.name = name;
}
@Override
public String toString() {
return "Node {name=" + name + '}';
}
}
关于LinkedList源码分析
package com.he.list_;
import java.util.Iterator;
import java.util.LinkedList;
/**
* @author hejh7
* @date 2022/11/7 0007 12:45
* @describe
*/
@SuppressWarnings({"all"})
public class LinkedListCRUD {
public static void main(String[] args) {
LinkedList list = new LinkedList();
//添加
list.add(100);
list.add(200);
list.add(300);
list.add(400);
list.add(500);
list.add(600);
/**
* 源码分析
* 1.初始化空链表
* public LinkedList() {}
* 2.添加方法
* public boolean add(E e) {
* linkLast(e);
* return true;
* }
* 3.执行添加元素方法
* void linkLast(E e) {
* final Node<E> l = last;
* final Node<E> newNode = new Node<>(l, e, null);
* last = newNode;
* if (l == null)
* first = newNode;
* else
* l.next = newNode;
* size++;
* modCount++;
* }
*
*/
System.out.println("list=" + list);
// //删除第一个节点
// list.remove();
// System.out.println("删除第一个节点list=" + list);
// //删除指定的元素
// list.remove(new Integer(200));
// System.out.println("删除指定的元素list=" + list);
// //按照索引删除元素
// list.remove(0);
// System.out.println("按照索引删除元素list=" + list);
// //删除第一个元素
// list.removeFirst();
// System.out.println("删除第一个元素list=" + list);
// //删除最后一个元素
// list.removeLast();
// System.out.println("删除最后一个元素list=" + list);
//
// //修改元素 返回修改的元素
// System.out.println(list.set(0,666));
// //查找元素
// System.out.println( list.get(0));
System.out.println("====迭代器遍历===");
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println(obj);
}
System.out.println("====增强for遍历===");
for (Object obj : list) {
System.out.println(obj);
}
System.out.println("====普通for遍历===");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
LinkedList和ArrayList的区别
Set接口和常用方法
(1)无序(添加和取出的顺序不一致),没有索引
(2)不允许元素重复,所以最多包含一个null
(3)JDK API中Set接口的实现类有:
Set接口的遍历方式
同Collection的遍历方式一样,因为Set接口是Collection接口的子接口。
1.可以使用迭代器
2.增强for循环
3.不能使用索引的方式来获取
常用方法示例;
package com.he.set_;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* @author hejh7
* @date 2022/11/8 0008 11:45
* @describe
*/
@SuppressWarnings({"all"})
public class SetMethod {
public static void main(String[] args) {
// 以Set接口的实现类,HashSet为例
// Set接口的实现类的对象(Set接口对象)不能存放重复元素
// 可以添加一个null
// Set接口对象存放数据、对象是无序的(添加顺序和取出顺序不一致)
// 取出的顺序是固定的
Set set = new HashSet();
set.add("小米");
set.add("大黑");
set.add("张三");
set.add("jankin");
set.add(null);
set.add(null);
for (int i = 0; i < 10; i++) {
System.out.println(set);
}
//遍历
System.out.println("===迭代器遍历===");
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj=" + obj);
}
System.out.println("===增强for循环遍历===");
for (Object obj : set) {
System.out.println(obj);
}
System.out.println("==================================");
System.out.println("size=" + set.size());
System.out.println("是否为空:" + set.isEmpty());
System.out.println("包含元素张三:"+set.contains("张三"));
System.out.println(set.remove(null));
System.out.println(set.remove("jankin"));
System.out.println(set);
}
}
HashSet的全面说明
(1)HashSet实现了Set接口
(2)HashSet实际上是HashMap
(3)可以存放null值,但是只能有一个null
(4)HashSet不保证元素是有序的,取决于hash后,再确定索引的结果(不保证元素存放和取出顺序一致)
(5)不能有重复元素/对象。在前面Set接口使用已经讲过了
package com.he.set_;
/**
* @author hejh7
* @date 2022/11/8 0008 11:54
* @describe
*/
public class HashSetStructure {
public static void main(String[] args) {
// 模拟一个HashSet的底层(其实就是HashMap)
// 创建一个Node数组,有些人称为table
Node[] table = new Node[16];
System.out.println("table=" + table);
Node jhon = new Node("jhon", null);
table[2] = jhon;
System.out.println("table=" + table);
Node jack = new Node("jack", null);
jhon.next = jack;
Node rose = new Node("rose", null);
jack.next = rose;
System.out.println("table:" + table);
Node lucy = new Node("lucy", null);
table[3] = lucy;
}
}
class Node {
Object item;
Node next;
public Node(Object item, Node next) {
this.item = item;
this.next = next;
}
@Override
public String toString() {
return "Node{" +
"item=" + item + '}';
}
}
HashSet的底层机制
分析:HashSet底层是HashMap,HashMap底层是(数组+链表+红黑树)
浓缩成6句话
1.HashSet底层是HashMap
2.添加一个元素时,先得到hash值,会转成索引值
3.找到存储数据表table,看这个索引位置是否已经存放的有元素
4.如果没有,直接加入
5.如果有,调用equals比较,如果相同,就放弃添加,如果不相同,则添加到最后
6.在JAVA 8 中,如果一条链表的元素个数,到达TREEIFY_THRESHOLD(默认是8),并且table的大小>= MIN_TREEIFY_CAPACITY(默认64)就进行树化(红黑树)
7.不管是数组还是数组中的链表元素个数,只要总数大于临界值 就进行扩容。
源码分析:
package com.he.set_;
import java.util.HashSet;
import java.util.Objects;
/**
* @author hejh7
* @date 2022/11/9 0009 17:09
* @describe
*/
@SuppressWarnings({"all"})
public class HashSetResourceCode {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
// hashSet.add("java");
// hashSet.add("php");
// hashSet.add("java");
//演示扩容 添加的元素大于数组临界值12个时候 扩容 数组16 临界值12 --> 数组扩大原来的两倍32 临界值24(数组 大小乘以加载因子0.75) --> 数组64 临界值48。。。。。
// for (int i = 1; i <= 100; i++) {
// hashSet.add(i);
// }
//演示链表
for (int i = 1; i <= 12; i++) {
hashSet.add(new A(i));
}
/**
* 源码分析:
*1.初始化HashSet 就是初始化了一个HashMap
* public HashSet() {
* map = new HashMap<>();
* }
* 2添加元素
* 2.1 调用add()方法 private static final Object PRESENT = new Object();
* public boolean add(E e) {
* return map.put(e, PRESENT)==null;
* }
* 2.2 调用put() 方法 value 就是 new Object()
* public V put(K key, V value) {
* return putVal(hash(key), key, value, false, true);
* }
* 2.3 调用2,2 中的hash()方法
* static final int hash(Object key) {
* int h;
* //返回需要添加元素的hashCode值 h >>> 16标识无符号右移16位
//计算key值的hashCode值 h = key.hashCode()
//key值的hashCode值无符号右移16位 h >>> 16
//1.右移16位是为了让高16位也参与运算,可以更好的均匀散列,减少碰撞,进一步降低hash冲突的几率
//2.异或运算是为了更好保留两组32位二进制数中各自的特征
* return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
* }
* 2.3 调用putVal() 方法
* final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
* boolean evict) {
* //定义辅助变量
* Node<K,V>[] tab; Node<K,V> p; int n, i;
* //判断数组tab 为null 或者 tab的长度为0 对table进行扩容
* //调用resize()方法扩容 这时tab的容量为16 阈值或者叫临界值为 16*0.75(加载因子) = 12
* if ((tab = table) == null || (n = tab.length) == 0)
* n = (tab = resize()).length;
* // (n - 1) & hash 算出 新加入元素的索引位置 并将当前元素再数组中的对象赋值给p
* // 表中索引的位置没有元素
//位与运算符为&,其运算规则是:参与运算的数字,低位对齐,高位不足的补零,如果对应的二进制位同时 为 1,那么计算结果才为 1,否则为 0。因此,任何数与 0 进行按位与运算,其结果都为 0。
* if ((p = tab[i = (n - 1) & hash]) == null)
* //添加元素
* tab[i] = newNode(hash, key, value, null);
* else {
* //定义辅助变量
* Node<K,V> e; K k;
* //如果当前的hash值和原来元素的hash值相等 且 值也相等 添加失败
* if (p.hash == hash &&
* ((k = p.key) == key || (key != null && key.equals(k))))
* e = p;
* //添加的元素 是否为 树节点
* else if (p instanceof TreeNode)
* //添加树节点
* e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
* else {
* // 死循环
* for (int binCount = 0; ; ++binCount) {
* //表中的元素和现在添加的元素hashCode一致
* //表中元素的下一个元素为空 新加的元素追加到当前元素的后面
* // 当前节点的下一个元素赋值给e
* if ((e = p.next) == null) {
* p.next = newNode(hash, key, value, null);
* //元素节点的链表达到8个 进行数化 将链表转化为红黑树
* if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
* treeifyBin(tab, hash);
* break;
* }
* //如果新加的元素和链表中的元素相等 退出
* if (e.hash == hash &&
* ((k = e.key) == key || (key != null && key.equals(k))))
* break;
* // 将e赋值给p 链表后移
* p = e;
* }
* }
* //元素不为null
* if (e != null) { // existing mapping for key
* V oldValue = e.value;
* if (!onlyIfAbsent || oldValue == null)
* e.value = value;
* afterNodeAccess(e);
* //返回原来元素的value 也是是空的Object
* return oldValue;
* }
* }
* //修改次数
* ++modCount;
* //如果表中的元素个数大于临界值 进行扩容
* if (++size > threshold)
* resize();
* //
* afterNodeInsertion(evict);
* return null;
* }
*
*/
}
}
class A {
int n;
public A(int n) {
this.n = n;
}
@Override
public int hashCode() {
return 100;
}
}
课堂练习:
package com.he.set_;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
/**
* @author hejh7
* @date 2022/11/10 0010 9:59
* @describe
*/
@SuppressWarnings({"all"})
public class HashSetExercise {
public static void main(String[] args) {
Set hashSet = new HashSet();
hashSet.add(new Employee("tom",12));
hashSet.add(new Employee("jack",23));
hashSet.add(new Employee("tom",12));
hashSet.add(new Employee("rose",45));
System.out.println("hashSet=" + hashSet);
}
}
class Employee{
private String name;
private int age;
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Employee employee = (Employee) o;
return age == employee.age && Objects.equals(name, employee.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
课后练习
package com.he.set_;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
/**
* @author hejh7
* @date 2022/11/10 0010 10:04
* @describe
*/
@SuppressWarnings({"all"})
public class HashSetExercise1 {
public static void main(String[] args) {
Set hashSet = new HashSet();
hashSet.add(new Employee1("tom",2300f,new MyDate("2020","7","8")));
hashSet.add(new Employee1("jack",4800f,new MyDate("2021","9","9")));
hashSet.add(new Employee1("tom",2300f,new MyDate("2020","7","8")));
hashSet.add(new Employee1("tom",4500f,new MyDate("2020","7","8")));
System.out.println(hashSet);
}
}
class Employee1{
private String name;
private float salary;
private MyDate birthday;
public Employee1(String name, float salary, MyDate birthday) {
this.name = name;
this.salary = salary;
this.birthday = birthday;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public float getSalary() {
return salary;
}
public void setSalary(float salary) {
this.salary = salary;
}
public MyDate getBirthday() {
return birthday;
}
public void setBirthday(MyDate birthday) {
this.birthday = birthday;
}
@Override
public String toString() {
return "Employee1{" +
"name='" + name + '\'' +
", salary=" + salary +
", birthday=" + birthday +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Employee1 employee1 = (Employee1) o;
return Objects.equals(name, employee1.name) && Objects.equals(birthday, employee1.birthday);
}
@Override
public int hashCode() {
return Objects.hash(name, birthday);
}
}
class MyDate{
private String year;
private String month;
private String day;
public MyDate(String year, String month, String day) {
this.year = year;
this.month = month;
this.day = day;
}
public String getYear() {
return year;
}
public void setYear(String year) {
this.year = year;
}
public String getMonth() {
return month;
}
public void setMonth(String month) {
this.month = month;
}
public String getDay() {
return day;
}
public void setDay(String day) {
this.day = day;
}
@Override
public String toString() {
return "MyDate{" +
"year='" + year + '\'' +
", month='" + month + '\'' +
", day='" + day + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
MyDate myDate = (MyDate) o;
return Objects.equals(year, myDate.year) && Objects.equals(month, myDate.month) && Objects.equals(day, myDate.day);
}
@Override
public int hashCode() {
return Objects.hash(year, month, day);
}
}
LinkedHashSet
LinkedHashSet的全面说明
(1)LinkedHashSet是HashSet的子类
(2)LinkedHashSet底层是一个LinkedHashMap,底层维护了一个数组+双向链表+红黑树
(3)LinkedHashSet根据元素的hashCode值来决定元素的存储位置,同时使用链表维护元素的次序图(图),这使得元素看起来是以插入顺序保存的。
(4)LinkedHashSet不允许添加重复元素
说明:
在LinkedHashSet中维护一个hash表和双向链表(LinkedHashSet 有head和tail)
每一个结点有before和after属性,这样可以形成双向链表
在添加一个元素时,先求hash值,再求索引,确定该元素在table的位置,然后将添加的元素加入到双向链表(如果已经存在,不添加[原则和hashset一样])
tail.next = newElement
newElement.pre = tail
tail = newElement;
这样的话,我们遍历LinkedHashSet 也能确保插入顺序和遍历顺序一致
package com.he.set_;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
/**
* @author hejh7
* @date 2022/11/12 0012 11:12
* @describe
*/
@SuppressWarnings({"all"})
public class LinkHashSetSource {
public static void main(String[] args) {
HashSet linkedHashSet = new LinkedHashSet();
linkedHashSet.add("tom");
linkedHashSet.add("123");
linkedHashSet.add("123");
linkedHashSet.add("456");
linkedHashSet.add(new Customer("张三",23));
linkedHashSet.add("HJH");
linkedHashSet.add(null);
linkedHashSet.add(null);
Iterator iterator = linkedHashSet.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj==" + obj);
}
//源码解读
//1.LinkedHashSet 加入顺序和取出元素/数据的顺序一致
//2.LinkedHashSet 底层维护的是一个LinkedHashMap(是HashMap的子类)
//3.LinkedHashSet 底层结构(数组table + 双向链表)
//4.LinkedHashSet 第一次添加元素时 直接将数组table 扩容到16 存放的节点类型是 LinkedHashMap$Entry
//5.数组是 HashMap$Node[] 存放的元素/数组时 LinkedHashMap$Entry
}
}
class Customer{
private String name;
private int age;
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 Customer(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Customer{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
练习
equals和hashCode重写
package com.he.set_;
import java.util.LinkedHashSet;
import java.util.Objects;
/**
* @author hejh7
* @date 2022/11/12 0012 11:35
* @describe
*/
@SuppressWarnings({"all"})
public class LinkedHashSetExercise {
public static void main(String[] args) {
//对象如何没有重新 hashCode() 和 equals() 方法 会添加相同的对象 两者缺一不可
LinkedHashSet linkedHashSet = new LinkedHashSet();
linkedHashSet.add(new Car("奥拓",1000));
linkedHashSet.add(new Car("奥迪",300000));
linkedHashSet.add(new Car("法拉利",200000));
linkedHashSet.add(new Car("奥拓",1000));
linkedHashSet.add(new Car("保时捷",7000000));
linkedHashSet.add(new Car("奥拓",1000));
System.out.println(linkedHashSet);
}
}
class Car{
private String name;
private double price;
public Car(String name, double price) {
this.name = name;
this.price = price;
}
@Override
public String toString() {
return "\nCar{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Car car = (Car) o;
return Double.compare(car.price, price) == 0 && Objects.equals(name, car.name);
}
@Override
public int hashCode() {
return Objects.hash(name, price);
}
}
TreeSet
TreeSet含Comparator构造器
package com.he.set_;
import java.util.Comparator;
import java.util.TreeSet;
/**
* @author hejh7
* @date 2022/11/19 0019 11:48
* @describe
*/
@SuppressWarnings({"all"})
public class TreeSet_ {
public static void main(String[] args) {
//当使用无参构造器创建TreeSet的时候是无序的
TreeSet treeSet = new TreeSet();
treeSet.add("tom");
treeSet.add("jack");
treeSet.add("smith");
treeSet.add("jankinHe");
treeSet.add("aine");
System.out.println("treeSet=" + treeSet);
System.out.println("---按照字符串首字母的顺序进行排序---");
//可以传入一个比较器(匿名内部类) 并指定规则
//如何字符串里面既有大写又有小写 先排序大写 再排序小写
TreeSet treeSet1 = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String) o1).compareTo((String) o2);
}
});
treeSet1.add("tom");
treeSet1.add("milan");
treeSet1.add("smith");
treeSet1.add("JankinHe");
treeSet1.add("aine");
treeSet1.add("Sdd");
System.out.println("treeSet1=" + treeSet1);
System.out.println("---按照字符串长度进行排序 长度相同加不进入---");
//可以传入一个比较器(匿名内部类) 并指定规则
TreeSet treeSet2 = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String) o1).length() - ((String) o2).length();
}
});
treeSet2.add("tom");
treeSet2.add("milan");
treeSet2.add("smith");
treeSet2.add("JankinHe");
treeSet2.add("aine");
treeSet2.add("Sdd");
System.out.println("treeSet2=" + treeSet2);
/**
* 源码:
* 1.构造器把传入的比较器对象 赋值给 TreeSet的底层的 TreeMap的属性 this.comparator
* public TreeMap(Comparator<? super K> comparator) {
* this.comparator = comparator;
* }
* 2.调用add
* public boolean add(E e) {
* return m.put(e, PRESENT)==null;
* }
* 3.调用 put
* public V put(K key, V value) {
* Entry<K,V> t = root;
* //第一次添加执行
* if (t == null) {
* compare(key, key); // type (and possibly null) check
*
* root = new Entry<>(key, value, null);
* size = 1;
* modCount++;
* return null;
* }
* int cmp;
* Entry<K,V> parent;
* // split comparator and comparable paths
* Comparator<? super K> cpr = comparator;
* //第二次添加执行
* if (cpr != null) {
* do {
* parent = t;
* cmp = cpr.compare(key, t.key);
* if (cmp < 0)
* t = t.left;
* else if (cmp > 0)
* t = t.right;
* else
* return t.setValue(value);
* } while (t != null);
* }
* else {
* if (key == null)
* throw new NullPointerException();
* @SuppressWarnings("unchecked")
* Comparable<? super K> k = (Comparable<? super K>) key;
* do {
* parent = t;
* cmp = k.compareTo(t.key);
* if (cmp < 0)
* t = t.left;
* else if (cmp > 0)
* t = t.right;
* else
* return t.setValue(value);
* } while (t != null);
* }
* Entry<K,V> e = new Entry<>(key, value, parent);
* if (cmp < 0)
* parent.left = e;
* else
* parent.right = e;
* fixAfterInsertion(e);
* size++;
* modCount++;
* return null;
* }
*/
}
}
Map集合
Map接口实现类的特点
(1)Map与Collection并列存在,用于保存具有映射关系的数据Key-Value(双列元素)
(2)Map中的key和value可以是任何引用类型的数据,会封装到HashMap$Node对象中
(3)Map中的key不允许重复,原因和HashSet一样,前面分析过源码。
(4)Map中的value可以重复
(5)Map的key可以为null,value也可以为null,注意key为null,只能有一个,value为null可以多个
(6)常用String类作为Map的key
(7)key和value之间存在单向一对一关系,即通过指定的key总能找到对应的value
package com.he.map_;
import java.util.HashMap;
import java.util.Map;
/**
* @author hejh7
* @date 2022/11/15 0015 13:16
* @describe
*/
@SuppressWarnings({"all"})
public class MapTest {
public static void main(String[] args) {
// (1)Map与Collection并列存在,用于保存具有映射关系的数据Key-Value(双列元素)
// (2)Map中的key和value可以是任何引用类型的数据,会封装到HashMap$Node对象中
// (3)Map中的key不允许重复,原因和HashSet一样,前面分析过源码。
// (4)Map中的value可以重复
// (5)Map的key可以为null,value也可以为null,注意key为null,只能有一个,value为null可以多个
// (6)常用String类作为Map的key
// (7)key和value之间存在单向一对一关系,即通过指定的key总能找到对应的value
Map hashMap = new HashMap();
hashMap.put("hjh","18");
hashMap.put("hjh",24);//key 相同 替换对用的value
hashMap.put("小明",24);
hashMap.put("tom",24);
hashMap.put(null,null);
hashMap.put(null,null);
hashMap.put("no",null);
System.out.println(hashMap.get("hjh"));
System.out.println("hashMap=" + hashMap);
}
}
(8)Map存放数据的key-value示意图,一对key-value 是放在一个Node中的,又因为Node实现了Entry接口,有些书上也说一对key-value就是一个Entry(如图)
package com.he.map_;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* @author hejh7
* @date 2022/11/15 0015 13:24
* @describe
*/
@SuppressWarnings({"all"})
public class MapSource_ {
public static void main(String[] args) {
Map hashMap = new HashMap();
hashMap.put("no1","张无忌");
hashMap.put("no2","金毛狮王");
hashMap.put("dog",new Dog());
//源码解读
/**
* 1 k-v 最后是 HashMap$Node node = newNode(hash,key,value,null)
* 2.k-v 为了方便程序员遍历,还会 创建 EntrySet集合 该集合存放的元素的类型 Entry ,
* 而一个Entey对象就有k,v EntrySet<Entry<k,v>> 即 transient Set<Map.Entry<k,v>> entrySet;
* 3.entrySet中 定义的类型是Map.Entry 但是实际上存放的还是 HashMap$Node
* 这是因为 static class Node<K,V> implements Map.Entry<k,V>;
* 4.当把HashMap$node 对象存放到entrySet 就方便我们遍历 因为 Map.Entry 提供了重要的方法 K getKey(); V getvalue();
*
*/
Set set = hashMap.entrySet();
System.out.println(set.getClass());//class java.util.HashMap$EntrySet
for (Object obj : set) {
//System.out.println(obj.getClass());//class java.util.HashMap$Node
//为了从HashMap$Node 取出k-v
//先做一个向下转型
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + "---" + entry.getValue());
}
}
}
class Dog{
}
Map的常用方法
(1)put:添加
(2)remove:根据键删除映射关系
(3)get:根据键获取值
(4)size:获取元素个数
(5)isEmpty:判断个数是否为0
(6)clear:清除
(7)containsKey:查找键是否存在
package com.he.map_;
import java.util.HashMap;
import java.util.Map;
/**
* @author hejh7
* @date 2022/11/15 0015 13:44
* @describe
*/
@SuppressWarnings({"all"})
public class MapMethod {
public static void main(String[] args) {
// (1)put:添加
// (2)remove:根据键删除映射关系
// (3)get:根据键获取值
// (4)size:获取元素个数
// (5)isEmpty:判断个数是否为0
// (6)clear:清除
// (7)containsKey:查找键是否存在
Map hashMap = new HashMap();
hashMap.put("邓超","孙俪");
hashMap.put("王宝强","马蓉");
hashMap.put("宋喆","马蓉");
hashMap.put("鹿晗","关晓彤");
hashMap.put("刘亦菲",null);
System.out.println("map=" + hashMap);
Object remove = hashMap.remove("宋喆");
System.out.println(remove);
System.out.println("map=" + hashMap);
System.out.println(hashMap.size());
System.out.println(hashMap.isEmpty());
System.out.println(hashMap.containsKey("hjh"));
System.out.println(hashMap.containsKey("刘亦菲"));
hashMap.clear();
System.out.println("map=" + hashMap);
}
}
Map接口遍历方法
Map遍历的示意图(比List,和Set复杂一点,但是基本原理一样)
(1)containsKey:查找键是否存在
(2)keySet:获取所有的键
(3)values:获取所有的值
(4)entrySet:获取所有关系
package com.he.map_;
import java.util.*;
/**
* @author hejh7
* @date 2022/11/15 0015 17:43
* @describe
*/
@SuppressWarnings({"all"})
public class MapFor {
public static void main(String[] args) {
Map map = new HashMap();
map.put("天龙八部","乔峰");
map.put("倚天同龙记","张无忌");
map.put("亮剑","李云龙");
map.put("打狗棍","戴天理");
map.put("刘亦菲",null);
map.put(null,null);
// **(1)containsKey:查找键是否存在**
//
// **(2)keySet:获取所有的键**
//
// **(3)values:获取所有的值**
//
// **(4)entrySet:获取所有关系**
System.out.println("---------keySet 先获取键 在获取值--------------");
System.out.println("-----增强for循环----");
Set set = map.keySet();
for (Object key : set) {
System.out.println(key + "-" + map.get(key));
}
System.out.println("-----迭代器----");
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Object key = iterator.next();
System.out.println(key + "-" + map.get(key));
}
System.out.println("----------values:获取所有的值---------");
System.out.println("-----增强for循环----");
Collection values = map.values();
for (Object value : values) {
System.out.println(value);
}
System.out.println("-----迭代器----");
Iterator iterator1 = values.iterator();
while (iterator1.hasNext()) {
Object next = iterator1.next();
System.out.println(next);
}
System.out.println("----------entrySet:获取所有关系---------");
Set entrySet = map.entrySet();
System.out.println("-----增强for循环----");
for (Object obj : entrySet) {
//System.out.println(obj.getClass());
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey()+"-" + entry.getValue());
}
System.out.println("-----迭代器----");
Iterator iterator2 = entrySet.iterator();
while (iterator2.hasNext()) {
Object next = iterator2.next();
Map.Entry entry = (Map.Entry) next;
System.out.println(entry.getKey() + "-" + entry.getValue());
}
}
}
课后练习
package com.he.map_;
import java.util.*;
/**
* @author hejh7
* @date 2022/11/15 0015 18:00
* @describe
*/
@SuppressWarnings({"all"})
public class MapExercise {
public static void main(String[] args) {
Map map = new HashMap();
map.put(1,new Employee("tom",1,13000));
map.put(2,new Employee("jack",2,28000));
map.put(3,new Employee("rose",3,36000));
map.put(4,new Employee("john",4,26000));
map.put(5,new Employee("lucy",5,17000));
//显示工资大于18000的
Set set = map.keySet();
System.out.println("------第一种遍历------");
for (Object key : set) {
Employee employee = (Employee) map.get(key);
if (employee.getSalary() > 18000){
System.out.println(key+"-"+employee);
}
}
System.out.println("------第二种遍历------");
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Object key = iterator.next();
Employee employee = (Employee) map.get(key);
if (employee.getSalary()>18000){
System.out.println(key+"-"+employee);
}
}
System.out.println("------第三种遍历------");
Set entrySet = map.entrySet();
for (Object obj : entrySet) {
Map.Entry entry = (Map.Entry) obj;
Object key = entry.getKey();
Employee employee = (Employee) entry.getValue();
if (employee.getSalary() > 18000){
System.out.println(key+"-"+employee);
}
}
System.out.println("------第四种遍历------");
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()) {
Object next = iterator1.next();
Map.Entry entry = (Map.Entry) next;
Object key = entry.getKey();
Employee employee = (Employee) entry.getValue();
if (employee.getSalary() > 18000){
System.out.println(key+"-"+employee);
}
}
}
}
class Employee {
private String name;
private int id;
private double salary;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Employee(String name, int id, double salary) {
this.name = name;
this.id = id;
this.salary = salary;
}
@Override
public String toString() {
return "employee{" +
"name='" + name + '\'' +
", id=" + id +
", salary=" + salary +
'}';
}
}
HashMap小结
- Map接口的常用实现类:HashMap、Hashtable和Properties
- HashMap是Map接口使用频率最高的实现类
- HashMap是以key-value 对的方式来存储数据(HashMap$Node类型)
- key不能重复,但是值可以重复,允许使用null值和null键(null键只能有1个)
- 如果添加相同的key,则会覆盖原来的key-val,等同于修改(key不会替换,val会替换)
- 与HashSet一样,不保证映射的顺序,因为底层是以hash表的方式来存储的。
- HashMap没有实现同步,因此是线程不安全的,方法没有做同步互斥的操作,没有synchronized
HashMap底层机制以及源码剖析
- HashMap底层维护了Node类型的数组table,默认为null
- 当创建对象时,将加载因子(loadFactor)初始化为0.75
- 当添加key-value时,通过key的哈希值得到在table的索引。然后判断该索引处是否有元素,如果没有元素,则直接添加。如果该处索引有元素,则继续判断该元素的key是否和准备加入的key相等,如果相等,则直接替换成新的val,如果不相等,需要判断是树结构还是链表结构,做出相应的处理。如果添加时发现容量不够,则需要扩容。
- 第1次添加,则需要扩容table容量为16,临界值(threshold)为12
- 以后再扩容,则需要扩容table容量为原来的2倍,临界值为原来的2倍,即24,以此类推。
- 在Java8中,如果一条链表的元素个数超过了TREEIFY_THRESHOLD(默认是8),并且table的大小>= MIN_TREEIFY_CAPACITY(默认64),就会进行树化(红黑树)
package com.he.map_;
import java.util.HashMap;
/**
* @author hejh7
* @date 2022/11/16 0016 12:27
* @describe
*/
@SuppressWarnings({"all"})
public class MapSource1 {
public static void main(String[] args) {
HashMap hashMap = new HashMap();
hashMap.put("java",10);
hashMap.put("java",20);
hashMap.put("php",10);
System.out.println("hashMap=" + hashMap);
/**
* 源码分析:
* 1.初始化HashMap 加载因子loadFactor=0.75 底层数组表为null
* public HashMap() {
* this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
* }
* 2.执行put方法
* public V put(K key, V value) {
* return putVal(hash(key), key, value, false, true);
* }
* 3.执行执行hash(key) 返回当前节点key的hash值 (h = key.hashCode()) ^ (h >>> 16);
* static final int hash(Object key) {
* int h;
* return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
* }
* 4.执行putVal方法
* final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
* boolean evict) {
* //辅助变量
* Node<K,V>[] tab; Node<K,V> p; int n, i;
* //如果table为null 或者 tab.length 为0 进行扩容
* if ((tab = table) == null || (n = tab.length) == 0)
* //第一次扩容核心代码
* //表的大小设置为16
* //newCap = DEFAULT_INITIAL_CAPACITY;
* //表的临界值为12(16*0.75)
* //newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
* n = (tab = resize()).length;
* if ((p = tab[i = (n - 1) & hash]) == null)
* //如何添加节点的key的hash值对应的table中的索引位置节点为null 直接添加到对应的位置
* tab[i] = newNode(hash, key, value, null);
* else {
* //辅助变量
* Node<K,V> e; K k;
* //如果新添加的k-v的在table表中索引对应的位置有值并且hash相等 key相等 则跳到下一步 替换的位置
* if (p.hash == hash &&
* ((k = p.key) == key || (key != null && key.equals(k))))
* e = p;
* //如果添加的k-v 是红黑树 则按照红黑树的方法进行添加
* else if (p instanceof TreeNode)
* e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
* else {
* //新添加的节点key的hash计算出表中的索引位置有值且不相等 执行下面
* //也就是在链表中添加节点
*
* for (int binCount = 0; ; ++binCount) {//死循环
* if ((e = p.next) == null) {
* //原来节点的下一个为null 直接添加
* p.next = newNode(hash, key, value, null);
* //添加完成后 判断链表的节点数是否到达8个 到达后调用树化方法将链表转换为红黑树
* if (binCount >= TREEIFY_THRESHOLD - 1) // TREEIFY_THRESHOLD=8
* //树化方法还会判断当前表的大小师傅到达64 没有则不会树化 而是对表进行扩容
* //核心代码如下
* //final void treeifyBin(Node<K,V>[] tab, int hash) {
* // int n, index; Node<K,V> e;
* // MIN_TREEIFY_CAPACITY = 64
* // if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
* // resize();
* treeifyBin(tab, hash);
* break;
* }
* //如何添加的元素节点和链表中的节点相等 则链表后移 继续进行比较
* if (e.hash == hash &&
* ((k = e.key) == key || (key != null && key.equals(k))))
* break;
* p = e;
* }
* }
* if (e != null) {
* V oldValue = e.value;
* //如果原来元素节点的key对应value不为空 则替换原来的value为当前的value
* if (!onlyIfAbsent || oldValue == null)
* e.value = value;
* afterNodeAccess(e);
* return oldValue;
* }
* }
* //每次添加成功++
* ++modCount;
* //添加完成后判断元素的个数是否大于临界值 大于进行扩容
* if (++size > threshold)
* resize();
* afterNodeInsertion(evict);
* return null;
* }
*
*/
}
}
触发树化测试(链表元素到达8个 且表的大小扩容到64)
package com.he.map_;
import java.util.HashMap;
import java.util.Objects;
/**
* @author hejh7
* @date 2022/11/16 0016 13:02
* @describe
*/
@SuppressWarnings({"all"})
public class MapSource2 {
public static void main(String[] args) {
HashMap hashMap = new HashMap();
for (int i = 1; i <= 12; i++) {
hashMap.put(new A(i),"hello");
}
}
}
class A {
private int num;
public A(int num) {
this.num = num;
}
@Override
public int hashCode() {
return 100;
}
}
Map接口实现类-Hashtable
- 存放的元素是键值对:即K-V
- hashtable的键和值都不能为null,否则会抛出NullPointerException
- hashTable使用方法基本上和HashMap一样
- hashTable是线程安全的(synchronized),hashMap是线程不安全的
- 实现Map接口
注意:
- 底层有数组 Hashtable$Entry[] 初始化大小为11
- 临界值 threshold = 11 * 0.75 ≈ 8
- 扩容:按照自己的扩容机制来进行
- 执行方法 addEntry(hash, key, value, index); 添加键值对,封装到Entry
package com.he.map_;
import java.util.Hashtable;
/**
* @author hejh7
* @date 2022/11/18 0018 9:38
* @describe
*/
@SuppressWarnings({"all"})
public class Hashtable_ {
public static void main(String[] args) {
Hashtable hashtable = new Hashtable();
//hashtable.put(null,null); //java.lang.NullPointerException
//hashtable.put(123,null); //java.lang.NullPointerException
//hashtable.put(null,456); //java.lang.NullPointerException
hashtable.put("tom",23);
hashtable.put("rose",18);
hashtable.put("john",66);
hashtable.put("john",27);
System.out.println("hashtable=" + hashtable);
// 1. 存放的元素是键值对:即K-V
// 2. **hashtable的键和值都不能为null**,否则会抛出NullPointerException
// 3. hashTable使用方法基本上和HashMap一样
// 4. **hashTable是线程安全的**(synchronized),**hashMap是线程不安全的**
// 5. 实现Map接口
// 6 扩容机制 Hashtable$Entry[] 初始化大小为11 threshold = 11 * 0.75 ≈ 8
//扩容是原来数组的2倍加1
}
}
Hashtable和HashMap对比
名称 | 版本 | 线程安全 | 效率 | 允许null键null值 |
---|---|---|---|---|
HashMap | 1.2 | 不安全 | 高 | 可以 |
Hashtable | 1.0 | 安全 | 较低 | 不可以 |
Properties
基本介绍
- Properties类继承自Hashtable类并且实现了Map接口,也是一种键值对的形式来保存数据。
- 它的使用特点和Hashtable类似。
- Properties还可以用于从xxx.properties文件中,加载数据到Properties类对象,并进行读取和修改。
- 文章链接:https://www.cnblogs.com/xudong-bupt/p/3758136.html
基本用法:
package com.he.map_;
import java.util.Properties;
/**
* @author hejh7
* @date 2022/11/18 0018 9:29
* @describe
*/
@SuppressWarnings({"all"})
public class Properties_ {
public static void main(String[] args) {
Properties properties = new Properties();
//添加元素 键和值都不能为空 否则空指针异常
//properties.put(null,null); //java.lang.NullPointerException
//properties.put(null,"123"); //java.lang.NullPointerException
//properties.put(123,null); //java.lang.NullPointerException
properties.put("john",100);
properties.put("tom",23);
properties.put("rose",88);
properties.put("john",200);//替换
System.out.println("properties=" + properties);
//删除
properties.remove("tom");
System.out.println("删除后properties=" + properties);
//获取
System.out.println(properties.get("rose"));
//修改
properties.setProperty("rose","66");
System.out.println("修改后properties=" + properties);
}
}
说明:工作后xxx.properties文件通常作为配置文件,这个知识点在IO流举例,有兴趣可先看文章。
配置文件不会显示乱码,统一调整为UTF-8
res.properties
name=root
key=value
pass=liu
package com.he.map_;
import java.io.*;
import java.util.Properties;
import java.util.Set;
/**
* @author hejh7
* @date 2022/11/18 0018 9:50
* @describe
*/
@SuppressWarnings({"all"})
public class PropertiesTest {
public static void main(String[] args) {
Properties properties = new Properties();
String path = "src/res.properties";
BufferedReader bufferedReader = null;
BufferedWriter bufferedWriter = null;
try {
//获取
bufferedReader = new BufferedReader(new FileReader(path));
properties.load(bufferedReader);
Set<Object> keys = properties.keySet();
for (Object key : keys) {
System.out.println(key + "---" + properties.getProperty((String) key));
}
//写入
bufferedWriter = new BufferedWriter(new FileWriter(path));
properties.setProperty("tom","23");
properties.setProperty("john","约翰");
properties.store(bufferedWriter,"这是新写入的!");
} catch (IOException e) {
e.printStackTrace();
}
}
}
TreeMap
package com.he.map_;
import java.util.Comparator;
import java.util.TreeMap;
/**
* @author hejh7
* @date 2022/11/19 0019 12:13
* @describe
*/
@SuppressWarnings({"all"})
public class TreeMap_ {
public static void main(String[] args) {
//无参构造 无序
TreeMap treeMap = new TreeMap();
treeMap.put("tom","汤姆");
treeMap.put("jack","杰克");
treeMap.put("lucy","露丝");
treeMap.put("milan","米兰");
treeMap.put("jankin","大神");
System.out.println("TreeMap=" + treeMap);
System.out.println("===按照key的首字母顺序排序===");
TreeMap treeMap1 = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String)o1).compareTo(((String)o2));
}
});
treeMap1.put("tom","汤姆");
treeMap1.put("jack","杰克");
treeMap1.put("lucy","露丝");
treeMap1.put("milan","米兰");
treeMap1.put("jankin","大神");
System.out.println("treeMap1=" + treeMap1);
System.out.println("===按照key的长度排序===");
TreeMap treeMap2 = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String)o1).length()-(((String)o2)).length();
}
});
treeMap2.put("tom","汤姆");
treeMap2.put("jack","杰克");
treeMap2.put("lucy","露丝");//key相同 会替换原来形同长度key对应的value
treeMap2.put("milan","米兰");
treeMap2.put("jankin","大神");
System.out.println("treeMap2=" + treeMap2);
}
}
集合选型
在开发中,选择什么集合实现类,主要取决于业务操作特点,然后根据集合实现类特性进行选择,分析如下:
(1)先判断存储类型(一组对象(单列)或者键值对(双列))
(2)一组对象: Collection接口
允许重复:List
增删多:LinkedList(底层是双向链表)
查改多:ArrayList(底层维护Object类型的可变数组)
不允许重复:Set
无序:HashSet底层是HashMap,维护一个Hash表(数组+链表+红黑树)
排序:TreeSet
插入和取出顺序一样: LinkedHashSet(继承自LinkedHashMap),维护数组+双向链表
(3)键值对:Map
键无序:HashMap(底层是:哈希表:数组+链表+红黑树)
键有序:TreeMap
键插入和取出顺序一致:LinkedHashMap(继承自HashMap)
读取文件: Properties
Collections工具类
Collections工具类介绍
- Collections是一个操作Set、List和Map等集合的工具类
- Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改操作
排序操作(均为static方法)
- reverse(List):反转List中元素的顺序
- shuffle(List):对List集合元素进行随机排序
- sort(List):根据元素的自然顺序对指定List集合元素按升序排序
- sort(List,Comparator):根据指定的Comparator产生的顺序对List集合进行排序
- swap(List,int,int):将指定list集合中的i处元素和j处元素进行交换
package com.he.collections_;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/**
* @author hejh7
* @date 2022/11/19 0019 12:24
* @describe
*/
@SuppressWarnings({"all"})
public class Collections_ {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("tom");
arrayList.add("hjh");
arrayList.add("rose");
arrayList.add("smith");
arrayList.add("jankinHe");
System.out.println("arrayList=" + arrayList);
// 1. reverse(List):反转List中元素的顺序
Collections.reverse(arrayList);
System.out.println("反转List中元素的顺序"+ arrayList);
// 2. shuffle(List):对List集合元素进行随机排序
// for (int i = 0; i < 5; i++) {
// Collections.shuffle(arrayList);
// System.out.println("对List集合元素进行随机排序"+ arrayList);
// }
// 3. sort(List):根据元素的自然顺序对指定List集合元素按升序排序
Collections.sort(arrayList);
System.out.println("根据元素的自然顺序对指定List集合元素按升序排序"+ arrayList);
// 4. sort(List,Comparator):根据指定的Comparator产生的顺序对List集合进行排序
Collections.sort(arrayList, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof String && o2 instanceof String){
String str1 = (String) o1;
String str2 = (String) o2;
int len1 = str1.length();
int len2 = str2.length();
//自定义比较规则 长度排序(由短到长) 长度相同按照首字符顺序排序
int res = (len1 == len2 ? str1.compareTo(str2): len1-len2);
return res;
}else {
return 0;
}
}
});
System.out.println("根据指定的Comparator产生的顺序对List集合进行排序"+ arrayList);
// 5. swap(List,int,int):将指定list集合中的i处元素和j处元素进行交换
Collections.swap(arrayList,1,2);
System.out.println("将指定list集合中的i处元素和j处元素进行交换"+ arrayList);
}
}
查找和替换
- Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素
- Object max(Collection, Comparator):根据Compartor指定的顺序,返回给定集合中的最大元素
- Object min(Collection)
- Object min(Collection, Object)
- int frequency(Collection, Object):返回指定集合中指定元素的出现次数
- void copy(List dest, List src):将src中的内容复制到dest中
- boolean replaceAll(List list, Object oldVal, Object newVal):使用新值替换List对象的所有旧值
package com.he.collections_;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
/**
* @author hejh7
* @date 2022/11/19 0019 12:37
* @describe
*/
@SuppressWarnings({"all"})
public class CollectionsTest {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("tom");
arrayList.add("hjh");
arrayList.add("rose");
arrayList.add("jankinHe");
arrayList.add("smith");
System.out.println("arrayList=" + arrayList);
// 1. Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素
System.out.println("根据元素的自然顺序,返回给定集合中的最大元素=" + Collections.max(arrayList));
// 2. Object max(Collection, Comparator):根据Compartor指定的顺序,返回给定集合中的最大元素
Object max = Collections.max(arrayList, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof String && o2 instanceof String) {
String str_o1 = (String) o1;
String str_o2 = (String) o2;
int a = str_o1.length();
int b = str_o2.length();
int result = a == b ? str_o1.compareTo(str_o2) : a - b;
return result;
} else {
return 0;
}
}
});
System.out.println("根据Compartor指定的顺序,返回给定集合中的最大元素=" + max);
// 3. Object (Collection)
System.out.println("根据元素的自然顺序,返回给定集合中的最小元素=" + Collections.min(arrayList));
// 4. Object min(Collection, Object)
Object min = Collections.min(arrayList, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof String && o2 instanceof String) {
String str_o1 = (String) o1;
String str_o2 = (String) o2;
int a = str_o1.length();
int b = str_o2.length();
int result = a == b ? str_o1.compareTo(str_o2) : a - b;
return result;
} else {
return 0;
}
}
});
System.out.println("根据Compartor指定的顺序,返回给定集合中的最小元素=" + min);
// 5. int frequency(Collection, Object):返回指定集合中指定元素的出现次数
int tom = Collections.frequency(arrayList, "tom");
System.out.println("返回指定集合中指定元素的出现次数" + tom);
// 6. void copy(List dest, List src):将src中的内容复制到dest中
// 拷贝要注意 ,拷贝后的集合dest的元素个数要 >= 被拷贝集合arrayList
//一般情况在初始化dest指定大小和arrayList相同
//ArrayList dest = new ArrayList(); // java.lang.IndexOutOfBoundsException
ArrayList dest = new ArrayList();
for (int i = 0; i < arrayList.size(); i++) {
dest.add(i);
}
Collections.copy(dest,arrayList);
System.out.println("dest=" + dest);
// 7. boolean replaceAll(List list, Object oldVal, Object newVal):使用新值替换List对象的所有旧值
Collections.replaceAll(dest,"tom","zs");
System.out.println("dest=" + dest);
}
}
课后作业
课后作业1
package com.he.homework;
import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Collections;
/**
* @author hejh7
* @date 2022/11/19 0019 13:07
* @describe
*/
@SuppressWarnings({"all"})
public class HomeWork1 {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add(new News("新冠确诊病例超千万,数百万印度教徒赴恒河'圣浴'引民众担忧。"));
arrayList.add(new News("男子突然想起2个月前钓的鱼还在网兜里,捞起一看赶紧放生。"));
System.out.println("----倒序遍历----");
int size = arrayList.size();
for (int i = size-1; i >= 0; i--) {
News news = (News) arrayList.get(i);
System.out.println(processTitle(news.getTitle()));
}
// Collections.reverse(arrayList);
// System.out.println("arrayList=" + arrayList);
// for (Object obj : arrayList) {
// News news = (News) obj;
// if (news.getContent().length()>=15){
// news.setContent(news.getContent().substring(0,15) + "...");
// }
// System.out.println(news.getContent());
// }
}
public static String processTitle(String title){
if (title == null){
return null;
}
if (title.length() > 15){
return title.substring(0,15) + "...";
}else {
return title;
}
}
}
class News{
private String title;
private String content;
public News(String title) {
this.title = title;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
@Override
public String toString() {
return "News{" +
"title='" + title + '\'' +
'}';
}
}
课后作业2
package com.he.homework;
import java.util.ArrayList;
import java.util.Iterator;
/**
* @author hejh7
* @date 2022/11/19 0019 17:47
* @describe
*/
@SuppressWarnings({"all"})
public class HomeWork2 {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
//添加元素
Car car1 = new Car("桑塔纳", 78000);
Car car2 = new Car("奔驰",450000);
Car car3 = new Car("宝来",120000);
Car car4 = new Car("保时捷卡宴",1160000);
Car car5 = new Car("面包车",66000);
arrayList.add(car1);
arrayList.add(car2);
arrayList.add(car3);
arrayList.add(car4);
arrayList.add(car5);
System.out.println("---arrayList增强for循环遍历---");
for (Object obj : arrayList) {
System.out.println(obj);
}
System.out.println("---arrayList迭代器遍历---");
Iterator iterator = arrayList.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next);
}
System.out.println("arrayList集合元素个数为:"+ arrayList.size());
System.out.println("arrayList集合是否为空:"+ arrayList.isEmpty());
//查找元素是否存在
System.out.println("arrayList元素car1是否存在:"+arrayList.contains(car1));
System.out.println("arrayList删除元素car1:"+arrayList.remove(car1));
arrayList.clear();
System.out.println("arrayList清空集合元素后" + arrayList);
ArrayList arrayList1 = new ArrayList();
Car c1 = new Car("宝马",450000);
Car c2 = new Car("宾利",5000000);
arrayList1.add(c1);
arrayList1.add(c2);
arrayList.addAll(arrayList1);
System.out.println("arrayList添加多个元素后" + arrayList);
System.out.println("arrayList查找多个元素是否存在" + arrayList.containsAll(arrayList1));
arrayList.removeAll(arrayList1);
System.out.println("arrayList删除多个元素后" + arrayList);
System.out.println("arrayList集合元素个数为:"+ arrayList.size());
System.out.println("arrayList集合是否为空:"+ arrayList.isEmpty());
}
}
class Car{
private String name;
private Integer price;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getPrice() {
return price;
}
public void setPrice(Integer price) {
this.price = price;
}
public Car(String name, Integer price) {
this.name = name;
this.price = price;
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
课后作业3
package com.he.homework;
import java.util.*;
/**
* @author hejh7
* @date 2022/11/19 0019 18:13
* @describe
*/
@SuppressWarnings({"all"})
public class HomeWork3 {
public static void main(String[] args) {
HashMap hashMap = new HashMap();
hashMap.put("jack",650);
hashMap.put("tom",1200);
hashMap.put("smith",2900);
System.out.println("hashMap=" + hashMap);
//将jack的工资更改为2600
System.out.println("---将jack的工资更改为2600---");
hashMap.put("jack",2600);
System.out.println("hashMap=" + hashMap);
//遍历所有的员工
System.out.println("---遍历所有的员工 方法1---");
Set set = hashMap.entrySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry)iterator.next();
System.out.println(entry.getKey()+"---"+entry.getValue());
}
System.out.println("---遍历所有的员工 方法2---");
Set set2 = hashMap.keySet();
for (Object key : set2) {
System.out.println(key+"---"+hashMap.get(key));
}
System.out.println("---遍历所有的工资---");
//遍历所有的工资
Collection values = hashMap.values();
for (Object value : values) {
System.out.println("员工工资:" + value);
}
System.out.println("---为所有的员工加薪100---");
//为所有的员工加薪100
Set set1 = hashMap.keySet();
for (Object obj : set1) {
hashMap.put(obj,((Integer)hashMap.get(obj))+100);
System.out.println("员工工资:" + hashMap.get(obj));
}
}
}
课后作业4
试分析HashSet和TreeSet分别是如何实现去重的
- HashSet的去重机制:hashCode() + equals(),底层先通过存入对象,进行运算得到一个hash值,通过hash值得到对应的索引,如果发现table索引所在的位置,没有数据,就直接存放,如果有数据,就进行equals比较[遍历比较],如果比较后不相同就加入,否则就不加入。
- TreeSet的去重机制:如果你传入了一个Comparator匿名对象,就使用实现的compare去重,如果方法返回0,就认为是相同的元素/数据,就不添加; 如果你没有传入一个Comparator匿名对象,则以你添加的对象实现的Comparator接口的compareTo去重。
课后作业5
package com.he.homework;
import java.util.TreeSet;
import java.util.concurrent.TransferQueue;
/**
* @author hejh7
* @date 2022/11/19 0019 18:44
* @describe
*/
@SuppressWarnings({"all"})
public class HomeWork05 {
public static void main(String[] args) {
TreeSet treeSet = new TreeSet();
treeSet.add(new Person()); java.lang.ClassCastException 报错
System.out.println(treeSet);
// 错误原因:treeSet在add时候会执行
/**
* final int compare(Object var1, Object var2) {
* return this.comparator == null ? ((Comparable)var1).compareTo(var2) : this.comparator.compare(var1, var2);
* }
*
* 会把加入的元素var1 转换成(Comparable) 对象,所以Person必须实现Comparable接口才行
*/
}
}
class Person implements Comparable{// 实现之后再添加就不会报错了
/**
*TreeSet的去重机制:如果你传入了一个Comparator匿名对象,就使用实现的compare去重,如果方法返回0,
* 就认为是相同的元素/数据,就不添加,如果你没有传入一个Comparator匿名对象,
* 则以你添加的对象实现的Comparator接口的compareTo去重。
* final int compare(Object var1, Object var2) {
* return this.comparator == null ? ((Comparable)var1).compareTo(var2) : this.comparator.compare(var1, var2);
* }
*/
@Override
public int compareTo(Object o) {
return 0;
}
}
课后作业6
package com.he.homework;
import java.util.HashSet;
import java.util.Objects;
/**
* @author hejh7
* @date 2022/11/19 0019 18:48
* @describe
*/
@SuppressWarnings({"all"})
public class HomeWork06 {
public static void main(String[] args) {
HashSet hashSet = new HashSet();
Person1 p1 = new Person1(1001, "AA");
Person1 p2 = new Person1(1002, "BB");
hashSet.add(p1);
hashSet.add(p2);
System.out.println("hashSet=" + hashSet);
p1.setName("CC");
//删除的时候也会根据id和name找元素的位置 因为1001的name已经改变 所以找到的位置没有p1 删除失败
hashSet.remove(p1);
System.out.println("hashSet=" + hashSet);
hashSet.add(new Person1(1001,"CC"));
System.out.println("hashSet=" + hashSet);
hashSet.add(new Person1(1001,"AA"));
System.out.println("hashSet=" + hashSet);
}
}
class Person1{
private int id;
private String name;
public Person1(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Person1 person1 = (Person1) o;
return id == person1.id && Objects.equals(name, person1.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
@Override
public String toString() {
return "Person1{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}