目录
顺序表是线性表的其中一种，那么什么是线性表呢？
1.线性表
线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列...
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
2.顺序表
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
2.1 接口的实现
public class MyArrayList {
private int[] arr = null;
private int usedSize = 0;//记录有效元素个数
private final static int DEFAULT_CAPACITY = 10;//初始数组默认空间
// 无参构造器
public MyArrayList() {
arr = new int[DEFAULT_CAPACITY];
}
// 有参构造器
public MyArrayList(int capacity) {
arr = new int[capacity];
}
// 打印顺序表
public void display() {
for (int i = 0; i < usedSize; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
// 新增元素,默认在数组最后新增
public void add(int data) {
checkCapacity();
arr[usedSize++] = data;
}
// 判断数组是否填满
private boolean isFull() {
return usedSize == arr.length;
}
// 检查数组容量
private void checkCapacity() {
if (isFull()) {
arr = Arrays.copyOf(arr,2 * arr.length);
}
}
// 在 pos 位置新增元素
public void add(int pos, int data) {
try {
isAddScore(pos);
checkCapacity();
for (int i = usedSize; i > pos; i--) {
arr[i] = arr[i - 1];
}
arr[pos] = data;
usedSize++;
} catch (Exception e) {
e.printStackTrace();
}
}
// 添加元素时判断下标是否合法
private void isAddScore(int pos) {
if (!(pos >= 0 || pos <= usedSize)) {
throw new IndexVisitException("数组下标越界");
}
}
// 判定是否包含某个元素
public boolean contains(int toFind) {
for (int i = 0; i < usedSize; i++) {
if (arr[i] == toFind) return true;
}
return false;
}
// 查找某个元素对应的位置
public int indexOf(int toFind) {
for (int i = 0; i < usedSize; i++) {
if (arr[i] == toFind) return i;
}
return -1;
}
// 获取 pos 位置的元素
public int get(int pos) {
try {
isGetScore(pos);
return arr[pos];
} catch (Exception e) {
e.printStackTrace();
return -1;
}
}
// 获取元素时判断下标是否合法
private void isGetScore(int pos) {
if (!(pos >= 0 && pos < usedSize)) {
throw new IndexVisitException("数组下标访问错误");
}
}
// 给 pos 位置的元素设为 value
public void set(int pos, int value) {
try {
isGetScore(pos);
arr[pos] = value;
} catch (Exception e) {
e.printStackTrace();
}
}
// 删除第一次出现的关键字key
public void remove(int toRemove) {
int pos = indexOf(toRemove);
if (pos == -1) {
System.out.println("又没你要删除的数字!");
return;
}
for (int i = pos; i < usedSize - 1; i++) {
arr[i] = arr[i + 1];
}
usedSize--;
}
// 获取顺序表长度
public int size() {
return usedSize;
}
// 清空顺序表
public void clear() {
usedSize = 0;
}
}3. ArrayList简介
在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：
【说明】
1. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
2. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
3. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
4. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList
5. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表
4. ArrayList使用
4.1 ArrayList的构造
| 方法 | 解释 |
|---|---|
| ArrayList() | 无参构造 |
| ArrayList(int initialCapacity) | 指定顺序表初始容量 |
| ArrayList(Collection<? extends E> c) | 利用其他 Collection 构建 ArrayList |
public static void main(String[] args) {
// ArrayList创建，推荐写法
// 构造一个空的列表
List<Integer> list1 = new ArrayList<>();
// 构造一个具有10个容量的列表
List<Integer> list2 = new ArrayList<>(10);
list2.add(1);
list2.add(2);
list2.add(3);
// list2.add("hello"); // 编译失败，List<Integer>已经限定了，list2中只能存储整形元素
// list3构造好之后，与list中的元素一致
ArrayList<Integer> list3 = new ArrayList<>(list2);
// 避免省略类型，否则：任意类型的元素都可以存放，使用时将是一场灾难
List list4 = new ArrayList();
list4.add("111");
list4.add(100);
}4.2 ArrayList常见操作
| 方法 | 解释 |
|---|---|
| boolean add(E e) | 尾插 e |
| void add(int index, E element) | 将 e 插入到 index 位置 |
| boolean addAll(Collection<? extends E> c) | 尾插 c 中的元素 |
| E remove(int index) | 删除 index 位置元素 |
| boolean remove(Object o) | 删除遇到的第一个 o |
| E get(int index) | 获取下标 index 位置元素 |
| E set(int index, E element) | 将下标 index 位置元素设置为 element |
| void clear() | 清空 |
| boolean contains(Object o) | 判断 o 是否在线性表中 |
| int indexOf(Object o) | 返回第一个 o 所在下标 |
| int lastIndexOf(Object o) | 返回最后一个 o 的下标 |
| List<E> subList(int fromIndex, int toIndex) | 截取部分 list |
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("JavaSE");
list.add("JavaWeb");
list.add("JavaEE");
list.add("JVM");
list.add("GC");
System.out.println(list);
// 获取list中有效元素个数
System.out.println(list.size());
// 获取和设置index位置上的元素，注意index必须介于[0, size)间
System.out.println(list.get(1));
list.set(1, "JavaWEB");
System.out.println(list.get(1));
// 在list的index位置插入指定元素，index及后续的元素统一往后搬移一个位置
list.add(1, "Java数据结构");
System.out.println(list);
// 删除指定元素，找到了就删除，该元素之后的元素统一往前搬移一个位置
list.remove("JVM");
System.out.println(list);
// 删除list中index位置上的元素，注意index不要超过list中有效元素个数,否则会抛出下标越界异常
list.remove(list.size() - 1);
System.out.println(list);
// 检测list中是否包含指定元素，包含返回true，否则返回false
if (list.contains("GC")) {
list.add("GC");
}
// 查找指定元素第一次出现的位置：indexOf从前往后找，lastIndexOf从后往前找
list.add("JavaSE");
System.out.println(list.indexOf("JavaSE"));
System.out.println(list.lastIndexOf("JavaSE"));
// 使用list中[0, 4)之间的元素构成一个新的ArrayList返回
List<String> ret = list.subList(0, 4);
System.out.println(ret);
list.clear();
System.out.println(list.size());
}4.3 ArrayList的遍历
public static void main(String[] args) {
List list = new ArrayList();
list.add("jack");
list.add("tom");
list.add("鱼香肉丝");
list.add("北京烤鸭");
//遍历
System.out.println("=====迭代器=====");
//1. 迭代器
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("obj=" + obj);
}
System.out.println("=====增强for=====");
//2. 增强for
for (Object obj : list) {
System.out.println("obj=" + obj);
}
System.out.println("=====普通for=====");
//3. 使用普通for
for (int i = 0; i < list.size(); i++) {
System.out.println("对象=" + list.get(i));
}
}4.4 ArrayList的扩容机制
注意：第一个元素添加时才扩容，不是调用ArrayList构造器时扩容
对数据进行装箱
DEFAULTCAPACITY_EMPTY_ELEMENTDATA是一个默认数组
因为我这里创建ArrayList使用的无参构造器，所以初始值就是DEFAULTCAPACITY_EMPTY_ELEMENTDATA
第一次进入时
elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA为true
进入ensureExplicitCapacity
此时数组长度为0
进入if语句中
grow内进行扩容
扩容
进行1.5倍扩容
注意：此时elementData已经有新的存储空间(地址已经发生改变)了
对第一个元素进行填充
此时填充了10个元素，准备第二次扩容
不会进入if语句内，直接返回minCapacity。
此时minCapacity大于数组长度
注意：此时elementData已经有新的存储空间(地址已经发生改变)了
公式
即1.5倍扩容
502
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
