java基础部分-第三周学习总结-ArrayList,LinkList

已于 2024-03-24 17:10:07 修改
阅读量869 收藏 6
点赞数 15
文章标签： 学习 java list 链表
于 2024-03-24 17:08:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52495299/article/details/136990450
版权

前言：这周主要就是对集合的学习

集合

什么是集合

1、 集合是Java API所提供的一系列类，可以用于动态存放多个对象。--集合只能存对象

2、 集合与数组的不同在于，集合是大小可变的序列，而且元素类型可以不受限定，只要是引用类型。(集合中不能放基本数据类型，但可以放基本数据类型的包装类)

3、 集合类可以自动扩容。

4、 集合类全部支持泛型，是一种数据安全的用法。

集合与数组的区别

  1. 数组和集合都是容器

  2. 数组是定义完成并运行后，类型确定、长度固定。数组适合元素的个数和类型确定的业务场景，不适合做需要增删数据操作.

  3. 集合是大小不固定，运行后可以动态变化，类型也可以选择不固定。集合非常适合做元素的增删操作。

集合框架总体结构

Java中集合类定义主要是java.util.*包下面，常用的集合在系统中定义了三大接口，这三类的区别是：

java.util.Set接口及其子类，set提供的是一个无序的集合；

java.util.List接口及其子类，List提供的是一个有序的集合；

java.util.Map接口及其子类，Map提供了一个映射（对应）关系的集合数据结构；

另外，在JDK5中新增了Queue(队列)接口及其子类，提供了基于队列的集合体系。每种集合，都可以理解为用来在内存中存放一组对象的某种”容器“---就像数组，就像前面我们自己定义的队列。

ArrayList

ArrayList底层是基于数组实现的：根据索引定位元素快，增删需要做元素的移位操作。 

ArrayList接口特有的方法:

List集合因为支持索引，所以多了很多索引操作的独特api，其他Collection的功能List也都继承了。

方法名称说明
void add(int index,E element)在此集合中的指定位置插入指定的元素
E remove(int index)删除指定索引处的元素，返回被删除的元素
E set(int index,E element)修改指定索引处的元素，返回被修改的元素
E get(int index)返回指定索引处的元素

手动实现底层源码

import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;

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

    private Object[] elementData = {};

    private int size = 0;//数组实际长度指针

    //初始化数组
    public MyArrayList() {
        elementData = new Object[10];
    }

    //有参构造
    public MyArrayList(int initialCapacity) {
        if (initialCapacity < 0) {
            throw new IndexOutOfBoundsException("无效初值");
        }
        elementData = new Object[initialCapacity];
    }

    //数组扩容
    private void ensureCapacity(){
        elementData = Arrays.copyOf(elementData, elementData.length * 2);
    }

    //添加元素
    public void add(E element){
        //判断是否需要扩容
        if (size+1 > elementData.length) {
            ensureCapacity();
        }
        elementData[size++] = element;
    }

    //根据索引插入元素
    public void add(int index,E element){
        //异常处理
        if (index > size || index < 0) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        //判断是否需要扩容
        if (size+1 > elementData.length) {
            ensureCapacity();
        }
        //循环移动元素
        for (int i = size; i > index; i--) {
            elementData[i] = elementData[i-1];
        }
        elementData[index] = element;
        size++;
    }

    //根据索引删除元素，并返回
    public E remove(int index){
        if (index > size || index < 0) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        E elementDatum = (E) elementData[index];
        for (int i = index; i < size-1; i++) {
            elementData[i] = elementData[i+1];
        }
        elementData[size - 1] = null;
        size--;
        return elementDatum;
    }

    //判断是否含有该元素
    public boolean contains(E element){
        for (int i = 0; i < size; i++) {
            if (elementData[i].equals(element)) {
                return true;
            }
        }
        return false;
    }

    //返回数组中实际长度
    public int size(){
        return size;
    }

    //返回索引处元素
    public E get(int index){
        if (index >= size || index < 0) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        return (E) elementData[index];
    }
    
    //判空
    public boolean isEmpty(){
        return size == 0;
    }
    
    //修改索引处的元素值，并返回原先的值
    public E set(int index,E element){
        if (index >= size || index < 0) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        E elementDatum = (E) elementData[index];
        elementData[index] = element;
        return element;
    }
    
    //重写toString方法
    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer("[");
        for (int i = 0; i < size; i++) {
            sb.append(elementData[i]);
            if (i < size-1) {
                sb.append(", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }

    public void clear(){
        for (int i = 0; i < size; i++) {
            elementData[i] = null;
        }
        size = 0;
    }
    
    
    //迭代器
    @Override
    public Iterator<E> iterator() {
        return new MyListIterator();
    }

    private class MyListIterator<E> implements Iterator<E>{
        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
            return currentIndex < size;
        }

        @Override
        public E next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return (E) elementData[currentIndex++];
        }
    }

}

LinkedList

底层数据结构是双链表，查询慢，首尾操作的速度是极快的，所以多了很多首尾操作的特有API。

LinkedList集合的特有功能:

方法名称说明
public void addFirst(E e)在该列表开头插入指定的元素
public void addLast(E e)将指定的元素追加到此列表的末尾
public E getFirst()返回此列表中的第一个元素
public E getLast()返回此列表中的最后一个元素
public E removeFirst()从此列表中删除并返回第一个元素
public E removeLast()从此列表中删除并返回最后一个元素

 手动实现底层源码

import java.util.NoSuchElementException;

public class MyLinkedList<E> {

    private int size;

    private Node<E> first = null;//头

    private Node<E> last =null ;//尾

    //初始化
    public MyLinkedList() {
        this.first = null;
        this.last = null;
        this.size = 0;
    }

    //返回尾节点
    public E getFirst() {
        if (first == null) {
            throw new NoSuchElementException("LinkedList is empty");
        }
        return first.value;
    }


    //返回头节点
    public E getLast() {
        if (last == null) {
            throw new NoSuchElementException("LinkedList is empty");
        }
        return last.value;
    }

    //删除尾节点
    public E removeFirst(){
        if (first == null) {
            throw new NoSuchElementException("LinkedList is empty");
        }
        E value = first.value;
        first = first.next;
        if (first != null ) {
            first.prev = null;
        }else {
            last = null;
        }
        size--;
        return value;
    }


    //删除头节点
    public E removeLast(){
        if (last == null) {
            throw new NoSuchElementException("LinkedList is empty");
        }
        E value = last.value;
        last = last.prev;
        if (last != null) {
            last.next = null;
        }else {
            first = null;
        }
        size--;
        return value;
    }

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

    //添加方法,默认尾插法
    public void add(E e){
        Node<E> newNode = new Node<>(last,e,null);
        if (isEmpty()) {
           first = newNode;
        }else {
            last.next = newNode;
        }
        last = newNode;
        size++;
    }

    //在该列表开头插入指定的元素
    public void addFirst(E e){
        Node<E> newNode = new Node<>(null, e, first);
        if (isEmpty()) {
            last = newNode;
        }else {
            first.prev = newNode;
        }
        first = newNode;
        size++;
    }

    //将指定的元素追加到此列表的末尾
    public void addLast(E e){
        Node<E> newNode = new Node<>(last, e, null);
        if (isEmpty()) {
            first = newNode;
        }else {
            last.next = newNode;
        }
        last = newNode;
        size++;
    }

    //索引位置添加
    public void add(int index,E e){
        if (index > size || index < 0) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        if (index == size) {
            add(e);
            return;
        }
        Node<E> newNode = new Node<>(null, e, null);
        if (index == 0) {
            newNode.next = first;
            first.prev = newNode;
            first = newNode;
        }else {
            Node<E> temp = first;
            for (int i = 0; i < index-1; i++) {
                temp = temp.next;
                }
            newNode.next = temp.next;
            newNode.prev = temp;
            temp.next.prev = newNode;
            temp.next = newNode;
        }
        size++;
    }

    //链表长度
    public int size(){
        return size;
    }
    
    //通过索引返回元素值
    public E get(int index){
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        Node<E> temp = first;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        return temp.value;
    }

    //修改索引处的值，返回原先的值
    public E set(int index,E e){
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }

        Node<E> temp = first;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        E value = temp.value;
        temp.value = e;
        return value;
    }

    //判断链表是否含有此元素
    public boolean contains(E e) {
        Node<E> current = first;
        while (current != null){
            if (current.value.equals(e)) {
                return true;
            }
            current = current.next;
        }
        return false;
    }

    //删除索引节点，返回其值
    public E remove(int index){
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        if (index == 0) {
            return removeFirst();
        }else if (index == size-1) {
            return removeLast();
        }else {
            Node<E> temp = first;
            for (int i = 0; i < index; i++) {
                temp = temp.next;
            }
            E value = temp.value;
            temp.next.prev = temp.prev;
            temp.prev.next = temp.next;
            size--;
            return value;
        }
    }

    //清空链表
    public void clear(){
        first = null;
        last = null;
        size = 0;
    }

    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer();
        sb.append("[");
        Node<E> temp = first;
        while (temp != null){
            sb.append(temp.value);
            if (temp.next != null) {
                sb.append(", ");
            }
            temp = temp.next;
        }
        sb.append("]");
        return sb.toString();
    }

    private static class Node<E> {
        E value;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.value = element;
            this.next = next;
            this.prev = prev;
        }
    }

}

ArrayList和LinkedList的区别

ArrayListLinkedList
底层封装数组实现，分配的是一块连续的内存空间底层封装链表实现，分配的是不连续的内存空间
读取数据效率更高读取数据效率相对较低
增，删等操作效率相对偏低增，删等操作效率高
相对于ArrayList,多了对于首元素和尾元素的操作
恰似枫扬
关注
  • 15
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java进阶--深入理解ArrayList实现原理
01-27
ArrayList就是动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了动态的增加和减少元素，实现了Collection和List接口，可以灵活的设置数组的大小。要注意的是ArrayList并不是线程安全的，因此一般建议在单线程中使用ArrayList。由上可知ArrayList继承AbstractList并且实现了List和RandomAccess，Cloneable,Serializable接口。①构造方法由上面三种构造方法可知，默认情况下使用ArrayList会生成一个大小为10的Object类型的数组。也可以调用ArrayList(intinitialCa
java基础核心总结归纳---参考手册--心得手册-学习资料-总结经验
12-20
1 Java 概述 3 1.1 Java 定义 3 1.2 Java 的特点 3 1.3 Java 开发环境 5 Java 基本语法 7 数据类型 7 整数型 7 浮点型 7 字符型 8 布尔型 8 基础语法 8 运算符 8 Java 执⾏控制流程 11 条件语句 11 if语句 11 if...else 条件语句 11 if...else if 多分⽀语句 11 switch 多分⽀语句 11 循环语句 12 while 循环语句 12 do...while 循环 12 for 循环 12 跳转语句 13 break 语句 13 continue 语句 13 return 语句 13 ⾯向对象 14 类的定义 14 对象的创建 14 属性和⽅法 14 构造⽅法 14 ⽅法重载 15 ⽅法的重写 15 初始化 15 类的初始化 15 构造器初始化 15 初始化顺序 16 this 和 super 16 访问控制权限 16 继承 17 多态 17 代理 17 Static 17 Final 17 接⼝和抽象类 18 接⼝ 18 抽象类 18 异常 18 认识 Exception 18 什么是 Throwable 18 常⻅的 Exception 19 与 Exception 有关的 Java 关键字 19 什么是 Error 20 内部类 20 集合 20 ArrayList 21 Vector 21 LinkedList 21 Stack 21 HashSet 22 TreeSet 22 LinkedHashSet 22 HashMap 23 集合实现类特征图 23 泛形 23 反射 24 I/O 24 File 类 24 基础 IO 类和相关⽅法 25 InputStream 25 OutputStream 25 Reader 类 26 Writer 类 26 InputStream 及其⼦类 27 OutputStream 及其⼦类 27 Reader 及其⼦类 28 Writer 及其⼦类 28 注解 28 关于 null 的⼏种处理⽅式 29 null 是任何引⽤类型的初始值 29
由ArrayList来深入理解Java中的fail-fast机制
09-02
fail-fast俗称快速失败,是在多线程进行迭代操作时产生冲突的一种异常抛出机制,下面我们就由ArrayList来深入理解Java中的fail-fast机制.
Java基础总结--附答案(1)1
08-03
public static void main(String[] args) {1. Arraylist LinkedList。
java基础--list（ArrayList、LinkedList、匿名类）.docx
08-07
List最全总结（ ArrayList， LinkedList， 匿名类）
Java基础了解-10-ArrayList/LinkedList
Xiaowu2048的博客
03-15 236
ArrayList/LinkedList
JAVA集合---LinkList
qq_35229940的博客
04-25 2153
LinkedList简介 LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList 实现 List 接口，能对它进行队列操作。 LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。 LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。 LinkedList 实现java.io.Serializable接口，这意味着LinkedList支
Java集合知识点总结——ArrayList和LinkList
AI菜鸡，NLP领域，至今为发不出论文掉头发
02-20 826
Java集合与数组的区别： 数组不是面向对象的，存在明显的缺陷，集合弥补了数组的缺点，比数组更灵活更实用，而且不同的集合框架类可适用不同场合。如下： 首先数组可以存放基本数据类型和对象，不同的是集合存放的都是对象，数组和集合存放的对象皆为对象的引用地址，两者存储的都不是对象的本身。 数组在建立之初，就必须要规定长度，数组的长度无法动态改变，但是集合可以根据实际情况动态改变集合的长度，使用起来...
Java集合--List（ArrayList、LinkedList）
喜之郎cc果冻的博客
09-10 245
ArrayList和LinkedList是Java中两种常用的List实现类。它们之间的主要区别如下： 内部实现：ArrayList是动态数组实现，底层使用数组来存储元素。LinkedList是链表实现，底层使用双向链表来存储元素。 随机访问：对于随机index访问的get和set方法，一般ArrayList的速度要优于LinkedList。 插入和删除操作：对于插入和删除操作，LinkedList优于ArrayList。 内存占用：LinkedList比ArrayList更占内存，因为LinkedLis
基于java-18_ArrayList，LinkList链表接口实现-源码.zip
05-08
提供的源码资源涵盖了Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速...
Java面试题总结-ArrayList和LinkedList的区别
m0_56642224的博客
12-11 764
Java面试题总结第二篇
java基础三:Arraylist和LinkList区别
lixpjita39的专栏
12-08 285
ArrayList和LinkedList的区别只有有以下几点： 1. ArrayList是基于动态数组的数据结构，LinkedList是基于双向链表的数据结构。 2. 对于随机访问get和set，ArrayList要优于LinkedList，因为LinkedList要移动指针。 3. 对于新增和删除操作add和remove，LinkedList比较有优势，因为ArrayList要移动数据。下面
(JAVA)-ArrayList，Linklist
fdvvg的博客
11-17 35
1.利用空参创建集合，在底层创建一个集合为0的数组，名字叫elementDate，有一个变量叫size，表示当前有几个元素。4.一次添加多个元素，1.5倍还放不下，则以新创建数组的长度为准。2.添加第一个元素时，底层会创建一个长度为10的数组。addAll方法，一次添加多个数据。add方法，一次添加一个数据。底层数据结构是双链表，查询慢。3.存满时会扩容1.5倍。
Java--LinkedList真的比ArrayList添加元素快？Open JDK JMH带你揭开真相
热门推荐
JustinQin
08-31 2万+
【学习背景】 欢迎进来学习的小伙伴~ 不管你是学生，还是职场小白，还是入行1~3年的小伙伴，相信很多小伙伴在面试Java工作岗位时，发现LinkedList和ArrayList这个问题基本是必面的一道题， 【面试场景】 当面试官问到LinkedList和ArrayList的区别时，可能很多准备得不够充分的小伙伴第一反应的回答仅仅是这样的： LinkedList底层数据结构是链表，添加和删除元素效率比ArrayList高~ ArrayList底层数据结构是数组，查询效率比LinkedList高~ 面试官：哦
Java基础底层-ArrayList和LinkedList的区别
Huang1178387848的博客
11-29 286
一、简介 Collection 接口的接口 对象的集合（单列集合） —List 接口：元素按进入先后有序保存，可重复，通过索引操作元素 ------LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全 ------ArrayList 接口实现类， 数组， 随机访问， 没有同步， 线程不安全 ------Vector 接口实现类 数组， 同步， 线程安全 —Set 接口：元素唯一，不可重复，并做内部排序即存取顺序不一致；不能根据索引操作元素 二、区别 总结 ArrayList：底层
引用实战学习
最新发布
qiuzhiuser的博客
05-19 132
【代码】引用实战学习。
web安全学习笔记（18）
m0_58875569的博客
05-18 644
记一下第31-32节课的内容。未授权访问漏洞；逻辑漏洞之任意用户密码重置的7种常用姿势
C语言查漏补缺学习【精简版】
qq_49288362的博客
05-18 809
逗号的组合关系是自左向右，所以左边的表达式会先计算，而右边的表达式的值就留下来作为逗号运算的结果。枚举类型名字通常并不真的使用，要用的是在大括号里的名字，因为它们就是常量符合，它们的类型是int,值则一次从0到n。当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改。当需要一些可以排列起来的常量值时，定义枚举的意义就是给了这些常量的值的名字。16.*：是一个单目运算符，用来访问指针的值所表示的地址上的变量。
第1关：学习-Java集合类之List的ArrayList之增删改查
06-01
那么，你的问题是关于Java集合类中的List的ArrayList之增删改查，是吗？ 首先，让我们来了解一下ArrayList。ArrayList是Java集合框架中的一个类，它实现了List接口。它是一个动态数组，可以根据需要自动扩展容量。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值