【JAVA-通过List＜E＞接口实现数组与链表】

于 2024-02-22 22:37:27 发布
阅读量827 收藏 28
点赞数 15
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZERO_HOPE/article/details/135575321
版权
本文详细介绍了如何用Java实现自定义List接口，包括使用数组（如ArrayList）和链表（如LinkedList）的方法实现，以及它们之间的区别，如数组支持动态数组和链表的高效插入/删除特性。
摘要由CSDN通过智能技术生成

首先，我们查看List类源代码，查看其中方法，然后用java实现一个我们自己的List<E> 接口类，选择原有List中的大部分方法，利用此接口实现数组以及链表。

零、List接口

首先定义接口 List<E> ，以下是对每个方法的详细解释：
int size(): // 返回列表中元素的数量。

boolean isEmpty(): //判断列表是否为空，如果为空则返回true，否则返回false。

boolean contains(Object o): //判断列表是否包含指定的元素。如果包含则返回true，否则返回false。

Object[] toArray(): //将列表转换为一个数组。

boolean add(Object o): //将指定的元素添加到列表的末尾，并返回true。

boolean remove(Object o): //从列表中移除指定的元素，如果成功移除则返回true，否则返回false。

boolean containsAll(List<E> c): //判断列表是否包含另一个集合中的所有元素，如果是则返回true，否则返回false。

boolean addAll(List<? extends E> c): //批量添加，将另一个集合中的所有元素添加到列表的末尾，如果成功添加则返回true。

boolean addAll(int index, List<? extends E> c): //在指定位置插入另一个集合中的所有元素。

boolean removeAll(List<?> c): //移除列表中与另一个集合相同的所有元素。

void clear(): //移除列表中的所有元素，使其为空。

E get(int index): //返回指定位置的元素。

E set(int index, E element): //将指定位置的元素替换为新的元素，并返回原来的元素。

void add(int index, E element): //在指定位置插入一个元素。

E remove(int index): //移除并返回指定位置的元素。

int indexOf(Object o): //返回指定元素在列表中第一次出现的位置索引，如果不存在则返回-1。

一、数组

查看ArrayList的实现，可以看到ArrayList类继承自AbstractList类，而AbstractList类又实现了List接口。

我们同样利用定义的接口List<E>，创建MyArrayList类来实现其中方法。

  • MyArrayList类实现了 List 接口，并使用泛型来表示列表的元素类型。
  • 类中的成员变量：
value: 用于存储列表元素的数组，初始长度为零。
size: 当前列表中的元素个数。
length: 表示数组当前的长度，即最大容量。
DEFAULT_LENGTH: 默认的最大容量，设定为30。

1. MyArrayList 类 

构造方法：根据传入的 initiallength 初始化数组长度，但不允许小于等于零。
如果 initiallength 小于等于默认容量（30），则使用默认容量初始化数组。
否则，使用传入的 initiallength 初始化数组。
public MyArrayList (int initiallength){
        if (initiallength <= 0){
            throw new IllegalArgumentException("initiallength 不能小于0");
        }
        if (initiallength <= 30){
            length = DEFAULT_LENGTH;
            value = new Object[length];
            size=0;
        }
        else{
            length = initiallength;
            value = new Object[length];
            size=0;
        }
    }

2.方法实现：

import java.util.Arrays;

public class MyArrayList<E> implements List<E> {

    //类成员变量
    Object[] value = {};    //长度为零的数组
    private int size;//当下坐标，当前存储的元素个数
    private int length;//表示数组当前的长度 最大容器
    private static final int DEFAULT_LENGTH = 30;//默认最大容量

    //构造方法
    public MyArrayList(int initiallength){
        if(initiallength <= 0){
            throw new IllegalArgumentException("初始长度initiallength不能小于0");
        }
        if (initiallength <= 30 ){
            length = DEFAULT_LENGTH;
            value = new Object[length];
            size = 0;
        }
        else{
            length = 30;
            value = new Object[length];
            size = 0;
        }
    }

    //元素个数
    @Override
    public int size() {
        return size;
    }

    //是否为空
    @Override
    public boolean isEmpty() {
        return size==0;
    }

    //是否包含指定元素
    @Override
    public boolean contains(Object o) {
        for (int i = 0; i < size; i++) {
            if(value[i].equals(o)){
                return true;
            }
        }
        return false;
    }

    //将列表转换为数组
    @Override
    public Object[] toArray() {
        return Arrays.copyOf(value,size);
    }

    //向列表中添加元素
    @Override
    public boolean add(Object o) {
        if(size <= DEFAULT_LENGTH){
            value[size++] = o;
        }
        return true;
    }

    //从列表中移除指定的元素
    @Override
    public boolean remove(Object o) {
        for (int i = 0; i < size; i++) {
            if (value[i].equals(o)){
                value = null;
                for (int x = i; x < size; x++) {
                    value[x] = value[i+1];
                }
            }
        }
        return true;
    }

    //判断列表是否包含另一个集合中的所有元素
    @Override
    public boolean containsAll(List c) {
        for (int i = 0; i < c.size(); i++) {
            Object element = c.get(i);
            boolean found = false;

            for (int j = 0; j < size; j++) {
                if (value[j].equals(element) && value[j]!= null){
                    found = true;
                    break;
                }
            }

            if (!found){
                return false;
            }
        }
        return true;
    }

    //将另一个集合中的所有元素添加到列表末尾
    @Override
    public boolean addAll(List<? extends E> c) {
        for (int i = 0; i < c.size(); i++) {
            Object element = c.get(i);
            value[size++]=element;
        }
        return true;
    }

    //在指定位置插入另一个集合中的所有元素
    @Override
    public boolean addAll(int index, List<? extends E> c) {
        if(index < 0 || index > size ){
            throw new IllegalArgumentException("Index is out of bounds. Index: \" + index + \", Size: \" + size");
        }

        int newSize = size + c.size();

        if (newSize > length){
            int newCapacity = Math.max(length*2,newSize);
        }

        for (int i = size - 1; i >= index ; i--) {
            value[i+c.size()] = value[i];
        }

        for (int i = 0; i < c.size(); i++) {
            value[index+i] = c.get(i);
        }
        size = newSize;
        return true;
    }



    //移除列表中与另一个集合相同的所有元素.
    @Override
    public boolean removeAll(List c) {
        for (int i = 0; i < c.size(); i++) {
            Object element = c.get(i);
            for (int j = 0; j < size; j++) {
                if(value[j] ==element){
                    value[j] = null;
                    for (int k = j; k < size; k++) {
                        value[k] = value[k+1];
                    }
                }
            }
        }
        return false;

    }

    //移除列表中的所有元素
    @Override
    public void clear() {
        for (int i = 0; i < size; i++) {
            value[i]=null;
        }
        size = 0;
    }

    //获取指定位置的元素
    @Override
    public E get(int index) {
        if (index >= 0 &&  index < size){
            return (E) value[index];
        }else{
            throw new IllegalArgumentException("index 超过了范围 max:"+(size-1));
        }
    }

    //替换指定位置的元素
    @Override
    public E set(int index, E element) {
        value[index] = element;
        return (E) value[index];
    }

    //在指定位置插入一个元素
    @Override
    public void add(int index, E element) {
        //index后的元素向后移动一个位置
        for(int i=size; i>index; i--){
            value[i-1]=value[i];
        }
        value[index]=element;
    }

    @Override
    public E remove(int index) {
        //移除指定位置的元素
        if(index<0||index>size-1) {
            throw new ArrayIndexOutOfBoundsException("index 超过了范围 max:" + (size - 1));
        }else {
            value[index] = null;
            for (int i = index; i < size; i++) {
                value[i]= value[i+1];
            }
        }
        return null;
    }

    //获取第一个匹配元素的索引
    @Override
    public int indexOf(Object o) {
        for (int i = 0; i < size; i++) {
            if (value[i].equals(o)){
                return i;
            }
        }
        return -1;
    }

}

3.数组的特点：

  1. 连续的内存空间： 数组中的元素在内存中是连续存储的，这使得对数组的随机访问和遍历操作非常高效。
  2. 相同数据类型： 数组中的元素必须是相同的数据类型，这是因为数组是一个固定大小的结构，每个元素占据相同的内存空间。
  3. 固定大小： 数组的大小是固定的，一旦创建，其大小通常不能动态改变。
  4. 随机访问： 由于元素的连续存储，可以通过索引直接访问数组中的任何元素，使得随机访问变得非常高效。

常见的数组操作包括：

  1. 访问元素： 通过索引可以快速访问数组中的任何元素。
  2. 插入元素： 在数组中插入元素可能需要将后续元素向后移动，这可能是一个耗时的操作。
  3. 删除元素： 删除数组中的元素同样可能需要将后续元素向前移动，同样可能是一个耗时的操作。
  4. 遍历： 遍历数组中的所有元素，执行特定的操作。
  5. 查找元素： 在数组中查找特定元素，可以使用线性查找或者二分查找等算法。
  6. 更新元素： 修改数组中特定位置的元素值。

二、链表

查看LinkedList，知晓其实现了 List 接口和 Deque 接口，而它本身是直接继承自 AbstractSequentialList 类。

接下来是一个使用链表实现的自定义泛型列表类 MyLinkedList，实现了之前提到的 List 接口。

1.Node 类：

Node<E> 是一个节点类，包含一个数据域 value 和一个指向下一个节点的引用 next。
构造方法 Node(E o, Node<E> next) 用于初始化节点。

class Node<E> {
    E value;
    Node<E> next;
 
    public Node(E o, Node<E> next){
        this.value = o;
        this.next = next;
    }
}
2.MyLinkedList 类：
  • 实现了 List 接口，使用泛型来表示列表的元素类型。
  • 成员变量包括 root（链表的头节点）、last（链表的尾节点）、size（链表中的元素个数）
public class TLinkedList<E> implements List{
    Node<E> root;
    Node<E> last;
    int size;
}
3.方法实现
package day01_ArrayList_LinkList;


public class MyLinkedList<E> implements List{
        Node<E> root;
        Node<E> last;
        int size;

    //两种构造方法：
    //接受一个元素作为参数，创建包含该元素的链表
    public MyLinkedList(E e){
        if(e == null){
            throw new NullPointerException ("o：" + e);
        }
        root = new Node<>(e, null);
        size++;
    }
    //无参数构造方法，用于创建空链表。
    public MyLinkedList(){ }

    //——————————主要方法实现——————————————

    //返回链表中的元素个数
    @Override
    public int size() {
        return size;
    }

    //判断链表是否为空
    @Override
    public boolean isEmpty() {
        return size==0;
    }

    //判断链表是否包含指定元素
    @Override
    public boolean contains(Object o) {
        Node tempNode = root;
        while (tempNode!=null){
            if(tempNode.value.equals(o)){
                return true;
            } else {
               tempNode = tempNode.next;
            }
        }
        return false;
    }

    // 将链表转换为数组
    @Override
    public Object[] toArray() {
        Object[] array = new Object[size];
        Node<E> temoNode = root;
        int index = 0 ;

        while (temoNode != null){
            array[index++] = temoNode.value;
            temoNode = temoNode.next;
        }
        return new Object[0];
    }

    //向链表末尾添加元素
    @Override
    public boolean add(Object o) {
        //判断root是否为null
        if (root == null){
            root = new Node<>((E)o,null);
            size++;
            return true;
        }

        //循环查找 最后一个节点 迭代
        Node<E> tempNode = root;
        while (tempNode != null ){
            tempNode = tempNode.next;
        }
        tempNode.next = new Node<>((E)o,null);
        size++;
        return true;
    }

    //从链表中移除指定元素
    @Override
    public boolean remove(Object o) {
        Node<E> tempNode = root;
        while (tempNode != null ){
            if(tempNode.value.equals(o)){
                tempNode.value = tempNode.next.value;
                tempNode.next = tempNode.next.next;
            }
            tempNode = tempNode.next;
        }
        size --;
        return true;
    }

    //判断链表是否包含另一个集合中的所有元素
    @Override
    public boolean containsAll(List c) {
        for (int i = 0; i < c.size(); i++) {
            Object element = c.get(i);
            boolean found = false;
            Node<E> tempNode = root ;
            while (tempNode != null){
                if (tempNode.value.equals(element)){
                    found = true;
                    break;
                }else {
                    tempNode = tempNode.next;
                }
            }
            if(!found){
                return false;
            }
        }
        return true;
    }

    //将另一个集合中的所有元素添加到链表末尾
    @Override
    public boolean addAll(List c) {
        if (c == null) {
            throw new IllegalArgumentException("The input list cannot be null");
        }

        for (int i=0 ; i < c.size() ; i++) {
            Object element = c.get(i);
            // 判断 root 是否为null
            if(root == null){
                root = new Node<>( (E)element, null);
                size++;
            }
            // 循环查找 最后一个节点
            Node<E> tempNode = root;
            while(tempNode.next != null){
                // 替换
                tempNode = tempNode.next;
            }
            tempNode.next = new Node<>((E)element, null);
            size++;
        }
        return true;
    }

    //在指定位置插入另一个集合中的所有元素
    @Override
    public boolean addAll(int index, List c) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        for (int i = 0; i < c.size(); i++) {
            Object element = c.get(i);

            if (index == 0) {
                // 在链表头部插入新节点
                root = new Node<>((E) element, root);
            } else {
                Node<E> tempNode = root;
                for (int j = 0; j < index - 1; j++) {
                    tempNode = tempNode.next;
                }
                tempNode.next = new Node<>((E) element, tempNode.next);
            }
            size ++;
            index ++;
        }
        return true;
    }

    //移除链表中的所有元素
    @Override
    public void clear() {
        Node<E> tempNode = root;
        while(tempNode != null){
            // 替换
            tempNode.value = null;
            tempNode = tempNode.next;
        }
        size = 0;
    }

    //获取指定位置的元素
    @Override
    public Object get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        Node<E> tempNode = root;
        for (int i = 0; i < index; i++) {
            tempNode = tempNode.next;
        }
        return tempNode.value;
    }

    //替换指定位置的元素
    @Override
    public Object set(int index, Object element) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }

        Node<E> tempNode = root;
        for (int j = 0; j < index; j++) {
            tempNode = tempNode.next;
        }
        tempNode.value = (E) element;// 直接更新指定索引处节点的值
        return true;
    }


    //在指定位置插入一个元素
    @Override
    public void add(int index, Object element) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        if (index == 0) {
            // 插入到链表头部
            root = new Node<>((E) element, root);
        } else {
            Node<E> tempNode = root;
            //遍历到index前一个Node
            for (int i = 0; i < index - 1; i++) {
                tempNode = tempNode.next;
            }
            //tempNode.next指向了原先索引位置的节点
            tempNode.next = new Node<>((E) element, tempNode.next);//
        }
        size++;
    }

    //移除指定位置的元素
    @Override
    public Object remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        Node<E> tempNode = root;
        for (int j = 0; j < index-1; j++) {
            tempNode = tempNode.next;
        }
        tempNode.next=tempNode.next.next;
        size--;
        return true;
    }


    //获取第一个匹配元素的索引
    @Override
    public int indexOf(Object o) {
        int index=0;
        Node<E> tempNode = root;
        while(tempNode != null){
            if(tempNode.value == o){
                return index;
            }else{
                tempNode = tempNode.next;
                index=index+1;
            }
        }
        return -1;
    }

    //移除链表中与另一个集合相同的所有元素
    @Override
    public boolean removeAll(List c) {

        boolean modified = false;

        for (int i = 0; i < c.size(); i++) {
            Object element = c.get(i);
            Node<E> tempNode = root;
            Node<E> prevNode = null;

            while (tempNode != null) {
                if (tempNode.value.equals(element)) {
                    if (prevNode == null) {
                        // 移除头节点
                        root = tempNode.next;
                    } else {
                        prevNode.next = tempNode.next;
                    }

                    size--;
                    modified = true;
                    break;  // 一旦找到并移除元素，就退出循环
                }

                prevNode = tempNode;
                tempNode = tempNode.next;
            }
        }
        return modified;
    }
}

4.链表的特点

  1. 非连续存储：链表中的元素在内存中不是连续存储的，而是通过指针（引用）相互连接起来的。

  2. 动态插入与删除：由于链表中的元素不需要连续存储，因此在链表中插入和删除节点非常高效，平均时间复杂度为O(1)。

  3. 随机访问性能较差：由于链表中的元素不是连续存储的，因此不能像数组一样通过索引直接访问元素，而是需要通过遍历链表来找到指定位置的元素。

  4. 不浪费内存空间： 链表可以动态分配内存，不需要预先指定固定大小，因此不会浪费内存

  5. 链表的种类：单向链表、双向链表和循环链表是常见的链表类型。单向链表中每个节点只有一个指向下一个节点的指针；双向链表中每个节点有一个指向下一个节点的指针和一个指向前一个节点的指针；循环链表是一种特殊的链表，其中尾节点指向头节点，形成一个环状结构。

三、两者区别（可进行拓展）

ArrayList类继承自AbstractList类，而AbstractList类又实现了List接口。因此，ArrayList类通过继承AbstractList类实现了List接口的大部分方法，同时也包含了一些自己的特定实现。ArrayList类提供了对动态数组的支持，可以根据需要动态增长和缩小。

LinkedList 类实际上实现了 List 接口和 Deque 接口，而它本身是直接继承自 AbstractSequentialList 类。这是因为 LinkedList 是一个双向链表，所以它实现了 Deque 接口，同时也可以被当作 List 使用。 AbstractSequentialList 是针对顺序访问序列的一个抽象类，而 LinkedList 则实现了这个抽象类，因此可以使用 AbstractSequentialList 中定义的方法。

ZERO_HOPE
关注
  • 15
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java学习笔记之List<E>集合
楊帥
12-28 6066
List是一个有序集合接口，实现该接口，可以精确控制列表中每个元素的插入位置，可以通过整数索引访问元素，并搜索列表中的元素。List允许重复，如果不允许重复，建议使用Set集合。 包含方法： int size(); 返回集合中的元素的数量，集合数量上限为Integer.MAX_VALUE boolean isEmpty(); 如果列表中没有元素，返回true boolean contains(O...
java容器-List<E>
哲淡笔记
02-01 675
1.介绍     List接口继承自Collection，即在Collection接口的基础上添加了一些用于随机访问的操作集合，并且提供了ListIterator迭代器，使得调用者可以方便的双向访问List，对应的方法为listIterator()。 2.主要子类型     ArrayList, LinkedList, Vector 3.主要添加方法 1) get(int index)
Java 集合深入理解（4）：List<E> 接口
weixin_34345753的博客
10-13 943
点击查看 Java 集合框架深入理解 系列， - ( ゜- ゜)つロ 乾杯~ 蓝瘦！香菇！ 连着加班几天，醉了。学学 List 放松下！ 在 Java 集合深入理解：Collection 中我们熟悉了 Java 集合框架的基本概念和优点，也了解了根接口之一的 Collection，这篇文章来加深 Collection 的子接口之一 List 的熟悉。 ...
Java学习之List<E>
你难忘的
04-14 532
List public interface List<E>extends Collection<E> 有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与 set 不同，列表通常允许重复的元素。 List中带索引的方法（特有） 方法 功能 ...
list<e> java_List<E> 接口简明
weixin_29447313的博客
02-26 397
java.util.List接口、 ListIterator、equals 方法List 是 Collection 接口的子接口，具备了 Collection 的所有方法。List 体系特有的共性方法中，查阅方法发现 List 的特有方法都有索引，这是该集合最大的特点。List ： 有序( 元素存入集合的顺序和取出的顺序一致 ) ，元素都有索引。元素可以重复。ArrayList ： 底层数据结构...
java数组和链表数据结构的区别 数组和链表.pdf
04-18
在计算机科学中，数据结构是组织、存储和处理数据的方式，它们是算法设计的基础。...在实际编程中，Java提供了ArrayList和LinkedList两种内置的列表实现，分别基于数组和链表，可以根据需要选择使用。
Java链表（Linked List）基本原理与实现方法入门示例
08-19
Java链表（Linked List）基本原理与实现方法入门示例 Java链表（Linked List）是一种基础而且重要的数据结构，在Java程序设计中广泛应用。本文将对Java链表（Linked List）的基本原理与实现方法进行详细介绍，并...
数组、单链表和双链表介绍以及双向链表的CC++Java实现 数组和链表.pdf
04-18
数组、单链表和双链表介绍以及双向链表的C、C++和Java实现 在计算机科学中，数组、单链表和双链表是最基本的数据结构。它们都是线性表的实现方式，具有相同类型的n(n≥0)个数据元素组成的有限序列。 数组 数组是...
数组和链表——精选推荐 数组和链表.pdf
04-18
下面我们将详细介绍数组和链表的基本组成部分、特点和Java实现。 一、数组 数组是最常用的线性数据结构，数组中的元素类型是一样的，并且有序的。数组的特点是： * 数据是连续的 * 随机访问速度快 在Java中，...
比较Java数组和各种List的性能小结
09-01
在Java编程中，数组和List接口的实现（如ArrayList、LinkedList和Vector）是两种常见的数据结构，它们各自具有不同的特点和性能。这篇文章将探讨这些结构在随机访问、迭代、插入和删除操作上的性能差异。 首先，...
自定义实现的ArrayList
03-03
自定义实现的ArrayList数据结构，有大量注释以及编写思路，帮助新手用Java语言来实现数据结构
list<e> java_Java中的List<E>问题
weixin_39683176的博客
02-19 188
packagecom.bjsxt.shopping;importjava.util.*;importjava.sql.*;publicclassUserManager{publicstaticListgetUsers(){//报错Listlist=newArrayList();//报错Conne...package com.bjsxt.shopping;import java.util.*;imp...
java当中的List<E> 接口
huali_1995的博客
08-29 255
根接口之一的 Collection，这里是研究Collection 的子接口之一 List 。import java.util.List;List 接口，又称为序列，几种 List 实现类是 ArrayList，LinkedList 和 Vector。在各种 List 中，最好的做法是以 ArrayList 作为默认选择。 当插入、删除频繁时，使用 LinkedList，Vector 总是比 Arr
java list值传递_Java中List<E>对象赋值问题（引用传递和值传递）
weixin_32767301的博客
02-28 1244
Java中List对象赋值操作问题业务需求是：取2个集合中的交集对象并返回。如下代码，busMap中key值和stocks中Map中的key值相等的对象则返回继续操作，也就是说剔除stocks中的不存在于busMap中的对象，就是一个过滤操作。实现代码 ① bug版报错：java.util.ConcurrentModificationException ; at java.util.Array...
List<E>学习笔记
徘徊在牛A与牛C之间的码农
02-15 267
一.List<E> 两大特点，有序，可重复 有序：集合中的元素有索引值，可以精确找到，按索引顺序排列 可重复：可以插入相同的值。 因为他继承了Collection 所以，也可以用迭代器去遍历集合，但是因为，他有索引，所以可以通过循环来遍历。 List<e> 创建集合的方法 如：代码中的A1 重要的方法： void add (int index,E ...
根据List输入，创建、打印、反转链表，并判断是否是回文链表
Tooooooong的博客
02-27 71
代码如下： class Node: def __init__(self, val): self.val = val self.next = None class LinkList: def __init__(self): self.head = None def create_linklist_from_list(self, input_list): input_list_
java 集合ArrayList ＜E＞
yalisada的博客
06-28 248
一个集合类 ArrayList 底层是一个数组结构（因为数组是不可变的，所以会新创一个数组 长度是list+1或-1，执行添加删除操作后，把原数据放到新数组中） 满足了可变数组的实现 E是泛型，ArrayList == ArrayList 这里E是String类型。 泛型只能是引用类型，不能是那八大基本类型 集合里面保存的都是地址值（只能是对象），如果想向集合中插入八大基本类型，那么可以把基本数据类型包装为引用数据类型就OK了。 创造一个ArrayList集合，名称是list，里面装的都是Stri
JAVA数据结构：通过实现List接口的自定义TLinkedList
最新发布
weixin_58879477的博客
01-13 846
JAVA数据结构：通过实现List接口的自定义TLinkedList
java定义list_Java创建List的4种方法
热门推荐
weixin_34183702的博客
02-12 1万+
1、通过构造方法，例如：List list = new ArrayList<>();然后调用list.add增加元素，如果知道初始化的值，这种先构造再一项项添加的方式，用起来并不爽，于是一边都用下面的方法2、通过Arrays.asList("a", "b");但是这种方法构造出的List是固定长度的，如果调用add方法增加新的元素，会报异常：java.lang.UnsupportedO...
List<String>是数组码
05-10
List<String> 不是数组，而是一个接口，它可以被实现成不同类型的数据结构，例如数组、链表、栈、队列等等。在 Java 中，List<String> 可以通过 ArrayList<String>、LinkedList<String> 等类来实现。与数组不同的是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值