数据结构学习笔记—ArrayList与顺序表
1.线性表
定义:线性表(linear list)是n个具有相同特性的数据元素的有限序列，线性表是一种在实际中广泛使用的数据结构，常见的线性表有顺序表，链表，栈，队列.....
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
2.顺序表
定义:顺序表是用一段**物理地址连续**的存储单元依次存储数元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改
代码实现
1. 定义一个顺序表
public class MyArrayList{
//顺序表的底层是数组
public int[] elem;//定义数组
public int usedSize;//定义 数组中有效数据个数
public static final int DEFAULT_SIZE = 10;//定义一个成员表示数组申请的空间
//添加构造方法
public MyArrayList(){
this.elem = new int[DEFAULT_SIZE];
}
}2. 顺序表的基本操作
1. 获取顺序表长度
public int size(){
//直接返回usedSize值即可
return this.usedSize;
}2. 打印顺序表
//打印顺序表,注意:该方法并不是顺序表中的方法，为了方便看测试结果给出的
//遍历数组输出值
public void display(){
for (int i = 0; i < this.usedSize; i++) {
System.out.println(this.elem[i]+" ");
}
System.out.println();3. 新增元素(默认在数组最后新增)
新增元素时需要考虑的因素
1. 检测当前顺序表是否满
2.满了就要进行扩容
//新增元素,默认在数组最后新增
public void add(int data){
//1.检测当前的顺序表是不是满了？
if(isFull()){
}
//2.如果满了 就要进行扩容
this.elem =
Arrays.copyOf(this.elem,2*this.elem.length);
//3.
this.elem[this.usedSize] = data;
//4.
this.usedSize++;
}
//判断顺序表是否满
public boolean isFull(){
if (size() >= this.elem.length){
return true;
}
return false;
}4. 在pos位置新增元素
这里需要考虑到位置的判断条件
1.负数下表不可以
2.越界不可以
3.数组满(扩容)
4.不能隔位插入(前面一定要有元素)
如果pos下标不合法，那么就会抛出一个PosWrongfulException异常
public void add(int pos, int data) throws PosWrongfulException{
//判断数组满
if (isFull()){
System.out.println("满了");
this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
}
if (pos < 0 || pos > this.usedSize){
System.out.println("pos位置不合法");
throw new PosWrongfulException("pos位置不合法");
}
//此时pos一定是合法的
//1.开始挪动数据
for (int i = this.usedSize-1; i >= pos; i--){
this.elem[i+1] = this.elem[i];
}
//2.插入数据
this.elem[pos] = data;
//3.usedSize++
usedSize++;
}//pos位置不合法异常
public class PosWrongfulException extends RuntimeException{
public PosWrongfulException(){
}
public PosWrongfulException(String message){
super(message);
}
}5. 判断是否包含某个元素
//判断是否包含某个元素
public boolean contains(int toFind){
for (int i = 0; i6. 查找某个元素对应的位置
//查找某个元素对应的位置
public int indexOf(int toFind){
for (int i = 0; i < this.size(); i++) {
if (this.elem[i] == toFind){
return i;
}
}
//未找到返回-1
return -1;
}7. 获取pos位置的元素
此处需要考虑两点：
1. 顺序表是否为空，为空时找不到pos位置，抛出一个EmptyException异常
2. 判断pos位置的合法性
//获取pos位置的元素
public int get(int pos){
if (isEmpty()){
throw new EmptyException("当前顺序表为空");
}
if (pos < 0 || pos >= this.usedSize){
throw new PosWrongfulException("get获取元素时,pos不合法异常");
}
return this.elem[pos];
}
//判断顺序表是否为空
public boolean isEmpty(){
return size() == 0;
}//空顺序表异常
public class EmptyException extends RuntimeException{
public EmptyException(){
}
public EmptyException(String message){
super(message);
}
}8. 给pos位置的元素更新为value
此处也要考虑顺序表为空和pos位置合法性
//给pos位置的元素更新为value
public void set(int pos, int value){
if (isEmpty()){
throw new EmptyException("当前顺序表为空");
}
if (pos < 0 || pos >= this.usedSize){
throw new PosWrongfulException("set获取元素时,pos不合法异常");
}
this.elem[pos] = value;
}9. 删除第一次出现的关键字key
此处需考虑顺序表为空和关键字key是否在这个顺序表中
//删除第一次出现的关键字key
public void remove(int key){
if (isEmpty()){
throw new EmptyException("顺序表为空");
}
int index = this.indexOf(key);
if (index == -1){
System.out.println("没有这个数字");
return;
}
for (int i = index; i < this.usedSize-1; i++) {
this.elem[i] = this.elem[i+1];
}
this.usedSize--;
}10. 清空顺序表
//清空顺序表
public void clear(){
//仅需有效元素个数为0即可
this.usedSize = 0;
}3.测试类
public class TestList {
public static void main(String[] args) {
MyArrayList myArrayList = new MyArrayList();
myArrayList.add(1);
myArrayList.add(2);
myArrayList.add(3);
//打印
myArrayList.display();
System.out.println("=========");
//pos位置添加元素
try {
myArrayList.add(1,10);
}catch (PosWrongfulException e){
e.printStackTrace();
}
myArrayList.display();
System.out.println("=========");
//判断是否包含某元素
System.out.println(myArrayList.contains(10));
System.out.println(myArrayList.contains(11));
System.out.println("=========");
//得到pos对应元素
System.out.println(myArrayList.get(0));
System.out.println("=========");
try {
System.out.println(myArrayList.get(1));
}catch (EmptyException e){
e.printStackTrace();
}
System.out.println("=========");
//给pos位置更新value
myArrayList.set(0,99);
myArrayList.display();
System.out.println("=========");
//获取顺序表尺寸
System.out.println(myArrayList.size());
System.out.println("=========");
//删除第一个出现的关键字key
myArrayList.remove(3);
myArrayList.display();
System.out.println("=========");
//清空表
myArrayList.clear();
myArrayList.display();
}
}3.1Arraylist构造方法
| 方法 | 解释 |
| ArrayList() | 无参构造 |
| ArrayList(Collection c) | 利用其他Collection构造ArrayList |
| ArrayList(int initialCapacity) | 指定顺序表初始容量 |
public static void main(String[] args) {
// ArrayList创建，推荐写法
// 构造一个空的列表
List list1 = new ArrayList<>();
// 构造一个具有10个容量的列表
List list2 = new ArrayList<>(10);
list2.add(1);
list2.add(2);
list2.add(3);
// list2.add("hello"); // 编译失败，List已经限定了，list2中只能存储整形元素
// list3构造好之后，与list中的元素一致
ArrayList list3 = new ArrayList<>(list2);
// 避免省略类型，否则：任意类型的元素都可以存放，使用时将是一场灾难
List list4 = new ArrayList();
list4.add("111");
list4.add(100);
} 3.2ArrayList常见操作
ArrayList提供了非常多的方法，只需记得常用，用到其他方法时查API
| 方法 | 解释 |
| boolean add(E e) | 尾插 e |
| void add(int index, E element) | E element) 将 e 插入到 index 位置 |
| boolean addAll(Collection 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 |
截取部分 list |
public static void main(String[] args) {
List list = new ArrayList<>();
list.add("JavaSE");
list.add("JavaWeb");
list.add("JavaEE");
list.add("JVM");
list.add("测试课程");
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("测试课程")){
list.add("测试课程");
}
// 查找指定元素第一次出现的位置：indexOf从前往后找，lastIndexOf从后往前找
list.add("JavaSE");
System.out.println(list.indexOf("JavaSE"));
System.out.println(list.lastIndexOf("JavaSE"));
// 使用list中[0, 4)之间的元素构成一个新的ArrayList返回
List ret = list.subList(0, 4);
System.out.println(ret);
list.clear();
System.out.println(list.size());
} 3.3ArrayList的遍历
ArrayList可以使用三种方式遍历：for循环＋下标，foreach，使用迭代器
public static void main(String[] args) {
List list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
// 使用下标+for遍历
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
System.out.println();
// 借助foreach遍历
for (Integer integer : list) {
System.out.print(integer + " ");
}
System.out.println();
Iterator it = list.listIterator();
while(it.hasNext()){
System.out.print(it.next() + " ");
}
System.out.println();
}