【数据结构入门】----ArrayList与顺序表

#玲儿响叮当

已于 2022-08-10 22:40:18 修改

阅读量111

点赞数 1

文章标签：数据结构链表算法

于 2022-08-10 22:38:21 首次发布

本文链接：https://blog.csdn.net/qq_36768138/article/details/126275426

版权

一、线性表

线性表是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

二、顺序表（接口的实现）

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改：

public class MyArrayList {
    public int[] elem;
    public int usedSize;
    public static final int DEFAULT_CAPACITY=2;

    public MyArrayList() {
        this.elem=new int[DEFAULT_CAPACITY];
    }
    //1 打印顺序表
    public void display(){
        for(int i=0;i<usedSize;i++){
            System.out.print(elem[i]+" ");
        }
    }
    //2 新增元素(判满）
    public void add(int data){
        if(isFull()){
            elem= Arrays.copyOf(elem,2*elem.length);
        }
        elem[usedSize]=data;
        usedSize++;
    }
    private boolean isFull(){
        if(usedSize==elem.length){
            return true;
        }
        return false;
    }
    //3 在pos位置新增元素（合法性、判满）!!!!!!
    //检查pos位置的合法性，不合法的话通过异常进行处理
    public void addQ(int pos,int data){
        try{
            checkAddPos(pos);
            if(isFull()){
                elem=Arrays.copyOf(elem,2*elem.length);
            }
            for(int i=usedSize-1;i>=pos;i--){
                elem[i+1]=elem[i];
            }
            elem[pos]=data;
            usedSize++;
        }catch(PosIndexNotLegalExcepption e){
            e.printStackTrace();
        }
    }
    private void checkAddPos(int pos){
        if(pos<0 || pos>usedSize){
            throw new PosIndexNotLegalExcepption("pos位置不合法！");
        }
    }
    //4 判断是否包含某个元素
    public boolean contains(int toFind){
        for(int i=0;i<usedSize;i++){
            if(elem[i]==toFind){
                return true;
            }
        }
        return false;
    }
    //5 查找某个元素对应的位置
    public int indexOf(int toFind){
        for(int i=0;i<usedSize;i++){
            if(elem[i]==toFind){
                return i;
            }
        }
        return -1;
    }
    //6 获取pos位置的元素!!!!!!!!!!!!!!!
    public int get(int pos){
        int retVal=-1;
        try{
            checkGetPos(pos);
            retVal=elem[pos];
        }catch(posIndexNotLegal e){
            e.printStackTrace();
        }
        return retVal;//在try...catch...的外面一定要写返回值
    }
    //增加的元素的位置可以在usedSize,索引的元素的位置不能在usedSize
    private void checkGetPos(int pos){
        if(pos<0 || pos>=usedSize){
            throw new posIndexNotLegal("pos位置不合法！");
        }
    }
    //7 获取顺序表的长度
    public int size(){
        return usedSize;
    }
    //8 给pos位置的元素设为value更新!!!!!!!!!!!!!!
    public void set(int pos,int value){
        try{
            checkGetPos(pos);
            elem[pos]=value;
        }catch(posIndexNotLegal e){
            e.printStackTrace();
        }
    }
    //9 删除数组中的某个第一次出现的元素!!!!!!!!!!
    public void remove(int key){
        int index=indexOf(key);
        if(index==-1){
            System.out.println("没有要删除的数字！");
            return;
        }
        for(int i=index+1;i<usedSize;i++){
            elem[i-1]=elem[i];
        }
        usedSize--;
    }
    //10 清空顺序表
    public void clear(){
        usedSize=0;
    }
}

三、ArrayList简介

在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：
ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

四、ArrayList使用
4.1 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常见操作

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("测试");
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<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<Integer> 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<Integer> it = list.listIterator();
while(it.hasNext()){
System.out.print(it.next() + " ");
}
System.out.println();
}