浅谈Java集合框架之List、ArrayList、LinkedList的使用及实现

最新推荐文章于 2022-09-05 14:09:58 发布
最新推荐文章于 2022-09-05 14:09:58 发布
阅读量249 收藏
点赞数
分类专栏： java学习笔记 数据结构与算法 文章标签： 数据结构 链表 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_46078890/article/details/119120458
版权

概览

1.List

List是一个接口继承于Collection接口，数据结构上List代表的是一个线性表
那么对于List接口中的方法有：

  • boolean add(E e) ：尾插
  • void add(int index, E element) ：将 e 插入到 index 位置，同时index之后的元素，必须逻辑向后移
  • E remove(int index)：删除 index 位置元素，同时，index之后的所有元素必须逻辑前移
  • boolean remove(Object o) ：删除遇到的第一个o元素（本质上是使用equals进行比较）
  • E get(int index)：获取下标 index 位置元素
  • E set(int index, E element) ：将下标index位置元素设置为element
  • int size()：返回元素个数
  • void clear()：清空线性表
  • boolean isEmpty()：返回是否是一个空的线性表
  • boolean contains(Object o)：判断o是否在线性表中（本质上是使用equals进行比较）
  • int indexOf(Object o) ：返回第一个o所在下标（本质上是使用equals进行比较）
  • int lastIndexOf(Object o)：返回最后一个o的下标（本质上是使用equals进行比较）
  • List < E > subList(int fromIndex, int toIndex)：截取部分list，不会影响原来的线性表
  • sort (Comparator <?super E>c)：对线性表进行排序，根据传入的比较器排序，可以使用匿名内部类
  • iterator()：返回迭代器，进行从前往后的遍历
  • listIterator()：效果等同于listIterator(0)
  • listIterator(int index)：从index位置开始遍历，下标的计算特殊一点
  • toArray()系列：list转数组
  • Arrays.asList()：数组转list

对于方法使用的注意：

  • remove：如果是 Integer 类型，则remove(int)就是当下标使用，返回删除的元素。如果是remove((Integer)int)，则当元素使用，返回boolean值
  • 对于引用类型的删除，需要在类中重写equals方法
  • 所有的ArrayList或者List其实都可以看做Collection

2. ArrayList

ArrayList 是一个顺序表，是容器，实现了List接口，通过泛型表现变化的元素类型。
除了继承到的方法，ArrayList增加的额外方法有：

  • ArrayList()：无参构造
  • ArrayList(Collection<? extends E> c) ：利用其他 Collection 构建ArrayList
  • ArrayList(int initialCapacity)：指定顺序表初始容量

对ArrayList进行手动的实现：

2.1 仿写真实的List接口

/**
 * 仿写真实的List
 */
public interface List extends Iterable{

    //添加元素
    boolean add(Integer e);

    void add(int index,Integer e);

    //根据下标删除
    Integer remove(int index);
    //根据元素删除
    boolean remove(Integer e);
    //删除第一个遇到的
    Integer get(int index);

    Integer set(int index,Integer e);

    int size();
    void clear();
    boolean isEmpty();

    //包含
    boolean contains(Integer e);

    int indexOf(Integer e);

    int lastIndexOf(Integer e);
}

2.2 仿写真实的ArrayList

public class ArrayList implements List {

    private int[] array;//数组
    private int size;//元素个数

    private int capacity;
    public ArrayList(){
        this.capacity=10;
        this.array = new int[this.capacity];
        this.size=0;
    }
    public ArrayList(int capacity) {
        this.capacity = capacity;
        this.array = new int[capacity];
        this.size=0;
    }

    public ArrayList(List other){
        array = new int[other.size()];
        for(int i=0;i<other.size();i++){
            array[i] = other.get(i);
        }
        this.size = other.size();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        for(int i=0;i<this.size;i++){
            if(i==this.size-1){
                sb.append(array[i]);
            }else{
                sb.append(array[i]+", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }

    /**
     * 扩容
     * 时间复杂度O(n)
     */
    public void dilatation(){
        if(this.size==this.capacity){
            this.capacity*=2;
            //定义新数组 并将老数组内容搬到新数组
            int[] newArray =  Arrays.copyOf(this.array,this.capacity);
            this.array = newArray;
        }
    }
    /**
     * 时间复杂度：平均 O(1)
     * @param e
     * @return
     */
    @Override
    public boolean add(Integer e) {
        dilatation();
        this.array[size++] = e;
        return true;
    }

    /**
     * 时间复杂度：O(n)
     *要把index及之后的所有元素，全部向后移
     * 为了元素不被覆盖，从后往前搬
     * @param index
     * @param e
     */
    @Override
    public void add(int index, Integer e) {
        if(index<0 || index>this.size){
            throw new IndexOutOfBoundsException("下标不合法!");

        }
        dilatation();
        for(int i=this.size;i>index;i--){
            array[i] = array[i-1];
        }
        array[index] = e;
        size++;
    }

    /**
     * 时间复杂度：O(n)
     * 从后往前覆盖
     * @param index
     * @return
     */
    @Override
    public Integer remove(int index) {
        if(index<0 || index>=this.size){
            throw new IndexOutOfBoundsException("下标不合法!");
        }
        int e = array[index];
        for(int i = index;i<this.size-1;i++){
            array[i] = array[i+1];
        }
        this.size--;
        return e;
    }

    /**
     * 时间复杂度：O(n)
     * @param e
     * @return
     */
    @Override
    public boolean remove(Integer e) {

        int index = indexOf(e);
        if(index!=-1){
            remove(index);
            return true;
        }else{
            return false;
        }

    }

    /**
     * 时间复杂度：O(1)
     * @param index
     * @return
     */
    @Override
    public Integer get(int index) {
        if(index<0||index>=this.size){
            throw new IndexOutOfBoundsException("下标不合法!");
        }
        return array[index];
    }

    /**
     * 时间复杂度：O(1)
     * @param index
     * @param e
     * @return
     */
    @Override
    public Integer set(int index, Integer e) {
        if(index<0||index>=this.size){
            throw new IndexOutOfBoundsException("下标不合法!");
        }
        Integer oldData = array[index];
        array[index] = e;
        return oldData;
    }

    /**
     * 时间复杂度：O(1)
     * @return
     */
    @Override
    public int size() {
        return this.size;
    }

    /**
     * 时间复杂度：O(n)
     */
    @Override
    public void clear() {
        //-1代表无效值
        Arrays.fill(array,-1);
        this.size=0;
    }

    /**
     * 时间复杂度：O(1)
     * @return
     */
    @Override
    public boolean isEmpty() {
        return this.size==0;
    }

    /**
     * 时间复杂度：O(n)
     * @param e
     * @return
     */
    @Override
    public boolean contains(Integer e) {

        return indexOf(e)!=-1;
    }

    /**
     * 时间复杂度：O(n)
     * @param e
     * @return
     */
    @Override
    public int indexOf(Integer e) {
        for(int i=0;i<this.size;i++){
            if(array[i]==e){
                return i;
            }
        }
        return -1;
    }

    /**
     * 时间复杂度：O(n)
     * @param e
     * @return
     */
    @Override
    public int lastIndexOf(Integer e) {
        for(int i=this.size-1;i>=0;i--){
            if(array[i]==e){
                return i;
            }
        }
        return -1;
    }

    @Override
    public Iterator iterator() {
        //返回一个Iterator接口的实现类的对象
        return new ArrayListIterator(this);
    }
}

2.3 仿写真实的Iterator接口（迭代器）

  • 迭代器互相之间独立
  • 迭代遍历的同时，不允许修改list的结构
  • 如果确实需要删除，需要使用迭代器中的remove方法，可以删除当前迭代到的位置
/**
 * 仿写真实的Iterator接口
 * 迭代器
 */
public interface Iterator {
	//返回true，表示本次迭代还没有把所有的数据遍历完
    boolean hasNext();
    //返回要遍历的下一个元素
    Integer next();
    void remove();
}

2.4 仿写真实的Iterable接口

iterate迭代，一个一个遍历

  • 如果一个类实现了Iterable接口，则表示这个类具备迭代的能力，隐含着，这个类的对象实际上表示一个容器
  • 该类通过返回一个迭代器（Iterator），可以通过这个迭代器进行容器内的元素的迭代
/**
 * 仿写真实的Iterable接口
 * 具备迭代能力 使用了依赖了Iterator接口
 */
public interface Iterable {
    Iterator iterator();
}

2.5 Iterator的实现类ArrayListIterator

/**
Iterator的实现类 用于给ArrayList中传递
*/
public class ArrayListIterator implements Iterator{
    private int index;
    private ArrayList list;
    //对一个顺序表做迭代，关键是控制下标


    public ArrayListIterator(ArrayList list) {
        this.index = 0;
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        return index<list.size();
    }

    @Override
    public Integer next() {
        return list.get(index++);
    }

    @Override
    public void remove() {
        //TODO
    }
}

2.6 泛型的ArrayList

重点对于构造方法、两种toArray方法、indexOf、clear进行实现

/**
 * 泛型的ArrayList
 * clear或者其他删除的时候，除了修改size，一定要把从List中删除掉的元素置为null，以免内存泄露
 * contains/indexOf/lastIndexOf等方法，都随时可能调用元素的equals方法
 * toArray的两种实现
 */
public class MyArrayList<E> implements List<E> {
    private E[] array;
    private int size;

    public MyArrayList() {
        //无法直接定义泛型数组，所以只能定义Object类型数组 然后强转
        this.array = (E[])new Object[10];
        this.size = 0;
    }
    @Override
    public int size() {
        return this.size;
    }

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

    @Override
    public boolean contains(Object o) {
        return indexOf(o)!=-1;
    }

    @Override
    public Iterator<E> iterator() {
        return null;
    }

    /**
     *
     * @return
     */
    @Override
    public Object[] toArray() {
        Object[] a = new Object[size];
        for(int i=0;i<this.size;i++){
            a[i] = array[i];
        }
        return a;
    }

    /**
     * 传进来的数组 长度小于size创建一个新数组返回
     * 大于size将元素放进去，并将size处元素置为null
     * 等于size，将元素放进去返回
     * @param a
     * @param <T>
     * @return
     */
    @Override
    public <T> T[] toArray(T[] a) {
        if(a.length<size){
            //创建一个数组直接返回
            T[] newArray = (T[])new Object[size];
            for(int i=0;i<size;i++){
                newArray[i] = (T)array[i];
            }
            return newArray;
        }else if(a.length==size){
            //把元素放入并返回

            for(int i=0;i<size;i++){
                a[i] = (T)array[i];
            }
            return a;
        }else{
            //把元素放入并返回
            //把超过的第一个位置设置为null
            for(int i=0;i<size;i++){
                a[i] = (T)array[i];
            }
            a[size] = null;
            return a;
        }

    }

    @Override
    public boolean add(E e) {

        array[size++] = e;
        return true;
    }

    @Override
    public boolean remove(Object o) {
        int i = indexOf(o);

        if(i==-1){
            return false;
        }else{
            remove(i);
            return true;
        }

    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends E> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {
        //如果是基本类型，数组中元素是否需要清理成无效值其实无所谓
        //但如果是引用类型，必须把数组中的元素修改为null，这样不会内存泄露
        Arrays.fill(array,null);
        this.size=0;
    }

    @Override
    public E get(int index) {
        return array[index];
    }

    @Override
    public E set(int index, E element) {
        E oldData = array[index];
        array[index] = element;
        return oldData;
    }

    @Override
    public void add(int index, E element) {

    }

    @Override
    public E remove(int index) {
        return null;
    }

    /**
     *
     * @param o
     * @return
     */
    @Override
    public int indexOf(Object o) {
        for(int i=0;i<this.size;i++){
            if(o==null){
                if(array[i]==o){
                    return i;
                }
            }else{
                if(array[i].equals(o)){
                    return i;
                }
            }
        }
       return -1;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<E> listIterator() {
        return null;
    }

    @Override
    public ListIterator<E> listIterator(int index) {
        return null;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        return null;
    }
}

3. LinkedList

List的实现类，数据结构是链表（双向链表，记录了第一个和最后一个节点）
除了继承的方法外，新增的方法只有一个无参的构造方法

对于LinkedList的手动实现：前面的List接口、Iterator接口、Iterable接口直接使用

3.1 节点类（Node）

public class Node {
   public Node prev;
   public Node next;
   public Integer element;

    public Node(Integer element) {
        this.element = element;
    }
}

3.2 仿写真实的LinkedList

public class LinkedList implements List{

    public Node head; //指向第一个节点
    public Node last;//指向最后一个节点
    public int size;

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        for(Node cur = this.head;cur!=null;cur = cur.next){
            sb.append(cur.element);
            if(cur!=last){
                sb.append(", ");
            }
        }
        sb.append("]");

        return sb.toString();

    }

    /**
     * 尾插   时间复杂度 O(1)
     * @param e
     * @return
     */
    @Override
    public boolean add(Integer e) {

        Node node = new Node(e);

        if(size==0){//判空
            this.head = this.last = node;

        }else{
            this.last.next = node;
            node.prev = this.last;
            this.last = node;
        }
        size++;
        return true;
    }

    /**
     * O(n)
     * @param index
     * @param e
     */
    @Override
    public void add(int index, Integer e) {
        if(index<0 || index>size){
            throw new IndexOutOfBoundsException("下标越界!");
        }
        Node node = new Node(e);
        //index==0 头插
        if(index==0){
            if(this.size==0){
                this.head = node;
                this.last = node;
            }else{
                node.next = this.head;
                this.head.prev = node;
                this.head = node;
            }
            this.size++;
            return;
        }else if(index==this.size){ //index==size 调用尾插
            add(e);
        }else{
            //中间插入
            //跳index不部找插入位置，也可以跳index-1步找前驱位置
            Node cur = null;
            if(index<size/2){
                cur = this.head;
                while(index>0){
                    cur = cur.next;
                    index--;
                }
            }else{
                cur = this.last;
                while(this.size-1-index>0){
                    cur = cur.prev;
                    index++;
                }
            }
            node.next = cur;
            cur.prev.next = node;
            node.prev = cur.prev;
            cur.prev = node;

            this.size++;
        }

    }

    /**
     * O(n)
     * @param index
     * @return
     */
    @Override
    public Integer remove(int index) {
        if(index<0 || index>=this.size){
            throw  new IndexOutOfBoundsException("下标非法!");
        }
        Integer v = 0;
        //index==0 头删
        if(index==0){
            if(this.head!=null&&this.head.next==null){
                v = this.head.element;
                this.head = null;
                this.last = null;

            }else{
                v = this.head.element;
                this.head = this.head.next;
                this.head.prev = null;
            }
            size--;

        }else if(index==this.size-1){// 尾删
            v = this.last.element;
            this.last = this.last.prev;
            this.last.next = null;
            size--;
            if(size==0){
                head=null;
            }
        }else{
            Node cur = null;
            if(index<size/2){
                cur = this.head;
                while(index>0){
                    cur = cur.next;
                    index--;
                }
            }else{
                cur = this.last;
                while(this.size-1-index>0){
                    cur = cur.prev;
                    index++;
                }
            }
            v = cur.element;
            cur.prev.next = cur.next;
            cur.next.prev = cur.prev;
            size--;
        }
        return v;
    }

    /**
     * O(n)
     * @param e
     * @return
     */
    @Override
    public boolean remove(Integer e) {
        for(Node cur = this.head;cur!=null;cur = cur.next){
            if(cur.element.equals(e)){
                if(cur.prev==null){
                    remove(0);
                }else if(cur.next==null){
                    remove(this.size-1);
                }else{
                    cur.prev.next = cur.next;
                    cur.next.prev = cur.prev;
                    size--;
                }
                return true;
            }
        }
        return false;
    }

    /**
     * O(n)
     * @param index
     * @return
     */
    @Override
    public Integer get(int index) {
        if(index<0 || index>=this.size){
            throw  new IndexOutOfBoundsException("下标非法!");
        }
        Node cur = this.head;
        for(int i=0;i<this.size;i++){
            cur = cur.next;
        }
        return cur.element;
    }

    /**
     * O(n)
     * @param index
     * @param e
     * @return
     */
    @Override
    public Integer set(int index, Integer e) {
        if(index<0 || index>=this.size){
            throw  new IndexOutOfBoundsException("下标非法!");
        }
        Node cur = this.head;
        for(int i=0;i<this.size;i++){
            cur = cur.next;
        }
        Integer v = cur.element;
        cur.element = e;
        return v;
    }

    /**
     * O(1)
     * @return
     */
    @Override
    public int size() {
        return this.size;
    }

    @Override
    public void clear() {
        this.head = this.last = null;
        this.size = 0;
    }

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

    @Override
    public boolean contains(Integer e) {
        return indexOf(e)!=-1;
    }

    /**
     * O(n)
     * @param e
     * @return
     */
    @Override
    public int indexOf(Integer e) {
        Node cur = this.head;
        int index=0;
        while(cur!=null){
            if(cur.element.equals(e)){
                return index;
            }
            index++;
            cur = cur.next;
        }
        return -1;
    }

    /**
     * O(n)
     * @param e
     * @return
     */
    @Override
    public int lastIndexOf(Integer e) {
        Node cur = this.last;
        int index=0;
        while(cur!=null){
            if(cur.element.equals(e)){
                return this.size-index-1;
            }
            index++;
            cur = cur.prev;
        }
        return -1;
    }

    @Override
    public Iterator iterator() {
    	//返回一个Iterator的实现类
        return new LinkedListIterator(this);
    }
}

3.3 Iterator的实现类LinkedListIterator

public class LinkedListIterator implements Iterator{
    private LinkedList list;
    private Node cur;

    public LinkedListIterator(LinkedList list) {
        this.list = list;
        this.cur = list.head;
    }

    @Override
    public boolean hasNext() {
        return cur!=null;
    }

    @Override
    public Integer next() {
        Integer v = cur.element;
        cur = cur.next;
        return v;
    }

    @Override
    public void remove() {
        //TODO
    }
}

4. ArrayList 和LinkedList的区别

从以下几方面考虑：

  • 每个方法做什么用，参数列表和返回值是什么
  • 大概描述每个方法的具体实现
  • 每个方法的时间复杂度
  • 有些方法有部分特殊点
Java 链表 (LinkedList)（详细）
diaolove的博客
02-04 1303
链表 一、什么是链表 ？1、链表简介2、链表的分类：二、Linkedlist架构图 一、什么是链表 ？ 1、链表简介 链表（Linkedlist）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。 它是一个集合，可以根据索引来随机的访问集合中的元素，还实现了Deque接口 它还是一个队列，可以当成双端队列来使用。 虽然LinkedList是一个List集合，但是它的实现方式和ArrayList是完全不同的，ArrayList的底层是通过一个动态
Java系列之：List集合子类ArrayList和LinkedList
zhengzaifeidelushang的博客
04-24 467
Java系列之：List集合子类ArrayList和LinkedList一、List集合子类特点二、LinkedList集合的特有功能 一、List集合子类特点 List集合常用子类：ArrayList、LinkedList ArrayList：底层数据结构是数组，查询快，增删慢 LinkedList：底层数据结构是链表，查询慢，增删快 数据库对象： import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data;
关于List集合类ArrayList、LinkedList、Vector详解
扎哇太枣糕的笔记博客
06-02 1093
  各位小伙伴们大家好，欢迎来到这个小扎扎的《Java核心技术 卷Ⅰ》笔记专栏，在这个系列专栏中我将记录浅学这本书所得收获，鉴于 看到就是学到、学到就是赚到 精神，这波简直就是血赚
Java学习笔记⑯（数据结构栈（队列、数组、链表、红黑树），List集合（List集合介绍以及常用方法、LinkList集合））
weixin_45994391的博客
11-29 394
一、数据结构 1. 栈和队列 2. 数组 3. 链表 4. 红黑树
Java-集合框架(List集合ArrayList，LinkedList，HashSet,TreeSet,Map，HashMap及其原理)
Have_MonkeyG的博客
04-15 1269
List集合ArrayList，LinkedList，HashSet,TreeSet,Map，HashMap及其原理
浅谈JAVA集合框架及其应用.pdf
06-27
本文将从源码分析角度出发，深入探讨Java集合框架中常用的接口和实现类的底层数据结构及其特点，并探讨其在实际业务开发中的应用选择。 Java集合框架中的数据结构主要分为两大类：Collection集合和Map集合。...
浅谈JAVA集合框架及其应用.zip
10-16
Java集合框架是Java编程语言中一个至关重要的组成部分，它为数据存储、管理和处理提供了丰富的类和接口。这个框架包括了数组、链表、队列、堆栈、映射等多种数据结构，极大地提高了开发效率和代码的可读性。在本文中...
浅谈java集合框架
07-19
### 浅谈Java集合框架 Java集合框架是一个用于存储、操作和检索一组对象的强大工具集。集合框架的设计目的是为了提供一套高效且灵活的数据结构来满足不同的应用需求。本篇文章将详细探讨Java集合框架中的一些核心...
浅谈Java中常用数据结构的实现类Collection和M
10-31
首先，Collection是Java集合框架的顶层接口，它是所有单值容器的父接口。Collection接口定义了对一组对象进行操作的基本方法，如添加元素(add)，删除元素(remove)，检查元素是否存在(contains)等。Collection的主要...
浅谈java集合类以及示例
12-20
Java集合框架是Java编程语言中不可或缺的一部分，它提供了一种高效、灵活的数据组织方式。本文将深入探讨Java集合类的基本概念、分类以及示例。 首先，Java中的集合分为两大类：一种是以单个元素存储的集合，它们...
day19知识点总结：集合框架提供的接口和方法 List、ArrayList、LinkedList、Map、HashMap
m0_48279672的博客
07-14 226
集合框架的好处：容量可扩展 java集合框架提供一组 性能优良的 接口和类 他们位于java.util包中 Collection、List、Set、Map是接口 ArrayList、LinkedList、HashMap是实现类 面试问：Collection和Collections的区别？ 答：Collection是接口，Collections是算法。Collection接口存储一组不唯一、无序的对象。 不唯一：可以在集合里存很多个a 无序：存进去之后不会按照原来的顺序List接口存储一组不唯一、有序的对
java集合之List接口的常用实现类、ArrayList、LinkedList、Vector
Q2854542067的博客
05-02 1723
Collection接口的常用方法， 以子类ArrayList实现类来演示: add():添加单个元素 remove():删除指定元素 contains():查找元素是否存在 size():获取元素个数 isEmpty()判断是否为空 clear():清空 addAll():添加多个元素 contaisnAll():查找多个元素是否都存在 removeAll():删除多个元素 如下演示： import java.util.Collection; import java.util.ArrayList; im
30.Java之List集合类（List 接口常用方法、ArrayList 类、Vector 类、LinkedList 类）
qq_46656580的博客
01-06 453
30.1.List 接口基本介绍 List 接口是 Collection 接口的子接口 List 集合类中元素有序（即 添加顺序 和 取出顺序 一致，不是指元素值大小排列顺序）、且可重复 List 集合中的每个元素都有其对应的顺序索引，即支持索引 List 容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素 30.2.List 接口常用方法 List 集合里添加了一些根据索引来操作集合的方法 void add(int index, Object ele)：在 ind
JAVA集合——List系列（ArrayList、LinkedList）
weixin_65049289的博客
03-28 941
JAVA——List集合（适合初学者的笔记）
数据结构-链表(LinkedList)介绍与实现
qq_39225639的博客
09-01 2043
数据结构-链表介绍链表的特点链表和数组的区别优点缺点链表的组成链表的常见方法链表的实现 介绍 链表和数组一样，都用来存储一系列的元素。但是链表和数组实现的机制完全不同。从而导致其相关操作的效率也有所不同。 链表的特点 链表是一种物理存储单元上非连续、非顺序的存储结构 链表直观形态，每个节点元素都有保存了下一个节点的引用，头部指向第一个节点，最后一个节点指向null。 链表和数组的区别 优点 链表存储空间是非连续的而数组的存储空间是连续的。因此链表的内存利用率会更高一点。 链表在头部插入元素和中间插入
ArrayList、LinkedList、Hashmap原理和区别
Haim
03-13 435
ArrayList 原理：底层实现的是一个连续的数组，所以它具备数组的一些特性，如下图 特性：查询快，因为数组存储在的是内存，所以查询操作直接的内存的操作。而且数组对应的是有下标的，查询可以根据下标查，可以快速查询到 插入慢，因为插入的时候，为了保证数组的连续性，插入后面的值都需要相应变更，就比如100个人排队在一起，你插入到第三，对应的后面的所有的人都要逐级移动一位 LinkedList 原理：底层是双向链表结构，如下图，每个node里面存在first，last这样的元素，然后前一个node的last关
List集合的特有API，以及List的四种遍历方式小结及异同
wujianrenn的博客
12-01 403
一、特点 分为：ArrayList 和LinkedList ；均有序，可重复，有索引 二、特有API 缘由：List集合因为支持索引，所以多了很多索引操作的独特API，其他Collection的功能List也都 继承了 （1）Array的特有API package List.API; public class ArrayListDemo { public static void main(String[] args) { //1.创建一个...
Java——集合之List、ArrayList、LinkedList
smile4548656的博客
04-19 1127
Java——集合之List、ArrayList、LinkedList
常用集合List、ArrayList、LinkedList的使用方法。
Geraige的博客
09-05 589
10、remove(Object o)： 移除集合中第一次出现的指定元素，移除成功返回true，否则返回false。boolean add(E e)：在链表后添加一个元素，如果成功，返回true，否则返回false；7、isEmpty()： 判断列表是否包含元素，不包含元素则返回 true，否则返回false。9、remove(int index)： 移除列表中指定位置的元素，并返回被删元素。3、get(int index)： 返回列表中指定位置的元素，index从0开始。
Java集合框架详解：ArrayList与LinkedList
"Java集合框架的学习总结" 在Java编程中，集合框架是一组接口和类，它们提供了用于存储和操作对象的结构。这个框架使得开发者能够更有效地管理内存中的数据，无论是简单的列表还是复杂的映射关系。以下是关于Java...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值