List【数据结构】

List

1.List的常用方法

方法	解释
boolean add( E e )	尾插e
void add(int index, 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< E > subList(int fromIndex, int toIndex)	截取部分 list

2. List的使用

注意： List是个接口，并不能直接用来实例化。,如果要使用，必须去实例化List的实现类。

2.1 线性表

线性表（linear list）是数据结构的一种，表示n个具有相同特性的数据元素的有限序列

线性表在逻辑上是线性结构，在物理上不一定是连续的，在物理上存储时，通常以数组和链式结构的形式存储

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使用用例

先定义一个顺序表数组结构

public int[] elem;
    public int usedSize;
    public static final int DEFAULT_CAPACITY = 10;


    public MyArrayList(){
        this.elem = new int[10];
    }

(1) 打印顺序表display(),只需要打印到 usedSize 下标就可以了

    public void display(){
        for(int i = 0; i < this.usedSize; i++){
            System.out.println(this.elem[i]+" ");
        }
        System.out.println();
    }

(2) 新增元素，默认在数组最后新增 add

先判断是否需要扩容 isFull()

 public boolean isFull(){
        //这里usedsize 必须和 elem.length
        return usedSize == elem.length;

需要扩容时，就申请空间扩容

public void add(int data){
        //扩容
        try{
            if(isFull()){
                elem = Arrays.copyOf(elem, 2*elem.length);
            }
        }catch(NegativeArraySizeException e){
            e.printStackTrace();
        }
        elem[usedSize++] = data;
    }

(3) 在 pos 位置新增元素 add(int pos, int data)

检查add元素的时候，pos位置是否合法

private void checkAddPos(int pos){
        if(pos < 0 || pos > usedSize){
            throw new PosIndexNotLegalException("pos位置不合法");
        }
    }

在 pos 位置新增元素，把pos后面元素全部向后移一位，然后放入新增元素

public void add(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(PosIndexNotLegalException e){
            e.printStackTrace();
        }

    }

上述代码中若有不合法，则调用异常类 PosIndexNotLegalException

package Listdemo;
public class PosIndexNotLegalException extends RuntimeException{
    public PosIndexNotLegalException(){
    }
    public PosIndexNotLegalException(String msg){
        super(msg);
    }
}

(4) 判定是否包含某个元素 contains()

public boolean contains(int toFind){
        for(int i = 0; i < usedSize; i++){
            if(elem[i] == toFind){
                return true;
            }
        }
        return false;
    }

(5) 查找某个元素对应的位置 indexOf()

public int indexOf(int toFind){
        for(int i = 0; i < usedSize; i++){
            if(elem[i] == toFind){
                return i;
            }
        }
        return -1;
    }

(6) 获取 pos 位置的元素 get()

同理 获取 pos 位置的数据，检查合法性

private void checkGetPos(int pos){
        if(pos < 0 || pos >= usedSize){
            throw new PosIndexNotLegalException("pos位置不合法");
        }
    }

public int get(int pos){
//        int retVal = -1;
//        try{
//            checkGetPos(pos);
//            retVal = elem[pos];
//        }catch(PosIndexNotLegalException e){
//            //就要处理pos位置不合法的问题
//            e.printStackTrace();
//        }
//        return retVal;
        checkGetPos(pos);
        return elem[pos];
    }

(7) 给 pos 位置元素设置 value 更新 set()

public void set(int pos, int value){
        checkGetPos(pos);
        elem[pos] = value;
    }

(8) 删除第一次出现的关键字key remove()

public void remove(int key){
        int index = indexOf(key);
        if(index == -1){
            System.out.println("没有你要删除的数字");
            return;
        }
        for(int i = index; i < usedSize; i++){
            elem[i] = elem[i+1];
        }
          //elem[] = null;
            usedSize--;
    }

(9) 获取顺序表长度 size()

public int size(){
        return usedSize;
    }

(10) 清空顺序表 clear()

public void clear(){
//        for(int i = 0; i < usedSize; i++){
//            elem[i] = null;
//        }
            usedSize = 0;
    }

验证测试

public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0,1);
        myArrayList.add(1,2);
        myArrayList.add(2,3);
        myArrayList.add(31);
        myArrayList.display();
        System.out.println(myArrayList.contains(1));
        System.out.println(myArrayList.indexOf(1));
        System.out.println(myArrayList.get(1));
        myArrayList.set(0,99);
        myArrayList.display();
    }

5. ArrayList的遍历

（1）for 循环遍历
（2）foreach循环
（3）使用迭代器
如：

public class Test {
    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);
        System.out.println("===================for======================");

        for(int i = 0; i < list.size(); i++){
            System.out.println(list.get(i));
        }
        System.out.println("====================foreach======================");

        for (String x: list) {
            System.out.println(x);
        }

        System.out.println("====================迭代器1=======================");

        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        System.out.println("====================迭代器2=======================");

        ListIterator<String> it2 = list.listIterator();
        while(it2.hasNext()){
            System.out.println(it2.next());
        }
}

测试结果：

**注意：**截取部分list subList()

List<String> ret = list.subList(1,3);
        System.out.println(ret);

        System.out.println("===================更新===================");
        ret.set(0,"zmy");

        System.out.println(list);
        System.out.println(ret);

测试结果：