一、集合的体系结构
1、单列集合(Collection)
二、Collection集合
1、Collection常见方法
1.1代码实现:
java
import java.util.ArrayList;
import java.util.Collection;
public class A01_CollectionDemo1 {
public static void main(String[] args) {
/*
public boolean add(E e) 添加
public void clear() 清空
public boolean remove(E e) 删除
public boolean contains(Object obj) 判断是否包含
public boolean isEmpty() 判断是否为空
public int size() 集合长度
注意点:
Collection是一个接口,我们不能直接创建他的对象。
所以,现在我们学习他的方法时,只能创建他实现类的对象。
实现类:ArrayList
*/
//目的:为了学习Collection接口里面的方法
//自己在做一些练习的时候,还是按照之前的方式去创建对象。
Collection<String> coll = new ArrayList<>();
//1.添加元素
//细节1:如果我们要往List系列集合中添加数据,那么方法永远返回true,因为List系列的是允许元素重复的。
//细节2:如果我们要往Set系列集合中添加数据,如果当前要添加元素不存在,方法返回true,表示添加成功。
// 如果当前要添加的元素已经存在,方法返回false,表示添加失败。
// 因为Set系列的集合不允许重复。
coll.add("aaa");
coll.add("bbb");
coll.add("ccc");
System.out.println(coll);
//2.清空
//coll.clear();
//3.删除
//细节1:因为Collection里面定义的是共性的方法,所以此时不能通过索引进行删除。只能通过元素的对象进行删除。
//细节2:方法会有一个布尔类型的返回值,删除成功返回true,删除失败返回false
//如果要删除的元素不存在,就会删除失败。
System.out.println(coll.remove("aaa"));
System.out.println(coll);
//4.判断元素是否包含
//细节:底层是依赖equals方法进行判断是否存在的。
//所以,如果集合中存储的是自定义对象,也想通过contains方法来判断是否包含,那么在javabean类中,一定要重写equals方法。
boolean result1 = coll.contains("bbb");
System.out.println(result1);
//5.判断集合是否为空
boolean result2 = coll.isEmpty();
System.out.println(result2);//false
//6.获取集合的长度
coll.add("ddd");
int size = coll.size();
System.out.println(size);//3
}
}
1.2 contains方法重写equals方法示例:(idea可自动重写)
java
import java.util.ArrayList;
import java.util.Collection;
public class A02_CollectionDemo2 {
public static void main(String[] args) {
//1.创建集合的对象
Collection<Student> coll = new ArrayList<>();
//2.创建三个学生对象
Student s1 = new Student("zhangsan",23);
Student s2 = new Student("lisi",24);
Student s3 = new Student("wangwu",25);
//3.把学生对象添加到集合当中
coll.add(s1);
coll.add(s2);
coll.add(s3);
//4.判断集合中某一个学生对象是否包含
Student s4 = new Student("zhangsan",23);
//因为contains方法在底层依赖equals方法判断对象是否一致的。
//如果存的是自定义对象,没有重写equals方法,那么默认使用Object类中的equals方法进行判断,而Object类中equals方法,依赖地址值进行判断。
//需求:如果同姓名和同年龄,就认为是同一个学生。
//所以,需要在自定义的Javabean类中,重写equals方法就可以了。
System.out.println(coll.contains(s4));
}
}
重写
java
@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);
}
2、Collection的遍历方式(3种)
Collection的遍历的三种方式:
- 迭代器遍历
- 增强for循环
- Lambda表达式
2.1迭代器遍历
迭代器不依赖索引
循环遍历:
java
//2.获取迭代器对象
//迭代器就好比是一个箭头,默认指向集合的0索引处
Iterator<String> it = coll.iterator();
//3.利用循环不断的去获取集合中的每一个元素
while(it.hasNext()){
//4.next方法的两件事情:获取元素并移动指针
String str = it.next();
System.out.println(str);
}
示例代码:(不依赖索引,而是通过指针移动的方式)
java
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class A03_CollectionDemo3 {
public static void main(String[] args) {
/*
Collection系列集合三种通用的遍历方式:
1.迭代器遍历
2.增强for遍历
3.lambda表达式遍历
迭代器遍历相关的三个方法:
Iterator<E> iterator() :获取一个迭代器对象
boolean hasNext() :判断当前指向的位置是否有元素
E next() :获取当前指向的元素并移动指针
*/
//1.创建集合并添加元素
Collection<String> coll = new ArrayList<>();
coll.add("aaa");
coll.add("bbb");
coll.add("ccc");
coll.add("ddd");
//2.获取迭代器对象
//迭代器就好比是一个箭头,默认指向集合的0索引处
Iterator<String> it = coll.iterator();
//3.利用循环不断的去获取集合中的每一个元素
while(it.hasNext()){
//4.next方法的两件事情:获取元素并移动指针
String str = it.next();
System.out.println(str);
}
}
}
迭代器书写的小细节:
迭代器细节注意点:
java
迭代器的细节注意点:
1.报错NoSuchElementException
2.迭代器遍历完毕,指针不会复位
3.循环中只能用一次next方法
4.迭代器遍历时,不能用集合的方法进行增加或者删除
暂时当做一个结论先行记忆,在今天我们会讲解源码详细的再来分析。
如果我实在要删除:那么可以用迭代器提供的remove方法进行删除。
如果我要添加,暂时没有办法。
java
//当上面循环结束之后,迭代器的指针已经指向了最后没有元素的位置
//System.out.println(it.next());//NoSuchElementException
//迭代器遍历完毕,指针不会复位
System.out.println(it.hasNext());
//如果我们要继续第二次遍历集合,只能再次获取一个新的迭代器对象
Iterator<String> it2 = coll.iterator();
while(it2.hasNext()){
String str = it2.next();
System.out.println(str);
}
java
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class A05_CollectionDemo5 {
public static void main(String[] args) {
//1.创建集合并添加元素
Collection<String> coll = new ArrayList<>();
coll.add("aaa");
coll.add("bbb");
coll.add("ccc");
coll.add("ddd");
coll.add("eee");
//2.获取迭代器对象
//迭代器就好比是一个箭头,默认指向集合的0索引处
Iterator<String> it = coll.iterator();
//3.利用循环不断的去获取集合中的每一个元素
while(it.hasNext()){
//4.next方法的两件事情:获取元素,并移动指针
String str = it.next();
if("bbb".equals(str)){
//coll.remove("bbb");
it.remove();
}
}
System.out.println(coll);
}
}
小结:
Interator方法:
2.2增强for循环
示例代码:
java
import java.util.ArrayList;
import java.util.Collection;
public class A06_CollectionDemo6 {
public static void main(String[] args) {
/* Collection系列集合三种通用的遍历方式:
1.迭代器遍历
2.增强for遍历
3.lambda表达式遍历
增强for格式:
for(数据类型 变量名: 集合/数组){
}
快速生成方式:
集合的名字 + for 回车
*/
//1.创建集合并添加元素
Collection<String> coll = new ArrayList<>();
coll.add("zhangsan");
coll.add("lisi");
coll.add("wangwu");
//2.利用增强for进行遍历
//注意点:
//s其实就是一个第三方变量,在循环的过程中依次表示集合中的每一个数据
for(String s : coll){
s = "qqq";
}
System.out.println(coll);//zhangsan lisi wangwu
}
}
2.3Lambda表达式遍历
示例代码:
java
//1.创建集合并添加元素
Collection<String> coll = new ArrayList<>();
coll.add("zhangsan");
coll.add("lisi");
coll.add("wangwu");
//2.利用匿名内部类的形式
//底层原理:
//其实也会自己遍历集合,依次得到每一个元素
//把得到的每一个元素,传递给下面的accept方法
//s依次表示集合中的每一个数据
/* coll.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});*/
//lambda表达式
coll.forEach(s -> System.out.println(s));
3、小结
三、List集合
1、List集合特有的方法(操作索引的4个方法)
示例代码:
java
import java.util.ArrayList;
import java.util.List;
public class A01_ListDemo1 {
public static void main(String[] args) {
/*
List系列集合独有的方法:
void add(int index,E element) 在此集合中的指定位置插入指定的元素
E remove(int index) 删除指定索引处的元素,返回被删除的元素
E set(int index,E element) 修改指定索引处的元素,返回被修改的元素
E get(int index) 返回指定索引处的元素
*/
//1.创建一个集合
List<String> list = new ArrayList<>();
//2.添加元素
list.add("aaa");
list.add("bbb");//1
list.add("ccc");
//void add(int index,E element) 在此集合中的指定位置插入指定的元素
//细节:原来索引上的元素会依次往后移
//list.add(1,"QQQ");
//E remove(int index) 删除指定索引处的元素,返回被删除的元素
//String remove = list.remove(0);
//System.out.println(remove);//aaa
//E set(int index,E element) 修改指定索引处的元素,返回被修改的元素
//String result = list.set(0, "QQQ");
//System.out.println(result);
// E get(int index) 返回指定索引处的元素
//String s = list.get(0);
//System.out.println(s);
//3.打印集合
System.out.println(list);
}
}
add方法:
java
//1.创建一个集合
List<String> list = new ArrayList<>();
//2.添加元素
list.add("aaa");
list.add("bbb");//1
list.add("ccc");
//void add(int index,E element) 在此集合中的指定位置插入指定的元素
//细节:原来索引上的元素会依次往后移
list.add(1,"QQQ");
remove方法:
java
E remove(int index) //删除指定索引处的元素,返回被删除的元素
String remove = list.remove(0);
System.out.println(remove);//aaa
List删除的小细节:
java
//List系列集合中的两个删除的方法
//1.直接删除元素
//2.通过索引进行删除
//1.创建集合并添加元素
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
//2.删除元素
//请问:此时删除的是1这个元素,还是1索引上的元素?
//为什么?
//因为在调用方法的时候,如果方法出现了重载现象
//优先调用,实参跟形参类型一致的那个方法。
//list.remove(1);
//手动装箱,手动把基本数据类型的1,变成Integer类型
Integer i = Integer.valueOf(1);
list.remove(i);
System.out.println(list);
set & get方法:
java
//E set(int index,E element) 修改指定索引处的元素,返回被修改的元素
//String result = list.set(0, "QQQ");
//System.out.println(result);
// E get(int index) 返回指定索引处的元素
//String s = list.get(0);
//System.out.println(s);
2、List集合的遍历方式(5种)
- 迭代器遍历
- 列表迭代器遍历
- 增强for遍历
- Lambda表达式遍历
- 普通for循环(因为List集合存在索引)
2.1迭代器遍历:
java
/*
List系列集合的五种遍历方式:
1.迭代器
2.列表迭代器
3.增强for
4.Lambda表达式
5.普通for循环
*/
//创建集合并添加元素
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
//1.迭代器
Iterator<String> it = list.iterator();
while(it.hasNext()){
String str = it.next();
System.out.println(str);
}
2.2增强for:
java
//2.增强for
//下面的变量s,其实就是一个第三方的变量而已。
//在循环的过程中,依次表示集合中的每一个元素
for (String s : list) {
System.out.println(s);
}
2.3Lambda表达式
java
//3.Lambda表达式
//forEach方法的底层其实就是一个循环遍历,依次得到集合中的每一个元素
//并把每一个元素传递给下面的accept方法
//accept方法的形参s,依次表示集合中的每一个元素
list.forEach(s->System.out.println(s) );
2.4普通for循环
java
//4.普通for循环
//size方法跟get方法还有循环结合的方式,利用索引获取到集合中的每一个元素
for (int i = 0; i < list.size(); i++) {
//i:依次表示集合中的每一个索引
String s = list.get(i);
System.out.println(s);
}
2.5列表迭代器(ListIterator,继承于Iterator)
java
// 5.列表迭代器
//获取一个列表迭代器的对象,里面的指针默认也是指向0索引的
//额外添加了一个方法:在遍历的过程中,可以添加元素
ListIterator<String> it = list.listIterator();
while(it.hasNext()){
String str = it.next();
if("bbb".equals(str)){
//qqq
it.add("qqq");
}
}
但迭代器默认指向0索引,想要使用previous方法需要先移动到后面
小结
四、数据结构(常见有8种)
1、什么是数据结构呢?
数据结构就是计算机存储、组织数据的方式
不同的业务场景要选择不同的数据结构
2、数据结构概述
常见的数据结构:
栈、队列、数组、链表、二叉树、二叉树查找
3、栈(后进先出,先进后出)
4、队列(先进先出,后进后出)
- 数据从后端进入队列模型的过程称为:入队列
- 数据从前端离开队列模型的过程称为:出队列
5、栈与队列小结
6、数组
7、链表(与数组相对)
双向链表可以提高查询效率:
小结
五、ArrayList原码分析
1、ArrayList集合底层原理
2、ArrayList源码分析
idea快捷键:Alt + 7:列出方法大纲
添加的数据长度不超过10:
一次添加多个,超过10,但不超过15:
六、LinkedList集合
1、LinkedList特有方法
2、LinkedList源码分析
3、迭代器源码分析
modCount:集合变化的次数
expectedModCount:创建对象时,传递过来的次数
结论:
在以后如何避免并发修改异常
在使用迭代器或者是增强for遍历集合的过程中,不要使用集合的方法去添加
或者删除元素即可