List——顺序表与链表（一）

已于 2022-12-03 20:50:09 修改
阅读量352 收藏 1
点赞数 2
分类专栏： Java数据结构 文章标签： list 数据结构 java
于 2022-12-03 20:39:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xx_bjpyy/article/details/128164550
版权

文章目录

什么是List

在集合框架中，**List是一个接口，继承自Collection。**而collection也是一个接口，该接口中规范了后续容器中常用的一些方法，继承自Iterable。具体如下所示：

在这里插入图片描述
Iterable也是一个接口，表示实现该接口的类是可以逐个元素进行遍历的，具体如下：

在这里插入图片描述
站在数据结构的角度来看，List就是一个线性表，即n个具有相同类型元素的有限序列，在该序列上可以执行增删改查以及变量等操作。

提示：以下是本篇文章正文内容，下面案例可供参考

一、List常见接口介绍

List提供了很多方法，具体如下：

在这里插入图片描述
虽然方法很多，但是常用方法如下：

方法解释
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 subList(int fromIndex, int toIndex)截取部分 list

值得注意的是，**List是个接口，并不能直接用来实例化。**如果要使用，必须去实例化List的实现类。在集合框架中，ArrayList和LinkedList都实现了List接口。

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

二、ArrayList与顺序表

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

1.ArrayList简介

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

在这里插入图片描述
说明：

  1. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
  2. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
  3. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
  4. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList
  5. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

2.实现自己的顺序表

手撕代码环节：
首先我们需要定义一个自己的list接口，接口中声明需要实现的各种方法：

public interface MyList {
    /**
     * 返回线性表中的元素个数
     * @return
     */
    int size();

    /**
     * 将e插入到线性表中，一定返回true
     * @param e
     * @return
     */
    boolean add(Long e);

    /**
     * 将e插入下标为index位置处，如果下标不合法，抛出ArrayIndexOutOfBoundsException异常
     * 向除末尾处插入都需要移动元素
     * @param index  下表合法范围[0,size())
     * @param e 添加的元素
     */

    void add(int index,Long e);

    /**
     * 删除index下标处的元素并返回
     * @param index [0,size()-1]
     * @return 返回删除的元素值
     */
    Long remove(int index);

    /**
     * 删除值为e的元素
     * @param e 需要删除的元素
     * @return 成功返回true  失败返回false
     */
    boolean remove(Long e);

    /**
     * 获取index处元素的值
     * @param index 数组下标
     * @return 该下标处的元素值
     */
    Long get(int index);

    /**
     * 修改元素
     * @param index [0,size)
     * @param e  修改后的元素
     * @return 原来index处的元素
     */
    Long set(int index,Long e);

    /**
     * 修改所有值为e的元素为ne
     * @param e
     * @return  修改的元素个数
     */
    int set(Long e,Long ne);

    /**
     * 从前往后，返回第一次遇到e的下标
     * @param e 目标元素
     * @return
     */
    int indexOf(Long e);

    /**
     * 从后向前
     * @param e
     * @return
     */
    int lastIndexOf(Long e);

    /**
     * 线性表中是否包含e
     * @param e
     * @return
     */
    boolean contains(Long e);

    /**
     * 打印顺序表
     */
    void display();

    /**
     *判满
     * @return
     */
    boolean isFull();

    /**
     * 判空
     * @return
     */
    boolean isEmpty();

    /**
     * 清空
     */
    void clear();
}

接下来就是接口中各方法的具体实现了：

public class MyArrayList implements MyList {
    //定义属性
    private Long[] array;   //定义了一个数组，数组容量为array.length
    private int size;   //保存元素的个数

    //构造方法
    public MyArrayList() {
        //初始元素个数为0
        this.size = 0;
        //容量自行定义，暂定为16个
        this.array = new Long[16];
        //将数组中每个位置初始化为null
        for (int i = 0; i < array.length; i++) {
            array[i] = null;
        }

    }

    @Override
    //返回顺序表的元素个数(！=顺序表大小)   size!=length
    public int size() {
        return size;
    }

    @Override
    //尾插元素
    public boolean add(Long e) {
        //尾插，此时size表示的是下标
        array[size] = e;

        size += 1;
        return true;
    }

    @Override
    //将e添加至index处
    public void add(int index, Long e) {

        //TODO：扩容问题

        if (index < 0 || index > size) {
            // 下标不合法
            throw new ArrayIndexOutOfBoundsException("下标不合法");
        }
        //先搬家，将index位置之后的元素往后挪一位，把index空出来
        for (int i = size; i > index; i--) {
            array[i] = array[i - 1];
        }
        //将e放在index处
        array[index] = e;
        size += 1;

    }

    @Override
    //移除下表为index处的元素，并返回元素值
    public Long remove(int index) {
        // 下标合法性检查
        if (index < 0 || index >= size) {
            // 下标不合法
            throw new ArrayIndexOutOfBoundsException("下标不合法");
        }
        //将index之后的元素统一往前挪一位
        //先将index处的元素保存下来 作为返回值
        Long e = array[index];

        for (int i = index; i < size; i++) {
            array[i] = array[i + 1];
        }
        // 把不存在的元素置为 null
        // 真实中是否要置 null，需要根据性能考虑
        array[size - 1] = null;
        //size减1
        size -= 1;
        return e;
    }

    @Override
    //移除第一个碰到的元素e，若成功返回true，失败（没找到）返回false
    public boolean remove(Long e) {
        // 按照从前到后的顺序，找到第一个遇到的 e
        for (int i = 0; i < size; i++) {
            if (array[i].equals(e)) {
                remove(i);
                size--;
                return true;
            }
        }
        return false;
    }

    @Override
    //返回下表为index的元素值
    public Long get(int index) {
        if (index < 0 || index >= size) {
            // 下标不合法
            throw new ArrayIndexOutOfBoundsException("下标不合法");
        }

        return array[index];
    }

    @Override
    //修改第一个指定位置的元素为e
    public Long set(int index, Long e) {
        // 下标合法性检查
        if (index < 0 || index >= size) {
            // 下标不合法
            throw new ArrayIndexOutOfBoundsException("下标不合法");
        }
        Long be = array[index];

        array[index] = e;

        return be;
    }

    @Override
    //修改所有e为ne,返回修改的个数
    public int set(Long e, Long ne) {
        int count = 0;
        for (int i = 0; i < size; i++) {
            if (array[i].equals(e)) {
                array[i] = ne;
                count++;
            }
        }

        return count;
    }

    @Override
    //返回第一个遇到的e的下标
    public int indexOf(Long e) {
        for (int i = 0; i < size; i++) {
            if (array[i].equals(e)) {
                return i;
            }
        }
        return -1;   //没找到
    }

    @Override
    //从后向前第一个e的下标
    public int lastIndexOf(Long e) {
        for (int i = size - 1; i >= 0; i--) {
            if (array[i].equals(e)) {
                return i;
            }
        }
        return -1;  //没找到
    }

    @Override
    //线性表中是否包含e
    public boolean contains(Long e) {
        for (int i = size - 1; i >= 0; i--) {
            if (array[i].equals(e)) {
                return true;
            }
        }
        //没找到
        return false;

        //一行代码
        //return indexOf(e) != -1
    }

    @Override
    //打印顺序表
    public void display() {
        if (size == 0) {
            System.out.println("[]");
            return;
        }
        System.out.print("[");
        for (int i = 0; i < size - 1; i++) {
            System.out.print(array[i] + ", ");
        }
        System.out.print(array[size - 1] + "]");
        System.out.println();
    }

    @Override
    public boolean isFull() {
        return size == array.length;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void clear() {
        for (int i = 0; i < size; i++) {
            array[i] = null;
        }
        this.size = 0;
    }

3.ArrayList的遍历

ArrayList可以使用三种方式遍历：for循环+下标、foreach、使用迭代器，在上述实现的自己的ArrayList中，display方法实现的打印顺序表就是使用的for循环+下标。

//这里使用的是java.util包下的ArrayList  并非自己写的 因为迭代器并没有在MyList中实现
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();
}

运行结果：

在这里插入图片描述

4.ArrayList的扩容机制

ArrayList是一个动态类型的顺序表，即：在插入元素的过程中会自动扩容：以下是ArrayList源码中扩容方式

Object[] elementData; // 存放元素的空间
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 默认空间
private static final int DEFAULT_CAPACITY = 10; // 默认容量大小
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
// 获取旧空间大小
int oldCapacity = elementData.length;
// 预计按照1.5倍方式扩容
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 如果用户需要扩容大小 超过 原空间1.5倍，按照用户所需大小扩容
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 如果需要扩容大小超过MAX_ARRAY_SIZE，重新计算容量大小
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 调用copyOf扩容
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
// 如果minCapacity小于0，抛出OutOfMemoryError异常
if (minCapacity < 0)
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

总结：

  1. 检测是否真正需要扩容，如果是调用grow准备扩容
  2. 预估需要库容的大小
    初步预估按照1.5倍大小扩容
    如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容
    真正扩容之前检测是否能扩容成功，防止太大导致扩容失败
  3. 使用copyOf进行扩容

5.使用示例：

手写一个扑克牌小游戏：

public class Card {
    public int rank; // 牌面值
    public String suit; // 花色
    @Override
    public String toString() {
        return String.format("[%s %d]", suit, rank);
    }
}
public class CardDemo {
    public static final String[] SUITS = {"♠", "♥", "♣", "♦"};

    // 买一副牌
    private static List<Card> buyDeck() {
        List<Card> deck = new ArrayList<>(52);
        for (int i = 0; i < 4; i++) {
            for (int j = 1; j <= 13; j++) {
                String suit = SUITS[i];
                int rank = j;
                Card card = new Card();
                card.rank = rank;
                card.suit = suit;
                deck.add(card);
            }
        }
        return deck;
    }

    private static void swap(List<Card> deck, int i, int j) {
        Card t = deck.get(i);
        deck.set(i, deck.get(j));
        deck.set(j, t);
    }

    private static void shuffle(List<Card> deck) {
        Random random = new Random(20190905);
        for (int i = deck.size() - 1; i > 0; i--) {
            int r = random.nextInt(i);
            swap(deck, i, r);
        }
    }

    public static void main(String[] args) {
        List<Card> deck = buyDeck();
        System.out.println("刚买回来的牌:");
        System.out.println(deck);
        shuffle(deck);
        System.out.println("洗过的牌:");
        System.out.println(deck);
// 三个人，每个人轮流抓 5 张牌
        List<List<Card>> hands = new ArrayList<>();
        hands.add(new ArrayList<>());
        hands.add(new ArrayList<>());
        hands.add(new ArrayList<>());
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                hands.get(j).add(deck.remove(0));
            }
        }
        System.out.println("剩余的牌:");
        System.out.println(deck);
        System.out.println("A 手中的牌:");
        System.out.println(hands.get(0));
        System.out.println("B 手中的牌:");
        System.out.println(hands.get(1));
        System.out.println("C 手中的牌:");
        System.out.println(hands.get(2));
    }
}

运行一下，得到：

在这里插入图片描述

总结

以上就是今天要讲的内容，本文手动复现了ArrayList的实现代码以及其中常见常用的方法。大致介绍了List接口以及其下的方法和具体实现类以及使用，后续会将LinkedList的代码实现以及使用总结一下，然后将两者进行比较和总结。还有相关编程题过几天也会总结一下~

彭彭彭摆鱼
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
java 带顺序的list_Java 中的 List —— 有序序列
weixin_35652867的博客
02-13 5984
List 在 java 中是个有序序列：一、容量ArrayList 中有一个容量概念，表示基础数组的大小(无参时默认为 10)。在需要的时候(比如 add操作)会自动增加其容量。LinkedList 没有这个概念。TreeMap 也有容量，默认是 16.二、改善的 search 方法LinkedList 与 ArrayList 都很低效O(N)。比如 Collection 的 contain 和 ...
List-有序集合
weixin_67796933的博客
06-23 9110
目录ListList集合概述和特点List集合特有方法并发修改异常ListIterator增强for循环List集合子类特点LinkedList集合的特有功能先到帮助文档中查看:它在java.util包下,使用它需要导包。是泛型，是List集合中的类型。往下看List是一个接口它继承自Collection接口，所以Collection接口中有的功能List都可以使用。List被称为有序集合也被称为序列。用户可以精确控制列表中每个元素的插入位置。 用户可以通过整数索引（列表中的位置）访问元素，并搜索列表...
List(有序)集合以及五种遍历介绍
weixin_60677044的博客
03-29 1344
继 承 C olle c tio n 接 口 ， 存 储 一 组 可 重 复 的 有 序 对 象元 素 顺 序 以 元 素 插 入 的 顺 序 放 置 元 素 ， 不 重 新 排 序通 过 索 引 访 问 数 组 元 素 ， 索 引 从 0 开 始。
List集合排序
SunnerChen的博客
04-02 1105
对List集合排序
图解数据结构（使用Python）——链表
12-21
概念：链表（Linked List）是由许多相同数据类型的数据按特定顺序排列而成的线性表，其特点是各个数据在计算机内存中的位置是不连续且随机的。 优点： 数据的插入和删除都比较方便，不需要移动大量的数据（列表在...
Java-数据结构课设-链表实现通讯录管理系统
10-07
一、用链表或者顺序表实现以下系统，完成线性表的建立（至少包括10个结点），以及线性表中信息（结点）的插入、查找、删除、修改、输出等操作，具体的模块要求见上方的“总的模块要求”。建议用“文件”存储数据。 1...
数据结构学习笔记——单链表
12-21
链表（linked list）是一种在物理上非连续，非顺序的数据结构，由若干节点（node）组成 单链表每一个节点又包含两部分，1是存放数据的变量data，2是存放指向下一个结点的指针next 双向链表每一个节点包含三部分，在...
C#数据结构与算法揭秘二
01-01
上文对数据结构与算法，有了一个简单的概述与介绍，这篇文章，我们介绍一中典型数据结构——线性结构。 什么是线性结构，线性结构是最简单、最基本、最常用的数据结构。线性表是线性结构的抽象(Abstract)， 线性结构...
数据结构笔记：栈
01-20
原文地址[ 分类目录——数据结构笔记](https://blog.csdn.net/bbjg_001/category_9753496.html) 栈（stack），有些地方也成为堆栈，是一种容器，可存储元素、访问元素、删除...可以通过线性表（顺序表或链表）实现，通
顺序表 list实现方式
u012246617的博客
04-26 221
数据元素本身连续存储，每个元素所占的存储单元大小固定相同，元素的下标是其逻辑地址，而元素存储的物理地址（实际内存地址）可以通过存储区的起始地址Loc (e0)加上逻辑地址（第i个元素）与存储单元大小（c）的乘积计算而得，故，访问指定元素时无需从头遍历，通过计算便可获得对应地址，其时间复杂度为O(1)。 一个顺序表的完整信息包括两部分，一部分是表中的元素集合，另一部分是为实现正确操作而需记录的信息，即有关表的整体情况的信息，这部分信息主要包括元素存储区的容量和当前表中已有的元素个数两项。 顺序表的实现
Java中List排序的3种方法
最新发布
qq_43985303的博客
05-25 2万+
本文介绍了 3 种 List 排序的方法，前两种方法常用于 JDK 8 之前的版本，其中比较器 Comparator 有两种实现的写法，而在 JDK 8 之后的版本，就可以使用 Comparator.comparing 实现排序了，如果排序字段中可能出现 null 值，要使用 Comparator.nullsXXX 进行排序处理（否则会报错）
顺序容器——list
qq_41292216的博客
08-21 518
list相较于vector的连续线性空间，list就显得复杂许多，它的好处是每次插入或删除一个元素，就配置或释放一个空间。因此，list对于空间的利用有绝对的精准，一点也不浪费。而且，对于任何位置的元素的插入或删除，它的时间复杂度都为O(1)。 list容器的底层实际上是一个双向循环链表。 list本身和list的节点的结构是不同的，需要分开设计 list的节点定义： template&l...
java中list存储有顺序吗
evilcry2012的专栏
06-07 2万+
java中list存储有顺序吗 50清河a118 | 浏览 1771 次 |举报我有更好的答案推荐于2018-03-03 11:24:10最佳答案list是有顺的集合，arrayList是用数组实现的，linkList是用链表实现的 本回答由网友推荐举报| 答案纠错 | 评论 2 0C和铉de华丽 采纳率：16% 擅长： JAVA相关 Html/Css 电脑装机/选购其他回答次序是List的最重要...
List 一定有序，Set不一定无序
QEIDJDJ123456的博客
05-10 1万+
首先，我们要明确的一点是，在java中我们通常说的集合有序无序针对的是插入顺序，是指在插入元素时，插入的顺序是否保持，当遍历集合时它是否会按照插入顺序展示。像TreeSet和TreeMap这样的集合主要实现了自动排序，我们称之为排序，而根据前面的定义它不一定是有序的。 所以，在我们常见的集合类型中，有序的有ArrayList，LinkedList，LinkedHashSet，LinkedHashMap等，无序的有HashSet，HashMap，HashTable，TreeSet，TreeMap等，而同时T
List集合排序及去重
qq_41306129的博客
04-24 3872
Comparable 简介 Comparable 是排序接口。 若一个类实现了Comparable接口，就意味着“该类支持排序”。此外，“实现Comparable接口的类的对象”可以用作“有序映射(如TreeMap)”中的键或“有序集合(TreeSet)”中的元素，而不需要指定比较器。 接口中通过x.compareTo(y)来比较x和y的大小。若返回负数，意味着x比y小；返回零，意味着x等于y；返回正数，意味着x大于y。 Comparator 简介 Comparator 是比较器接口。我们若需要控制某个类
顺序容器list
seemeno的博客
04-03 361
顺序容器list 概述 （以下内容参考stl源码剖析） 相较于vector的连续线性空间，list就更为复杂。其好处是每次插入或删除一个元素，就配置或释放一个元素空间。因此list对于任何位置的元素插入或移除，永远是常数。 是一个环状双向链表，只有一个指向空节点的指针node iterator begin(){ return (link_type)((*node).next); } iterato...
List集合的各种排序
热门推荐
yuanfang0907的博客
02-15 11万+
在Java编程中，经常要对List集合进行排序，因此对List排序的各种情况进行总结，希望对各位读者有所帮助。 1.单属性变量List排序 1.1按照变量属性升序，降序排序 /** * 单属性变量list 自身属性升序, 降序排序 */ private void singleVariableSort1(){ List&lt;Integer&gt; list...
有序List
湾区小学生的博客
03-20 1657
有序列表是指列表中的元素是有顺序的，例如从小到大或者从大到小的顺序。 OrderedList()：创建一个新的有序表 add(item)：添加元素 remove(item)：删除item元素 search(item)：查看item是否在有序表中，返回一个布尔值 isEmpty()： 返回一个布尔值，判断有序表是否为空 size()：返回有序表的长度，即元素的个数 index(item)：返回元素...
基本数据结构：链表（list） - C小加 - C++博客
08-04 391
基本数据结构：链表（list） - C小加 - C++博客 基本数据结构：链表（list） - C小加 - C++博客基本数据结构：链表（list）作者：C小加更新时间：2012-7-31谈到链表之前，先说一下线性表。线性表是最基本、最简单、也是最常用的一种数据结...
哈希表设计与实现——链表法
05-10
链表法是一种解决哈希表碰撞问题的方法。具体来说，对于哈希表中的每个桶，可以使用一个链表来存储所有映射到该桶的键值对。如果发生碰撞，只需要将新的键值对添加到链表的末尾即可。 下面是一个使用链表法实现哈希...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

彭彭彭摆鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值