ArrayList与顺序表（上）

线性表

线性表 （ linear list ） 是 n 个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构，常见的线性表：顺序表、链表、栈、队列...

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。

顺序表

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

接口的实现

想实现对List的增删查改，我们首先要知道它的底层代码。

public class SeqList {
private int[] array;
private int size;
// 默认构造方法
SeqList(){ }
// 将顺序表的底层容量设置为initcapacity
SeqList(int initcapacity){ }
// 新增元素,默认在数组最后新增
public void add(int data) { }
// 在 pos 位置新增元素
public void add(int pos, int data) { }
// 判定是否包含某个元素
public boolean contains(int toFind) { return true; }
// 查找某个元素对应的位置
public int indexOf(int toFind) { return -1; }
// 获取 pos 位置的元素
public int get(int pos) { return -1; }
// 给 pos 位置的元素设为 value
public void set(int pos, int value) { }
//删除第一次出现的关键字key
public void remove(int toRemove) { }
// 获取顺序表长度
public int size() { return 0; }
// 清空顺序表
public void clear() { }
// 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
public void display() { }
}

然后是我自己对于这些代码的补充填写，仅供参考。

public class Demo {
    public static void main(String[] args) {
        SeqList seqList = new SeqList();
        seqList.add(1);
        seqList.add(2);
        seqList.add(3);
        seqList.add(4);
        seqList.add(5);
        seqList.add(6);
        seqList.disPlay();
/*        seqList.get(100);*/
        seqList.size();
        seqList.clear();
    }
}

如图是Demo文件的代码；

import java.util.Arrays;

public class SeqList {
    private int[] elem;
    private int usedSize;
    private static final int finalNumber = 10;
    public SeqList(){
        this.elem = new int[finalNumber];
        this.usedSize = 0;
    }
    public void disPlay(){
        if(isFull()){
          elem = Arrays.copyOf(elem,2*elem.length);
        }
        for (int i = 0; i < this.usedSize ; i++){
            System.out.print(this.elem[i]+" ");
        }
    }
    public void add(int add){
        this.elem[usedSize] = add;
        usedSize++;

    }
    public boolean isFull(){
        return usedSize == elem.length;
    }
    public boolean contain(int toFind){
        for (int i = 0;i <= this.usedSize;i++) {
            if (toFind == elem[i]){
                return true;
            }
        }
            return false;
    }
    public int indexOf(int toFind){
        for (int i = 0;i <= this.usedSize;i++) {
            if (toFind == this.elem[i]){
                return i;
            }
        }
        return -1;
    }
    public int get(int pos){
        if (!checkPos(pos)){
            throw new posOutBoundsException("获取数据时不合法");
        }
        return elem[pos];
    }
    public int size(){
        return usedSize;
    }
    public void set(int pos,int value){
        if(!checkPos(pos)){
            throw new posOutBoundsException("替换数据时不合法");
        }
        elem[pos] = value;
    }
    public boolean checkPos(int pos){
        if (pos < 0 || pos > usedSize) {
            return false;
        }
        return true;
    }
    public void add(int pos,int value){
        if(!checkPos(pos)) {
            throw new posOutBoundsException("替换数据时不合法");
        }
        if(isFull()){
            elem = Arrays.copyOf(elem,2*elem.length);
        }
        for(int i = usedSize-1;i >= pos;i--){
            elem[i+1] =elem[i];
        }
        elem[pos] = value;
        usedSize++;
    }
    public boolean isEmpty(){
        return usedSize == 0;
    }
    public void remove(int toRemove){
        if(isEmpty()){
            return;
        }
        int index = indexOf(toRemove);
        if (index == -1){
            return;
        }
        for (int i = index; i<usedSize-1;i++){
            elem[i] = elem[i+1];
        }
        usedSize--;
    }
    public void clear(){
        for (int i = 0;i<=usedSize;i++){
            elem[i] = null;
        }
    }
}

如图是SeqList文件的代码；

public class posOutBoundsException extends RuntimeException{
    public posOutBoundsException(){

    }
    public posOutBoundsException(String message){
        super(message);
    }
}

如图是posOutBoundsException文件的代码；

ArrayList简介

在集合框架中， ArrayList 是一个普通的类，实现了 List 接口，具体框架图如下：

1. ArrayList 是以泛型方式实现的，使用时必须要先实例化。

2. ArrayList 实现了 RandomAccess 接口，表明 ArrayList 支持随机访问。

3. ArrayList 实现了 Cloneable 接口，表明 ArrayList 是可以 clone 的。

4. ArrayList 实现了 Serializable 接口，表明 ArrayList 是支持序列化的。

5. 和 Vector 不同， ArrayList 不是线程安全的，在单线程下可以使用，在多线程中可以选择 Vector 或者 CopyOnWriteArrayList。

6. ArrayList 底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表。