本文深入探讨了Java集合框架，包括引用数据类型、面向对象的概念及其应用、以及Collection接口和ArrayList、LinkedList的使用方法。重点讲解了迭代器的使用、并发修改异常以及List和Map的嵌套操作。此外，还介绍了HashMap的哈希表结构和存储过程，包括无参数和有参数构造方法的分析，以及resize方法和扩容机制。最后，详细阐述了元素存储的索引确定和处理重复哈希值的对象策略。
```java
引用数据类型:
类 数组 接口 枚举 注解
Scanner Random 数组 Date SimpleDateFormat String StringBuilder等
想使用,先new new完了就可以点 如果new不出来,一般都是类名直接调用
Arrays
面向对象:
1.什么是面向对象:
万物皆对象,我们自己的事儿,找对象去做
2.为什么要使用面向对象:懒
洗衣服->洗衣机
大学带饭
就是为了干点事方便,我们直接找一个对象,调用对象身上的功能,帮我们去做事
3.什么时候使用面向对象:
当在一个类中想使用其他类的成员时,就需要面向对象思想了
4.怎么使用面向对象:
new呀 点呀
今日重点:
1.会使用Collection接口中的方法
2.会使用ArrayList和LinkedList中的方法以及遍历
3.会使用迭代器去遍历集合
4.会使用增强for遍历集合
```
# 第一章.集合框架(单列集合)
```java
1.数组特点:
a.既可以存储基本类型,还可以存储引用类型
b.定长
2.集合:容器
3.集合作用:存储数据
4.集合特点:
a.只能存储引用数据类型
b.长度可变
c.集合有很多强大的方法类直接操作元素
```
```java
1.集合分两大类:
a.单列集合:集合中的元素单独存储
list.add("三上");
list.add("松下");
b.双列集合:集合中的元素都是成对(键值对 key,value的形式)
map.put("涛哥","柳岩") 前面的是key,后面的是value
```
# 第二章.Collection接口
```java
1.概述:单列集合的顶级接口
2.特点:
a.元素有序
b.元素可重复
c.无索引(没有用过索引操作元素的方法)
3.使用:
a.创建对象:Collection<E> 集合名 = new 实现类对象<E>()
<E>:泛型 -> 泛型必须是引用数据类型 ; 泛型是为了明确集合中要存储什么类型的元素
如果不确定泛型,集合元素默认类型为Object
比如: Collection<String> coll = new 实现类对象<String>()
Collection<Integer> coll = new 实现类对象<Integer>()
注意:等号右边的<>中不用写
Collection<Integer> coll = new 实现类对象<>()
4.常用方法:
boolean add(E e) : 将给定的元素添加到当前集合中(我们一般调add时,不用boolean接收,因为add一定会成功)
boolean addAll(Collection<? extends E> c) :将另一个集合元素添加到当前集合中 (集合合并)
void clear():清除集合中所有的元素
boolean contains(Object o) :判断当前集合中是否包含指定的元素
boolean isEmpty() : 判断当前集合中是否有元素->判断集合是否为空
boolean remove(Object o):将指定的元素从集合中删除
int size() :返回集合中的元素数。
Object[] toArray(): 把集合中的元素,存储到数组中
```
```java
public class Test01_Collection {
public static void main(String[] args) {
//创建Collection集合
Collection<String> collection = new ArrayList<>();
//boolean add(E e) : 将给定的元素添加到当前集合中(我们一般调add时,不用boolean接收,因为add一定会成功)
collection.add("刘备");
collection.add("宋江");
collection.add("赵云");
collection.add("关羽");
collection.add("张飞");
collection.add("柳岩");
System.out.println(collection);
//boolean addAll(Collection<? extends E> c) :将另一个集合元素添加到当前集合中 (集合合并)
Collection<String> collection1 = new ArrayList<>();
collection1.add("释迦牟尼佛");
collection1.add("斗战胜佛");
collection1.add("旃檀功德佛");
collection1.add("阿弥陀佛");
collection1.add("南无大圣舍利尊王佛");
collection.addAll(collection1);
System.out.println(collection);
//void clear():清除集合中所有的元素
Collection<String> collection2 = new ArrayList<>();
collection2.add("樱桃小丸子");
collection2.add("铁臂阿童木");
collection2.add("熊出没");
collection2.add("百变小樱魔术卡");
System.out.println("collection2 = " + collection2);
//collection2.clear();
//System.out.println("collection2 = " + collection2);
//boolean isEmpty() : 判断当前集合中是否有元素->判断集合是否为空
boolean empty = collection2.isEmpty();
System.out.println("empty = " + empty);
//boolean contains(Object o) :判断当前集合中是否包含指定的元素
System.out.println(collection2.contains("熊出没"));
//boolean remove(Object o):将指定的元素从集合中删除
//System.out.println(collection2.remove("熊出没"));
//System.out.println(collection2);
//int size() :返回集合中的元素数。
System.out.println(collection2.size());
//Object[] toArray(): 把集合中的元素,存储到数组中
Object[] array = collection2.toArray();
//遍历数组
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
```
# 第三章.迭代器
## 1.迭代器基本使用
```java
1.概述:迭代器是一个接口 -> Iterator
2.获取:
Collection中的方法:Iterator<E> iterator() -> 凡是Collection以及实现类都可以用此方法获取迭代器对象
3.方法:
boolean hasNext() -> 判断有没有下一个元素
E next() -> 获取下一个元素
```
```java
public class Test01_Iterator {
public static void main(String[] args) {
//创建ArrayList对象
ArrayList<String> list = new ArrayList<>();
list.add("柳岩");
list.add("三上");
list.add("松下");
list.add("大乔");
list.add("涛哥");
//获取迭代器对象
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
String element = iterator.next();
System.out.println(element);
}
}
}
```
> 经验:使用迭代器的时候尽量不要连续调用多次next()
>
> ```java
> public class Test02_Iterator {
> public static void main(String[] args) {
> //创建ArrayList对象
> ArrayList<String> list = new ArrayList<>();
> list.add("柳岩");
> list.add("三上");
> list.add("松下");
> list.add("大乔");
> list.add("涛哥");
>
> //获取迭代器对象
> Iterator<String> iterator = list.iterator();
> while(iterator.hasNext()){
> System.out.println(iterator.next());
> //System.out.println(iterator.next());
> }
> }
> }
> ```
>
> <img src="img/image-20220325105056462.png" alt="image-20220325105056462" style="zoom:80%;" />
## 2.迭代器迭代原理
## 3.迭代器底层原理
```java
1.Iterator<String> iterator = list.iterator();
等号左边是Iterator接口,那么咱们也没有new Iterator的实现类对象,那么Iterator接口接收的是谁呢?是哪个实现类对象呢?
2.大家记住一点:
只要是等号左边是接口类型或者抽象类类型,等号右边又没有直接new对象,那么等号左边是接口类型或者抽象类类型也肯定指向了某一个实现类或者子类,一般都是通过源码来看
```
> 1.注意:Iterator指向ArrayList内部类Itr,这种情况,仅仅局限于迭代的是ArrayList集合
>
> 2.如果迭代HashSet集合,Iterator指向的实现类就不是Itr了,那么是谁呢?
>
> 
## 4.并发修改异常
```java
1.需求:定义集合,存储"孙悟空","唐僧","猪八戒","沙和尚",遍历集合,在遍历的过程中,如果获取出来的是"猪八戒",就直接在集合中添加"白龙马"
```
```java
public class Test04_Iterator {
public static void main(String[] args) {
/*
1.需求:定义集合,存储"孙悟空","唐僧","猪八戒","沙和尚",遍历集合,
在遍历的过程中,如果获取出来的是"猪八戒",就直接在集合中添加"白龙马"
*/
//创建集合
ArrayList<String> list = new ArrayList<>();
list.add("孙悟空");
list.add("唐僧");
list.add("猪八戒");
list.add("沙和尚");
//迭代器
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
//获取集合元素
String element = iterator.next();
if ("猪八戒".equals(element)){
list.add("白龙马");
}
}
System.out.println(list);
}
}
```
```java
以上代码看似方方面面么有问题,但是一运行报错了:
Exception in thread "main" java.util.ConcurrentModificationException -> 并发修改异常
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
at java.util.ArrayList$Itr.next(ArrayList.java:859)
at com.atguigu.b_iterator.Test04_Iterator.main(Test04_Iterator.java:23)
结论:在使用迭代器的过程中,不要随便改变集合长度
```
```java
问题1:为什么上面的代码会出现并发修改异常呢?
========================================
Iterator<String> iterator = list.iterator();
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int lastRet = -1; // index of last element returned; -1 if no such
/*
expectedModCount:预期操作次数
modCount:实际操作次数
*/
int expectedModCount = modCount;
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
结论:当实际操作次数和预期操作次数不相等时,直接抛出"并发修改异常"
```
```java
问题2.我们做什么操作了,导致了modCount和expectedModCount不相等了呢?-> 调用了ArrayList中的add方法
====================================================================================
list.add("白龙马");
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++
}
```
```java
最总结论:当调用add的时候,只给modCount++了,然后expectedModCount并没有重新赋值,此时再调用next方法,next方法底层直接做了判
断,如果modCount和expectedModCount不等时,抛出并发修改异常
```
```java
public class Test04_Iterator {
public static void main(String[] args) {
/*
1.需求:定义集合,存储"孙悟空","唐僧","猪八戒","沙和尚",遍历集合,
在遍历的过程中,如果获取出来的是"猪八戒",就直接在集合中添加"白龙马"
*/
//创建集合
ArrayList<String> list = new ArrayList<>();
list.add("孙悟空");
list.add("唐僧");
list.add("猪八戒");
list.add("沙和尚");
//迭代器
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()){
//获取集合元素
/*
next底层判断了预期操作次数如果和实际操作次数不相等
抛"并发修改异常"
*/
String element = iterator.next();
if ("猪八戒".equals(element)){
/*
当调用add的时候,只给实际操作次数++
再次回头调用next方法的时候,并没有重新给预期操作次数赋值
导致了预期操作次数如果和实际操作次数不相等
*/
list.add("白龙马");
}
}
System.out.println(list);
}
}
```
> ```java
> 扩展:ListIterator迭代器(了解)
> 方法:ListIterator<E> listIterator()
> public class Test05_Iterator {
> public static void main(String[] args) {
> /*
> 1.需求:定义集合,存储"孙悟空","唐僧","猪八戒","沙和尚",遍历集合,
> 在遍历的过程中,如果获取出来的是"猪八戒",就直接在集合中添加"白龙马"
> */
> //创建集合
> ArrayList<String> list = new ArrayList<>();
> list.add("孙悟空");
> list.add("唐僧");
> list.add("猪八戒");
> list.add("沙和尚");
>
> //迭代器
> ListIterator<String> iterator = list.listIterator();
> while(iterator.hasNext()){
> //获取集合元素
> String element = iterator.next();
> if ("猪八戒".equals(element)){
> /*
> ListIterator中的add方法
> */
> iterator.add("白龙马");
> }
> }
>
> System.out.println(list);
> }
> }
>
>
> ```
# 第四章.数据结构
## 1.栈
```java
1.特点:
先进后出
2.好比:手枪压子弹
```
## 2.队列
```java
1.特点:先进先出
2.好比:排队
```
## 3.数组
```java
1.特点:
查询快(有索引)
增删慢(定长)
2.如果向往数组中添加一个元素,首先要创建一个新数组,将老数组的数据复制到新数组中,然后在最后添加新的元素
```
## 4.链表
```java
1.特点:
查询慢
增删快
2.分类:
单向链表
双向链表
```
### 4.1单向链表
```java
1.特点:
一个节点分成2部分
a.第一部分:数据域->存数据的地方
b.第二部分:指针域->下一个元素的地址
2.前面的节点记录后面节点的地址
但是后面节点的地址不记录前面节点的地址
3.如果集合底层数据结构为单向链表,集合元素是无序的
```
### 4.2双向链表
```java
1.特点:
一个节点分3部分
a.第一部分:指针域->上一个节点地址
b.第二部分:数据域->存的数据
c.第三部分:指针域->下一个节点地址
2.一个节点上,既记录下一个节点地址,也记录上一个节点地址
前面的记录后面的,后面的记录前面的节点
3.如果集合底层数据结构是双向链表,元素有序 -> 比如LinkedList LinkedHashSet LinkedHashMap
```
> 小结:
>
> 栈:先进后出
>
> 队列:先进先出
>
> 数组:查询快(索引) 增删慢(定长)
>
> 链表:查询慢,增删快
>
> 单向链表:元素无序
>
> 双向链表:元素有序
# 第五章.List接口
```java
1.概述:List接口 extends Collection接口
2.特点:
a.元素有序
b.元素可重复
c.有索引
3.数据结构:不同的实现类,数据结构不一样
```
# 第六章.List集合下的实现类
## 1.ArrayList集合
```java
1.概述:ArrayList是List接口的实现类
2.特点:
a.元素有序
b.元素可重复
c.有索引
3.数据结构:数组
4.使用:
ArrayList<泛型> 集合名 = new ArrayList<>()
5.常用方法:
boolean add(E e) -> 添加元素->往集合末尾添加
void add(int index, E element)->将元素添加到指定的索引位置上
boolean remove(Object o) -> 删除指定的元素
E remove(int index) -> 删除指定索引位置上的元素,返回的是被删除的元素
E set(int index, E element) -> 将指定索引位置上的元素,修改成后面的element元素
E get(int index) -> 获取指定索引位置上的元素
int size() -> 获取集合元素个数
```
### 1.ArrayList集合使用
```java
public class Test01_ArrayList {
public static void main(String[] args) {
//创建ArrayList集合
ArrayList<String> list = new ArrayList<>();
//boolean add(E e) -> 添加元素->往集合末尾添加
list.add("蜻蜓队长");
list.add("蝎子莱莱");
list.add("鲨鱼辣椒");
list.add("蟑螂恶霸");
list.add("卡布达");
System.out.println(list);
//void add(int index, E element)->将元素添加到指定的索引位置上
list.add(2,"呱呱蛙");
System.out.println(list);
System.out.println("===============================");
//boolean remove(Object o) -> 删除指定的元素
//System.out.println(list.remove(&#
最低0.47元/天 解锁文章
5518
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
