集合框架-day01
今日学习内容：
- 模拟ArrayList
- 常见的数据结构
- 集合框架体系
- List接口和实现类
- 泛型
今日学习目标：
- 了解什么是数据结构
- 掌握模拟ArrayList
- 了解常见的数据结构和其特点
- 掌握集合框架体系结构
- 掌握List接口存储特点
- 掌握ArrayList类常用方法
- 了解泛型的定义和作用
- 掌握使用集合时使用泛型来约束元素类型
26. 数据结构概述
Java的集合框架其实就是对数据结构的封装，在学习集合框架之前，有必要先了解下数据结构。
26.1. 什么是数据结构（了解）
所谓数据结构，其实就是计算机存储、组织数据的方式。
数据结构是用来模拟数据存储操作的，其实就是对数据做增删改查操作。
-
增：把某个数据存储到某个容器中
-
删：从容器中把某个数据删除掉
-
改：把容器中某个数据替换成另一个数据
-
查：把容器中的数据查询出来
不同的数据结构，底层采用不同的存储方式（算法），在具体操作的时候效率是不一样的，比如有的查询速度很快，有的插入速度很快，有的操作头和尾速度很快等。
常见的数据结构：
- 数组（Array） 掌握
- 链表（Linked List） 了解
- 哈希表（Hash） 了解
- 栈（Stack） 了解
- 队列（Queue） 了解
- 树（Tree） 了解
- 图（Graph）
- 堆（Heap）
26.2. 数组结构
26.2.1. 模拟ArrayList（掌握）
假设我现在是某个篮球队的教练，需要安排5个球员上场打球。此时需要模拟上场球员的存储，简单一点，我们就只存储上场球员的球衣号码。那么此时我需要以下几个操作：
1．初始一个容量为5的容器，用来存储场上的5个球衣号码。
2．安排5个球员上场，比如球员号码分别为11、22、33、44、55。
3．查询指定索引位置球员的球衣号码是多少，如查询索引位置为2的球衣号码是33。
4．替换场上索引位置为2的球员，使用333号替换33号。
5．罚下场上索引位置为2的球员（直接罚下，没有补位）。
6．打印出场上球员的球衣号码，打印风格如 [11，22，33，44，55]。
操作前后效果图：
26.2.2. 初始化操作（掌握）
使用Integer数组来存储场上球员号码，提供了两个构造器，一个用于自定义初始化容量，一个用于使用默认的初始化容量10。
public class PlayerList {
//存储场上球员号码
private Integer[] players;
//存储场上球员数量
private int size;
//自定义初始容量
public PlayerList(int initialCapacity) {
if (initialCapacity < 0) {
throw new RuntimeException("初始容量不能为负数");
}
this.players = new Integer[initialCapacity];
}
//默认初始容量为10
public PlayerList() {
this(10);
}
}
测试代码：
public class App {
public static void main(String[] args) {
//初始容量为默认的10
PlayerList list1 = new PlayerList();
//自定义初始化容量为5
PlayerList list2 = new PlayerList(5);
//自定义初始化容量为20
PlayerList list3 = new PlayerList(20);
}
}
26.2.3. 打印操作（掌握）
public String toString() {
if (players == null) {//如果没有初始化容器
return "null";
}
if (size == 0) {//如果容器中球员数量为0
return "[]";
}
StringBuilder sb = new StringBuilder(40);
sb.append("[");
for (int index = 0; index < size; index++) {
sb.append(players[index]);
//如果不是最后一个
if (index != size - 1) {
sb.append(",");
} else {//如果是最后一个
sb.append("]");
}
}
return sb.toString();
}
26.2.4. 保存操作（掌握）
//向场上添加一个球员号码
public void add(Integer playerNumber) {
this.players[size] = playerNumber;//保存球衣号码
size++;//场上球员数量加1
}
测试代码
public class App {
public static void main(String[] args) {
//初始化容器,设置初始化容量为5
PlayerList list = new PlayerList(5);
System.out.println(list);
//向容器中添加5个元素（球员号码）
list.add(11);
list.add(22);
list.add(33);
list.add(44);
list.add(55);
//打印容器中每一个元素
System.out.println(list);
}
}
输出结果：
[]
[11,22,33,44,55]
因为数组的长度是固定的，此时的players数组只能存储5个元素，如果再多存储一个就报错：数组索引越界。此时就要考虑在保存操作时对数组做扩容操作，扩容的原理是：
- 创建一个原数组长度两倍长的新数组
- 把旧数组中的所有元素拷贝到新数组中
- 把新数组的引用赋给旧数组变量
保存操作时扩容操作：
//向场上添加一个球员号码
public void add(Integer playerNumber) {
//如果容器容量已满,此时需要扩容，此时扩容机制为原来容量的2倍
if (size == players.length) {
this.players = Arrays.copyOf(players, size * 2);
}
//-----------------------------------------
this.players[size] = playerNumber;//保存球衣号码
size++;//场上球员数量加1
}
26.2.5. 查询操作（掌握）
需求：查询指定索引位置球员的球衣号码是多少，如查询索引位置为2的球衣号码是33。
其实就是返回数组中，指定索引对应的元素值。
public Integer get(int index) {
if (index < 0 || index >= size) {
throw new RuntimeException("索引越界");
}
return players[index];
}
测试代码：
Integer playerNum = list.get(2);
System.out.println(playerNum);
输出结果：
33
26.2.6. 修改操作（掌握）
需求：替换场上索引位置为2的球员，使用333号替换33号。
//替换指定位置的球员号码
public void set(int index, Integer newPlayerNumber) {
if (index < 0 || index >= size) {
throw new RuntimeException("索引越界");
}
players[index] = newPlayerNumber;
}
26.2.7. 删除操作（掌握）
需求：罚下场上索引位置为2的球员（直接罚下，没有补位）。
删除操作的原理，把后续的元素整体往前挪动一个位置。
//删除指定位置的球员号码
public void remove(int index) {
if (index < 0 || index >= size) {
throw new RuntimeException("索引越界");
}
for (int i = index; i < size - 1; i++) {
players[i] = players[i + 1];
}
players[size - 1] = null;
size--;
}
26.2.8. 让容器支持存储任意数据类型的元素（掌握）
此时元素类型是Integer类型，也就是只能存储整型的数据，但是却不能存储其他类型的数据，此时我们可以考虑吧元素类型改成Object，那么Object数组可以存储任意类型的数据。
public class MyArrayList {
//存储元素
private Object[] elementData = null;
//存储元素数量
private int size = 0;
//自定义初始容量
public MyArrayList(int initialCapacity) {
if (initialCapacity < 0) {
throw new RuntimeException("初始容量不能为负数");
}
this.elementData = new Object[initialCapacity];
}
//默认初始容量为10
public MyArrayList() {
this(10);
}
//向容器中添加一个元素
public void add(Object playerNumber) {
//如果容器容量已满,此时需要扩容，此时扩容机制为原来容量的2倍
if (size == elementData.length) {
this.elementData = Arrays.copyOf(elementData, size * 2);
}
//-----------------------------------------
this.elementData[size] = playerNumber;//保存球衣号码
size++;//容器中元素数量加1
}
//查询指定位置的元素
public Object get(int index) {
if (index < 0 || index >= size) {
throw new RuntimeException("索引越界");
}
return elementData[index];
}
//替换指定索引位置的元素
public void set(int index, Object newPlayerNumber) {
if (index < 0 || index >= size) {
throw new RuntimeException("索引越界");
}
elementData[index] = newPlayerNumber;
}
//删除指定索引位置的元素
public void remove(int index) {
if (index < 0 || index >= size) {
throw new RuntimeException("索引越界");
}
for (int i = index; i < size - 1; i++) {
elementData[i] = elementData[i + 1];
}
elementData[size - 1] = null;
size--;
}
public String toString() {
if (elementData == null) {//如果没有初始化容器
return "null";
}
if (size == 0) {//如果容器中元素数量为0
return "[]";
}
StringBuilder sb = new StringBuilder(40);
sb.append("[");
for (int index = 0; index < size; index++) {
sb.append(elementData[index]);
//如果不是最后一个
if (index != size - 1) {
sb.append(",");
} else {//如果是最后一个
sb.append("]");
}
}
return sb.toString();
}
}
26.2.9. 数组的性能分析（了解）
在计算机科学中，算法的时间复杂度是一个函数，它定性描述了该算法的运行时间，常用大O符号来表述。
时间复杂度是同一问题可用不同算法解决，而一个算法的质量优劣将影响到算法乃至程序的效率。算法分析的目的在于选择合适算法和改进算法。
我们在这里针对ArrayList存储数据的增删改查（CRUD）做性能分析：
-
保存操作：
如果保存在数组的最后一个位置，至少需要操作一次。
如果保存在数组的第一个位置，如果存在N个元素，此时需要操作N次(后面的元素要整体后移)。
平均: (N+1) /2 次。 N表示数组中元素的个数。 如果要扩容，更慢，性能更低。
-
删除操作:
如果删除最后一个元素，操作一次。
如果删除第一个元素，操作N次。
平均：(N+1)/2次.
-
修改操作: 操作1次.
-
查询操作：根据索引查询元素: 操作1次.
结论：基于数组的数据结构做查询是和修改是非常快的，做保存和删除操作比较慢了。
那如果想保证保存和删除操作的性能，此时就得提提链表这种数据结构了。
26.3. 其他数据结构（了解）
26.3.1. 链表（了解）
链表结构（火车和火车车厢）：
1)：单向链表，只能从头遍历到尾/只能从尾遍历到头。
2)：双向链表，既可以从头遍历到尾,又可以从尾遍历到头。
通过引用来表示上一个节点和下一个节点的关系。
单向链表：
双向链表：
对LinekdList操作的性能分析：
双向链表可以直接获取自己的第一个和最后一个节点。
-
保存操作
如果新增的元素在第一个或最后一个位置，那么操作只有1次。
-
删除操作
如果删除第一个元素 ：操作一次
如果删除最后一个元素：操作一次
如果删除中间的元素：
找到元素节点平均操作：(1+N)/2次
找到节点之后做删除操作: 1次
-
修改操作
平均：(N+1)/2次
-
查询操作:
平均:(N+1)/2次
结论：
ArrayList： 查询、更改较快，新增和删除较慢。
LinkedList： 查询、更改较慢，新增和删除较快。
一般的，在开发中数据都是存储在数据库中，我们一般主要用来查询，所以ArrayList使用较多。
26.3.2. 队列（了解）
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。
进行插入操作的端称为队尾，进行删除操作的端称为队头。
单向队列(Queue)：先进先出(FIFO)，只能从队列尾插入数据，只能从队列头删除数据。
双向队列(Deque)：可以从队列尾/头插入数据，只能从队列头/尾删除数据。
结论：最擅长操作头和尾。
26.3.3. 栈（了解）
栈（stack）又名堆栈，它是一种运算受限的线性表，后进先出(LIFO)，和手枪弹夹类似。
栈结构仅允许在表的一端进行插入和删除运算，这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈中插入新元素又称作入栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素。从一个栈中删除元素又称作出栈，表示把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素（LIFO）。
26.3.4. 哈希表（了解）
一般的，数组中元素在数组中的索引位置是随机的，元素的取值和元素的位置之间不存在确定的对应关系。因此，在数组中查找特定的值时，需要把查找值和一系列的元素进行比较。
此时的查询效率依赖于查找过程中所进行的比较次数，如果比较次数较多，查询效率还是不高。
如果元素的值（value）和在数组中的索引位置（index）有一个确定的对应关系，我们把这种关系称之为哈希（hash）。则元素值和索引对应的公式为: index = hash(value)。也就是说，通过给定元素值，只要调用hash(value)方法，就能找到数组中取值为value的元素的位置。
比如，图中的hash算法公式为：index = value / 10 - 1。
在往哈希表中存储对象时，该hash算法就是对象的hashCode方法。
注：这里仅仅是假设算法公式是这样的，真实的算法公式我们可以不关心。
26.3.5. 树和二叉树（了解）
前面我们介绍的数据结构数组、栈、队列，链表都是线性数据结构，除此之外还有一种比较复杂的数据结构——树。
计算机中的树，是根据生活中的树抽象而来的，表示N个有父子关系的节点的集合。
-
N为0的时候，该节点集合为空，这棵树就是空树
-
任何非空树中，有且只有一个根节点（root）
-
N>1时，一颗树由根和若干棵子树组成，每棵子树由更小的若干子树组成
树中的节点根据有没有子节点，分成两种：
-
普通节点：拥有子节点的节点。
-
叶子节点：没有字节点的节点。
二叉树：一种特殊的，遵循某种规则的树。
树的结构因为存在多种子节点情况，真的太复杂了，如果我们对普通的树加上一些约束，比如让每一棵树的节点最多只能包含两个子节点，而且严格区分左子节点和右子节点（左右位置不能交换），此时就形成了二叉树。
排序二叉树，有顺序的树：
- 若左子树不为空，则左子树所有节点的值小于根节点的值。
- 若右子树不为空，则右子树所有节点的值大于根节点的值。
- 左右子树也分别是排序二叉树。
红黑树：更高查询效率的的排序二叉树。
排序二叉树可以快速查找，但是如果只有左节点或者左右右节点的时候，此时二叉树就变成了普通的链表结构，查询效率比较低。为此一种更高效的二叉树出现了——红黑树。
- 每个节点要么是红色的，要么是黑色的。
- 根节点永远是黑色的。
- 所有叶子节点都是空节点（null），是黑色的。
- 每个红色节点的两个子节点都是黑色的。
- 从任何一个节点到其子树每个叶子节点的路径都包含相同数量的黑色节点。
27. 集合框架体系
集合是Java中提供的一种容器，可以用来存储多个数据，根据不同存储方式形成的体系结构，就叫做集合框架体系（掌握）。
每一种容器类底层拥有不同的底层算法。
既然数组可以存储多个数据，为什么要出现集合？-
- 数组的长度是固定的，集合的长度是可变的。
- 使用Java类封装出一个个容器类，开发者只需要直接调用即可，不用再手动创建容器类。
集合中存储的数据，叫做元素，元素只能是对象（引用类型）。
27.1. 容器的分类（掌握）
根据容器的存储特点的不同，可以分成三种情况：
- List(列表)：允许记录添加顺序，允许元素重复。
- Set(集合)：不记录添加顺序，不允许元素重复。
- Map(映射)：容器中每一个元素都包含一对key和value，key不允许重复，value可以重复。严格上说，并不是容器（集合），是两个容器中元素映射关系。
注意：List和Set接口继承于Collection接口，Map接口不继承Collection接口。
- Collection接口：泛指广义上集合，主要表示List和Set两种存储方式。
- List接口：表示列表，规定了允许记录添加顺序，允许元素重复的规范。
- Set接口：表示狭义上集合，规定了不记录添加顺序，不允许元素重复的规范。
- Map接口：表示映射关系，规定了两个集合映射关系的规范。
注意：我们使用的容器接口或类都处于java.util包中。
27.2.List接口（重点）
List接口是Collection接口子接口，List接口定义了一种规范，要求该容器允许记录元素的添加顺序，也允许元素重复。那么List接口的实现类都会遵循这一种规范。
List集合存储特点：
- 允许元素重复
- 允许记录元素的添加先后顺序
该接口常用的实现类有：
- ArrayList类：数组列表，表示数组结构，采用数组实现，开发中使用对多的实现类，重点。
- LinkedList类：链表，表示双向列表和双向队列结构，采用链表实现，使用不多。
- Stack类：栈，表示栈结构，采用数组实现，使用不多。
- Vector类：向量，其实就是古老的ArrayList，采用数组实现，使用不多。
27.2.1. List常用API方法（必须记住）
添加操作
- boolean add(Object e)：将元素添加到列表的末尾
- void add(int index, Object element)：在列表的指定位置插入指定的元素
- boolean addAll(Collection c)：把c列表中的所有元素添加到当前列表中
删除操作
- Object remove(int index)：从列表中删除指定索引位置的元素,并返回被删除的元素
- boolean removeAll(Collection c)：从此列表中移除c列表中的所有元素
修改操作
- Object set(int index, Object ele)：修改列表中指定索引位置的元素，返回被替换的旧元素
查询操作
- int size()：返回当前列表中元素个数
- boolean isEmpty()：判断当前列表中元素个数是否为0
- Object get(int index)：查询列表中指定索引位置对应的元素
- Object[] toArray()：把列表对象转换为Object数组
- boolean contains(Object o):判断列表是否存在指定对象
注意，标红的是经常使用的方法。
27.2.2.ArrayList类（重点）
ArrayList类，基于数组算法的列表，通过查看源代码会发现底层其实就是一个Object数组。
需求1：操作List接口常用方法
public class ArrayListDemo1 {
public static void main(String[] args) {
//创建一个默认长度的列表对象
List list = new ArrayList();
//打印集合中元素的个数
System.out.println("元素数量："+list.size());//0
//添加操作：向列表中添加4个元素
list.add("Will");
list.add(100);
list.add(true);
list.add("Lucy");
//查询操作:
System.out.println("列表中所有元素："+list);//输出:[Will, 100, true, Lucy]
System.out.println("元素数量："+list.size());//4
System.out.println("第一个元素："+list.get(0));//Will
//修改操作：把索引为2的元素，替换为wolfcode
list.set(2, "wolfcode");
System.out.println("修改后："+list);//输出:[Will, 100, wolfcode, Lucy]
//删除操作：删除索引为1的元素
list.remove(1);
System.out.println("删除后："+list);//输出:[Will, wolfcode, Lucy]
}
}
需求2：创建四个User对象，存储在List中，分析内存图。
public class User {
private String name;
private int age;
//省略两个参数构造器、getter/setter方法、toString方法
}
public class ArrayListDemo2 {
public static void main(String[] args) {
List girls = new ArrayList();
User u1 = new User("西施", 18);
girls.add(u1);
girls.add(new User("王昭君",19));
girls.add(new User("貂蝉",20));
girls.add(new User("杨玉环",21));
System.out.println(girls);
//修改u1对象的名字和年龄
u1.setName("小施");
u1.setAge(17);
System.out.println(girls);
}
}
运行结果（观察变化）：
[User [name=西施, age=18], User [name=王昭君, age=19], User [name=貂蝉, age=20], User [name=杨玉环, age=21]]
[User [name=小施, age=17], User [name=王昭君, age=19], User [name=貂蝉, age=20], User [name=杨玉环, age=21]]
内存分析，解释原因：
结论：集合类中存储的对象,都存储的是对象的引用,而不是对象本身。
27.2.3.LinkedList类（了解）
ArrayList类，基于数组算法的列表，通过查看源代码会发现底层其实就是一个Object数组。
LinkedList类，底层采用链表算法，实现了链表，队列，栈的数据结构。无论是链表还是队列主要操作的都是头和尾的元素，因此在LinkedList类中除了List接口的方法，还有很多操作头尾的方法。
- void addFirst(Object e) 将指定元素插入此列表的开头。
- void addLast(Object e) 将指定元素添加到此列表的结尾。
- Object getFirst() 返回此列表的第一个元素。
- Object getLast() 返回此列表的最后一个元素。
- Object removeFirst() 移除并返回此列表的第一个元素。
- Object removeLast() 移除并返回此列表的最后一个元素。
- boolean offerFirst(Object e) 在此列表的开头插入指定的元素。
- boolean offerLast(Object e) 在此列表末尾插入指定的元素。
- Object peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
- Object peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
- Object pollFirst() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
- Object pollLast() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
- void push(Object e) 将元素推入此列表所表示的栈。
- Object pop() 从此列表所表示的栈处弹出一个元素。
- Object peek() 获取但不移除此列表的头（第一个元素）。
LinkedList之所以有这么多方法，是因为自身实现了多种数据结构，而不同的数据结构的操作方法名称不同，在开发中LinkedList使用不是很多，知道存储特点就可以了。
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList list = new LinkedList();
//添加元素
list.addFirst("A");
list.addFirst("B");
System.out.println(list);
list.addFirst("C");
System.out.println(list);
list.addLast("D");
System.out.println(list);
//获取元素
System.out.println("获取第一个元素：" + list.getFirst());//C
System.out.println("获取最后一个元素：" + list.getLast());//D
//删除元素
list.removeFirst();
System.out.println("删除第一个元素后：" + list);//[B, A, D]
list.removeLast();
System.out.println("删除最后一个元素后：" + list);//[B, A]
}
}
程序运行结果：
[B, A]
[C, B, A]
[C, B, A, D]
获取第一个元素：C
获取最后一个元素：D
删除第一个元素后：[B, A, D]
删除最后一个元素后：[B, A]
27.2.4.Stack和Vector类（了解）
Vector类：基于数组算法实现的列表，其实就是ArrayList类的前身。和ArrayList的区别在于方法使用synchronized修饰，所以相对于ArrayList来说，线程安全，但是效率就低了点。
Stack类：表示栈，是Vector类的子类，具有后进先出(LIFO)的特点，拥有push（入栈），pop（出栈）方法。
27.3. 泛型（会用即可）
27.3.1. 什么是泛型（了解）
其实就是一种类型参数，主要用于某个类或接口中数据类型不确定时，可以使用一个标识符来表示未知的数据类型，然后在使用该类或方法时指定该未知类型的真实类型。
泛型可用到的接口、类、方法中，将数据类型作为参数传递，其实更像是一个数据类型模板。
如果不使用泛型，从容器中获取出元素，需要做类型强转，也不能限制容器只能存储相同类型的元素。
List list = new ArrayList();
list.add("A");
list.add("B");
String ele = (String) list.get(0);
27.4. 自定义和使用泛型（了解）
定义泛型：使用一个标识符，比如T在类中表示一种未知的数据类型。
使用泛型：一般在创建对象时，给未知的类型设置一个具体的类型，当没有指定泛型时，默认类型为Object类型。
需求：定义一个类Point，x和y表示横纵坐标，分别使用String、Integer、Double表示坐标类型。
如果没有泛型需要设计三个类，如下：
定义泛型：
//在类上声明使用符号T,表示未知的类型
//在类上声明使用符号T,表示未知的类型
public class Point<T> {
private T x;
private T y;
//省略getter/setter
}
使用泛型：
//没有使用泛型，默认类型是Object
Point p1 = new Point();
Object x1 = p1.getX();
//使用String作为泛型类型
Point<String> p2 = new Point<String>();
String x2 = p2.getX();
//使用Integer作为泛型类型
Point<Integer> p3 = new Point<Integer>();
Integer x3 = p3.getX();
画图分析：
注意：这里仅仅是演示泛型类是怎么回事，并不是要求定义类都要使用泛型。
27.5. 在集合框架中使用泛型（掌握）
拿List接口和ArrayList类举例。
class ArrayList<E>{
public boolean add(E e){ }
public E get(int index){ }
}
此时的E也仅仅是一个占位符，表示元素（Element）的类型，那么当使用容器时给出泛型就表示该容器只能存储某种类型的数据。
//只能存储String类型的集合
List<String> list1 = new ArrayList<String>();
list1.add("A");
list1.add("B");
//只能存储Integer类型的集合
List<Integer> list2 = new ArrayList<Integer>();
list2.add(11);
list2.add(22);
因为前后两个泛型类型相同（也必须相同），泛型类型推断：
List<String> list1 = new ArrayList<String>();
可以简写为
List<String> list1 = new ArrayList<>();
通过反编译工具，会发现泛型其实是语法糖，也就是说编译之后，泛型就不存在了。
注意：泛型必须是引用类型，不能是基本数据类型（错误如下）：
List<int> list = new ArrayList<int>();//编译错误
泛型不存在继承的关系（错误如下）：
List<Object> list = new ArrayList<String>(); //错误的
学习优势：
1.包含java前后端从 0 ->1 全过程教学, 内容全面, 知识点不遗漏, 学完即可参加实际工作.
2.课程为目前项目开发常用的技术知识，向用人单位对标，学以致用。那些脱离实际，废弃不用的，太前沿的框架技术前期不建议学。
3.一起学习,打卡,一起交流,希望能营造一个和线下一样的学习环境。
需要进微信学习交流群, 或者想领取代码,文档,全套视频的同学请+v：lmm99964
扫一扫
152
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
