1、什么是数据结构?
◼ 数据结构是计算机存储、组织数据的方式
线性结构：线性表 (数组、链表、栈、队列、哈希表)
树形结构：二叉树、AVL树、红黑树、B树、堆、Trie、哈夫曼树、并查集
图形结构：邻接矩阵、邻接表
◼ 在实际应用中，根据使用场景来选择最合适的数据结构
2、线性表
◼线性表是具有 n 个相同类型元素的有限序列( n ≥ 0 )
a1 是首节点(首元素)， an 是尾结点(尾元素)
a1 是a2 的前驱，a2 是a1 的后继
◼ 常见的线性表有
数组
链表
栈
队列
哈希表(散列表)
3、数组(Array)
◼ 数组是一种顺序存储的线性表，所有元素的内存地址是连续的
int [] array = new int []{11,22,33};
◼ 在很多编程语言中，数组都有个致命的缺点：
无法动态修改容量
◼ 实际开发中，我们更希望数组的容量是可以 动态改变的
4、动态数组(Dynamic Array)接口设计
◼int size(); // 元素的数量
◼boolean isEmpty(); // 是否为空
◼boolean contains(E element); // 是否包含某个元素 ◼void add(E element); // 添加元素到最后面
◼E get(int index); // 返回index位置对应的元素
◼E set(int index, E element); // 设置index位置的元素 ◼void add(int index, E element); // 往index位置添加元素 ◼E remove(int index); // 删除index位置对应的元素
◼int indexOf(E element); // 查看元素的位置
◼void clear(); // 清除所有元素
5、动态数组的设计
◼ 在Java中，成员变量会自动初始化，比如
int 类型自动初始化为 0
对象类型自动初始化为 null
6、添加元素 - add(E element)
/**
* 添加元素到尾部
* @param element
*/
public void add(E element) {
add(size, element);
}
/**
* 在index位置插入一个元素
* @param index
* @param element
*/
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacity(size + 1);
for (int i = size; i > index; i--) {
elements[i] = elements[i - 1];
}
elements[index] = element;
size++;
}
private void rangeCheckForAdd(int index) {
if (index < 0 || index > size) {
outOfBounds(index);
}
}
private void outOfBounds(int index) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
7、打印数组
◼重写toString 方法
◼在toString 方法中将元素拼接成字符串
◼ 字符串拼接建议使用 StringBuilder
public String toString() {
StringBuilder string = new StringBuilder();
string.append("size=").append(size).append(", [");
for (int i = 0; i < size; i++) {
if (i != 0) {
string.append(", ");
}
string.append(elements[i]);
}
string.append("]");
return string.toString();
}
8、删除元素 - remove(int index)
size 等于 7
index 等于 3
思考:最后一个元素如何处理？
/**
* 删除index位置的元素
* @param index
* @return
*/
public E remove(int index) {
rangeCheck(index);
E old = elements[index];
for (int i = index + 1; i < size; i++) {
elements[i - 1] = elements[i];
}
elements[--size] = null;
return old;
}
private void rangeCheck(int index) {
if (index < 0 || index >= size) {
outOfBounds(index);
}
}
private void outOfBounds(int index) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
9、添加元素 - add(int index, E element)
size 等于 5
index 等于 2
/**
* 在index位置插入一个元素
* @param index
* @param element
*/
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacity(size + 1);
for (int i = size; i > index; i--) {
elements[i] = elements[i - 1];
}
elements[index] = element;
size++;
}
private void rangeCheckForAdd(int index) {
if (index < 0 || index > size) {
outOfBounds(index);
}
}
private void outOfBounds(int index) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
错误的覆盖顺序
10、测试
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(99);
list1.add(88);
list1.add(77);
list1.add(66);
list1.add(55);
list1.set(3, 80);
if ((int)list1.get(3) != 80) {
throw new IllegalAccessError("测试不通过");
}
Asserts.test((int)list1.get(3) == 80);
Asserts断言类
package com.alangeit;
public class Asserts {
public static void test(boolean value) {
try {
if (!value) throw new Exception("测试未通过");
} catch (Exception e) {
e.printStackTrace();
}
}
}
11、如何扩容
不能够重新申请内存空间拼接到原来的数组后面，因为申请的内存空间是随机的
申请一个新的更大的内存空间来存放这个数组，将原来的数据复制到新的数组，把原来数组的引用指向新数组，原来的数组空间会被回收。
ArrayList
/**
* 在index位置插入一个元素
* @param index
* @param element
*/
public void add(int index, E element) {
rangeCheckForAdd(index);
// 扩容
ensureCapacity(size + 1);
for (int i = size; i > index; i--) {
elements[i] = elements[i - 1];
}
elements[index] = element;
size++;
}
/**
* 保证要有capacity的容量
* @param capacity
*/
private void ensureCapacity(int capacity) {
int oldCapacity = elements.length;
if (oldCapacity >= capacity) return;
// 新容量为旧容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);// 右移：除以2
// 开辟新的内存空间
E[] newElements = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
// 将旧的数据复制到新的数组
newElements[i] = elements[i];
}
// 将旧的数组指向新的数组
elements = newElements;
System.out.println(oldCapacity + "扩容为" + newCapacity);
}
测试
public class Main {
public static void main(String[] args) {
// 测试
ArrayList<Integer> list1 = new ArrayList<>();
// 扩容
for (int i = 0; i < 20; i++) {
list1.add(i);
}
}
}
10扩容为15
15扩容为22
12、泛型
◼ 使用泛型技术可以让动态数组更加通用，可以存放任何数据类型
// 泛型
// 所有的类，最终都继承java.lang.Object
// new是向堆空间申请内存
ArrayList<Person> persons = new ArrayList<>();
persons.add(new Person(10, "Jack"));
persons.add(new Person(12, "James"));
persons.add(new Person(15, "Rose"));
persons.add(new Person(22, "abc"));
System.out.println(persons);
// size=4, [Person [age=10, name=Jack], Person [age=12, name=James], Person [age=15, name=Rose], Person [age=22, name=abc]]
13、对象数组
Object[] objects = new Object[7];
14、内存管理细节
clear
/**
* 清除所有元素
*/
public void clear() {
for (int i = 0; i < size; i++) {
elements[i] = null;
}
size = 0;
}
// clear
ArrayList<Person> persons2 = new ArrayList<>();
persons2.add(new Person(10, "Jack"));
persons2.add(new Person(12, "James"));
persons2.clear();
persons2.add(new Person(22, "abc"));
System.out.println(persons2);
// 提醒JVM进行垃圾回收
System.gc();
打印
size=1, [Person [age=22, name=abc]]
1
Person - finalize
Person - finalize
/**
* 删除index位置的元素
* @param index
* @return
*/
public E remove(int index) {
rangeCheck(index);
E old = elements[index];
for (int i = index + 1; i < size; i++) {
elements[i - 1] = elements[i];
}
elements[--size] = null;
return old;
}
15、null的处理
◼ 一个内部设计方面的问题
是否可以存储 null 数据？
16、java.util.ArrayList
◼ JDK中内置了一个动态数组类:java.util.ArrayList
◼ 源码分析
