精华内容
下载资源
问答
  • linkedlist方法
    2022-05-20 12:44:52

    常用方法
    addFirst(E e) :在此列表的开始处插入指定的元素。
    addLast(E e) :将指定的元素列表的结束。
    getFirst() :返回此列表中的第一个元素。
    getLast() :返回此列表中的最后一个元素。
    removeFirst() :移除并返回此列表中的最后一个元素。
    removeLast() :移除并返回此列表中的最后一个元素。

    package com.study.exception.demo20;
    
    import java.util.ArrayList;
    import java.util.LinkedList;
    
    public class LinkedListDemo {
    
    
        public static void main(String[] args) {
            LinkedList<String> s = new LinkedList<String>();
    
            s.add("语文");
            s.add("数学");
            s.add("英语");
    
    //        addFirst(E e) :在此列表的开始处插入指定的元素。
    //        addLast(E e) :将指定的元素列表的结束。
            s.addFirst("历史");
            s.addLast("地理");
    
    //        getFirst() :返回此列表中的第一个元素。
    //        getLast() :返回此列表中的最后一个元素。
            System.out.println(s.getFirst());
            System.out.println(s.getLast());
    
    //        removeFirst() :移除并返回此列表中的最后一个元素。
    //        removeLast() :移除并返回此列表中的最后一个元素。
            s.removeFirst();
            s.removeLast();
    
    
            System.out.println(s);
        }
    }
    
    
    更多相关内容
  • LinkedList方法

    2020-10-10 14:57:31
    import java.util.LinkedList; public class LinkListDemo { public static void main(String[] args) { /* LinkedList集合底层是双向链表,增删快,查找要从头开始查找。... 作为链表,特有方法是,

    LInkedList
    底层是双向链表
    前面有节点,后面也有节点
    linkedList还实现了
    Queue接口,可以当作队列和栈来使用
    )基本底层结构如图,
    在这里插入图片描述

    头节点中first指向第一个节点
    头节点中last指向最后一个节点
    普通节点pre指向前面节点
    next指向后面节点
    首节点pre =null
    尾节点next =null

    Deque(栈)借口两个实现类
    linkedlist
    arrayDeque

    队列Queue可以是这两个
    可以当栈使用,也可以当队列使用

    package com.company;
    
    import java.util.Deque;
    import java.util.LinkedList;
    import java.util.List;
    
    public class USER {
        public static void main(String[] args) {
            //操作栈的方法
            Deque<String> list = new LinkedList<>();
            list.push("我是深");//入栈
    
            list.push("甚至");
            String pop = list.pop();
            System.out.println(pop);//取出栈顶元素
        }
    }
    
    

    当作队列使用

    package com.company;
    
    import java.util.Deque;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Queue;
    
    public class USER {
        public static void main(String[] args) {
            //操作栈的方法
            Queue<String> list = new LinkedList<>();
            list.offer("shen");//入队
    
            list.offer("甚至");
            String pop = list.poll();
            System.out.println(pop);//取出栈顶元素
        }
    }
    
    
    package com.company.Collections;
    
    import java.util.LinkedList;
    
    public class LinkListDemo {
        public static void main(String[] args) {
            /*
            LinkedList集合底层是双向链表,增删快,查找要从头开始查找。
            查找慢是问题
            是Collection和List接口的实现类
            作为链表,特有方法是,对首尾数据进行操作
             */
    
            LinkedList<Integer> link = new LinkedList<>();
            link.add(8);
            link.add(8);
            link.add(55);
    
            link.getFirst();
            link.getLast();//这个列表中大量对尾部和首部进行操作的方法
        }
    }
    
    
    展开全文
  • LinkedList方法详解

    2022-05-01 20:59:23
    add方法 add(E e):调用linkLast方法将元素添加到尾部 add(int index, E element): 检查index是否越界 比较index与size,如果index==size,则代表插入位置为链表尾部,调用linkLast方法,否则调用linkBefore...

    add方法

    add(E e):调用linkLast方法将元素添加到尾部

     add(int index, E element):

    1. 检查index是否越界
    2. 比较index与size,如果index==size,则代表插入位置为链表尾部,调用linkLast方法,否则调用linkBefore方法

    get方法

    根据index,调用node方法寻找目标节点,返回目标节点的item。

    node方法

    如果index在链表的前半部,则从头节点开始遍历;否则从尾节点开始遍历。

    set方法

    1. 检查index是否越界
    2. 调用node方法寻找目标节点
    3. 将目标节点的item属性设为element

    remove方法

    remove(Object o):

    1. 判断o是否为null,如果o为null,则遍历链表寻找item属性为空的节点,并调用unlink方法将该节点移除
    2. 如果o不为null, 则遍历链表寻找item属性跟o相同的节点,并调用unlink方法将该节点移除

    remove(int index):

    1. 检查index是否越界
    2. 调用unlink方法,移除index位置的节点

    clear方法

    1. 从first节点开始,遍历将所有节点的属性清空
    2. 将first节点和last节点设为null

    linkLast方法

    1. 拿到当前的尾节点 l 节点
    2. 使用e创建一个新的节点newNode,prev属性为l节点,next属性为null
    3. 将当前尾节点设置为上面新创建的节点newNode
    4. 如果l节点为空则代表当前链表为空, 将newNode设置为头结点,否则将l节点的next属性设置为newNode

    linkBefore方法

    1. 拿到succ节点的prev节点
    2. 使用e创建一个新的节点newNode,其中prev属性为pred节点,next属性为succ节点
    3. 将succ节点的prev属性设置为newNode
    4. 如果pred节点为null,则代表succ节点为头结点,要把e插入succ前面,因此将first设置为newNode,否则将pred节点的next属性设为newNode

    unlink方法

    1. 定义element为x节点的值,next为x节点的下一个节点,prev为x节点的上一个节点
    2. 如果prev为空,则代表x节点为头结点,则将first指向next即可;否则,x节点不为头结点,将prev节点的next属性指向x节点的next属性,并将x的prev属性清空
    3. 如果next为空,则代表x节点为尾节点,则将last指向prev即可;否则,x节点不为尾节点,将next节点的prev属性指向x节点的prev属性,并将x的next属性清空
    4. 将x的item属性清空,以便垃圾收集器回收x对象

    展开全文
  • 耍起来 ... import java.util.*; public class LinkedListTest { public static void main(String[] args) { ... list = new LinkedList<>(); List<Integer> list1 = new ArrayList<>(); list.

    在这里插入图片描述

    耍起来

    package com.beyond;
    
    import java.util.*;
    
    public class LinkedListTest {
        public static void main(String[] args) {
            List<Integer> list = new LinkedList<>();
            List<Integer> list1 = new ArrayList<>();
            list1.add(1);
            list1.add(2);
            list1.add(3);
            list.add(3);
            list.add(9);
            System.out.println(list);
            list.add(0,4);
            System.out.println(list);
            list.addAll(list1);
            list.addAll(2,list1);
            System.out.println(list);
    
            ((LinkedList<Integer>) list).addFirst(2);
            System.out.println(list);
            ((LinkedList<Integer>) list).addLast(9);
            System.out.println(list);
    
    //        list.clear();
    //        System.out.println(list);
            System.out.println(list.get(3));
    
            Object clone = ((LinkedList<Integer>) list).clone();
            System.out.println(clone.toString());
    
    
            System.out.println(list.contains(2));
    //
    //        Iterator<Integer> iterator = ((LinkedList<Integer>) list).descendingIterator();  // 逆序遍历
    //        while (iterator.hasNext()){
    //            System.out.print(iterator.next()+" ");
    //        }
    
            System.out.println(((LinkedList<Integer>) list).element());
    
            System.out.println(list.indexOf(2));
            System.out.println(list.lastIndexOf(2));
    
            ListIterator<Integer> iterator = list.listIterator();
            while (iterator.hasNext()){
                System.out.print(iterator.next()+" ");
            }
            System.out.println();
    
            boolean offer = ((LinkedList<Integer>) list).offer(5);
            System.out.println(list);
    
            ((LinkedList<Integer>) list).offerLast(0);
            System.out.println(list);
    
            System.out.println(((LinkedList<Integer>) list).peek());
            System.out.println(((LinkedList<Integer>) list).peekFirst());
            System.out.println(((LinkedList<Integer>) list).peekLast());
    
    
            List<String> list2  = new LinkedList<>();
    //        System.out.println(((LinkedList<Integer>) list2).element());  // 没有则报错
    //        System.out.println(((LinkedList<Integer>) list2).peek());
    //        System.out.println(((LinkedList<Integer>) list2).peekFirst());
    //        System.out.println(((LinkedList<Integer>) list2).peekLast());
    
            System.out.println(((LinkedList<Integer>) list).poll());
            System.out.println(((LinkedList<Integer>) list).pollFirst());
            System.out.println(((LinkedList<Integer>) list).pollLast());
            System.out.println(((LinkedList<Integer>) list).pop());
            System.out.println(((LinkedList<Integer>) list).pop());
            ((LinkedList<Integer>) list).push(1001);
            System.out.println(list);
    //        System.out.println(((LinkedList<String>) list2).removeFirst());
    
            list.set(0, 99);
            System.out.println(list);
            System.out.println(list.size());
    
            Spliterator<Integer> spliterator = list.spliterator();
            Spliterator<Integer> split = spliterator.trySplit();
            int characteristics = split.characteristics();
            System.out.println(characteristics);
        }
    }
    
    
    展开全文
  • 容器中基于链路的linkedList方法的底层实现
  • LinkedList的各种方法

    2021-12-23 18:39:41
    LinkedList常用于栈和队列的模拟,经常在算法题中遇见,所以一次性将LinkedList方法总结一下。 public E getFirst() 返回此列表中的第一个元素。 public E getLast() 返回此列表中的最后一个元素。 public E ...
  • 简谈LinkedList特有的方法

    千次阅读 2022-01-16 23:32:00
    一、什么是LinkedList集合 二、LinkedList集合特有的方法
  • LinkedList是一个链表。详细源码分析看这里 链表维护3个成员: 第一个元素,最后一个元素,链表长度。元素(node)是双向的, 增加 void linkedFirst(e) 加在最前面 addFirst(e) 同上 offerFirst(e) void linkLast...
  • 图解 LinkedList 方法

    2021-03-22 18:53:42
  • Java中LinkedList类的常用方法

    千次阅读 2022-02-07 18:34:08
    LinkedList类有很多方法,可以模拟栈,队列,链表功能。 一、队列  1.入队 add(E e );将e插入队列末尾。  2.出队删除队首 poll() ; 取出队首元素,并且在队列中删除队首。队首为空返回null。  3.出队删除队首 ...
  • 目录 LinkedList自我理解 LinkedList(链表)常用方法 增加 删除 获取 其他 LinkedList自我理解   学了数据结构的小伙伴们,应该晓得逻辑结构和存储结构。例如:栈这种数据结构可以用链式存储实现,也可以用顺序存储...
  • LinkedList方法解析及实现原理 LinkedList为一个链表类型的List列表,列表在频繁的插入和删除列表元素的时候,使用LinkedList比使用ArrayList将更为高效。 目录 LinkedList方法解析及实现原理 目录 add(int ...
  • 1、Java LinkedListLinkedList类与ArrayList几乎相同,也是集合List的实现类,相比...例如://导入 LinkedList类import java.util.LinkedList;public class Main {public static void main(String[] args) {LinkedL...
  • 六、常用方法 一、简介 链表(Linked list)是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的地址。 链表可分为单向链表和双向链表。 Java ...
  • 解析LinkedList源码的add方法
  • LinkedList 双链表 add() 和 addAll()方法、subList()方法 作为栈、队列、双端队列的使用
  • LinkedList 方法知识点

    2015-07-12 14:50:23
    package test_day_9;...import java.util.LinkedList; public class LinkedListDemos { public static void main(String[] args) { // LinkedList 底层是链表结构,增删速率快 不同步 Linke
  • 主要介绍了简单了解java集合框架LinkedList使用方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • LinkedList的用法

    2010-09-17 22:38:02
    LinkedList<String> list = new LinkedList(); list.add("aaa"); list.add("bbb"); list.add("ccc"); /* * public void addFirst(E e)方法 * 将指定元素插入此列表的开头 */ list.addFirst("000...
  • 本文实例讲述了C#双向链表LinkedList排序实现方法。分享给大家供大家参考。具体如下: 1.函数 打印链表函数PrintLinkedList 和 排序函数SortLinkedList 注:下面代码中的链表每项都是double类型,如果换做其他的类型...
  • 前几天公司新来了一位实习生,面试时的时候问了一个问题,什么问题呢,就是关于LinkedList中的add()方法,问他知不知道这个方法是怎么实现的,结果他支支吾吾了半天也没有说出一二三来,大家一起来看看我的理解。...
  • LinkedList用法详解

    千次阅读 2020-06-21 15:45:27
    一、LinkedList介绍
  • import java.util.LinkedList; /** * * @author Ginfer * @virsion * HP * linkedlist * HP * 自定义栈集合 * 栈的数据结构是先进后出, */ public class MyStack { /... //添加一个构造方法,并默认new一个Linke...
  • 详解LinkedList

    2022-07-23 16:45:27
    linkedList本质上是一个双向链表,通过一个Node内部类实现的这种链表结构。LinkedList能存储null值。LinkedList在删除和增加等操作上性能好,而ArrayList在查询的性能上好。从源码中看,它不存在容量不足的情况。...
  • 主要介绍了解析Java中的队列和用LinkedList集合模拟队列的方法,相关算法的实现也是ACM中的常见题目,需要的朋友可以参考下
  • LinkedList中有一些方法虽然名字不同,但可以完成相同的操作,实现相同的功能,其中: 1、getFirst()和element()完全一样,它们都返回列表的头(第一个元素),并且不移除它,若List为空,则抛出...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 187,747
精华内容 75,098
关键字:

linkedlist方法