Java链表(单链表、双向链表、单向环形链表)

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量756 收藏 27
点赞数 26
分类专栏： 数据结构学习 文章标签： java 链表 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asbeforelonely/article/details/138029157
版权

链表

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

单链表创建和遍历代码实现

package dataStructure.LinkedList;

/**
 * @author 
 * @date 2024-04-12 14:52
 */

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        HeroNode hero1 = new HeroNode(1,"宋江1","及时雨1");
        HeroNode hero2 = new HeroNode(1,"宋江2","及时雨2");
        HeroNode hero3 = new HeroNode(1,"宋江3","及时雨3");

        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.list();
    }
}
class SingleLinkedList {
    //初始化头节点，头节点不存放数据
    private HeroNode head = new HeroNode(0,"","");
    //添加节点到单向链表
    //1.找到当前链表的最后一个节点
    //2.将最后这个节点的next指向新的节点
    public void add(HeroNode heroNode) {
        //因为head节点不能动，因此我们需要一个辅助遍历temp
        HeroNode temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }
    //显示链表
    public void list() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，需要辅助变量
        HeroNode temp = head.next;
        while (true) {
            //判断是否到链表最后
            if (temp == null ){
                break;
            }
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }
}
//定义HeroNode,每个HeroNode对象都是一个节点
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;   //指向下一个节点

    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

单链表代码实现(按编号顺序添加)

在这里插入图片描述

    public void addByOrder(HeroNode heroNode) {
        //因为单链表，temp是位于添加位置的前一个节点
        HeroNode temp = head;
        boolean flag = false;   //flag标志添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null ){
                //已经到链表的最后
                break;
            }
            if (temp.next.no > heroNode.no) {
                //在temp的d当前位置添加
                break;
            } else if (temp.next.no == heroNode.no) {
                //编号已存在
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.printf("准备插入的英雄编号 %d 已经存在",heroNode.no);
        } else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

//测试在psvm中 
HeroNode hero4 = new HeroNode(4,"宋江4","及时雨4");
HeroNode hero5 = new HeroNode(5,"宋江5","及时雨5");
HeroNode hero6 = new HeroNode(6,"宋江6","及时雨6");
SingleLinkedList singleLinkedList1 = new SingleLinkedList();
singleLinkedList1.addByOrder(hero4);
singleLinkedList1.addByOrder(hero6);
singleLinkedList1.addByOrder(hero5);
singleLinkedList1.list();

单链表节点修改的代码实现

//修改节点的信息，根据no编号来修改，no编号不能修改
    public void update(HeroNode newHeroNode) {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = head.next;
        while(true) {
            if (temp == null) {
                System.out.printf("没有找到编号%d的节点,不能修改\n",newHeroNode.no);
                break;
            }
            if (newHeroNode.no == temp.no) {
                temp.name = newHeroNode.name;
                temp.nickname = newHeroNode.nickname;
                System.out.println("修改成功");
                break;
            }
            temp = temp.next;
        }
    }

单链表删除节点

在这里插入图片描述

public void delete(int no ) {
        HeroNode temp = head;
        while(true) {
            if (temp == null) {
                System.out.printf("没有找到编号%d的节点,不能删除\n",no);
                break;
            }
//            System.out.println("temp.next.no is " + temp.next.no);
            if (temp.next.no == no) {
                temp.next = temp.next.next;
                System.out.println("删除成功");
                break;
            }
            temp = temp.next;
        }
    }

题目

  1. 求单链表中的有效节点个数

    /* 
    * 
    * @author  
    * @date 2024/4/15 16:37
     * @param head 链表的头节点
     * @return int 有效节点个数
    */
    public static int getLength(HeroNode head) {
        if (head.next == null ) {
            return 0;
        }
        int length = 0;
        HeroNode cur = head.next;
        while (cur != null) {
            length ++;
            cur = cur.next;
        }
        return length;
    }

  2. 查找单链表中的倒数第k个节点

    public static HeroNode findLatIndexNode(HeroNode head, int index){
        if (head.next == null) {
            return null;
        }
        //获取链表长度
        int size = getLength(head);
        if (index <= 0 || index > size) {
            return null;
        }
        HeroNode cur = head.next;
        for (int i = 0; i < (size - index); i++) {
            cur = cur.next;
        }
        return cur;
    }

  3. 单链表的反转

    在这里插入图片描述

    public static void reverseList(HeroNode head){
        if (head.next == null || head.next.next == null){
            return ;
        }
        HeroNode cur = head.next;
        HeroNode next = null;   //指向当前节点[cur]的下一个节点
        HeroNode reverseHead = new HeroNode(0,"","");
        //遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
        while (cur != null) {
            next = cur.next;    //先暂时保存当前节点的下一个节点
            cur.next = reverseHead.next;    //cur中next用于存放reverseHead中next值
            reverseHead.next = cur;    //将cur连到reverseHead后的第一个位置
            cur = next; //让cur后移
        }
        //将head.next指向reverseHead.next，实现单链表的反转
        head.next = reverseHead.next;
    }

  4. 从尾到头打印单链表

    在这里插入图片描述

        //用栈
    public static void reversePrint(HeroNode head) {
        if (head.next == null) {
            return ;
        }
        //创建一个栈，将各个节点压入栈中
        Stack<HeroNode> stack = new Stack<>();
        HeroNode cur = head.next;
        while (cur != null) {
            stack.push(cur);
            cur = cur.next;
        }
        while (stack.size()>0) {
            System.out.println(stack.pop());
        }
    }

  5. 合并两个有序的单链表，合并之后的链表依然有序

    public static HeroNode mergeDoubleList(HeroNode head1, HeroNode head2) {
        //TODO 如果其中一个链表为空，则直接返回另一个链表
        if (head1 == null) {
            return head2;
        }
        if (head2 == null) {
            return head1;
        }
        HeroNode mergeHead = new HeroNode(0,"","");
        HeroNode cur1 = head1.next;
        HeroNode cur2 = head2.next;
        HeroNode cur = mergeHead;
        while (cur1 != null || cur2 != null) {
            if (cur1 != null && cur2 != null) {
                if (cur1.no <= cur2.no) {
                    cur.next = cur1;
                    cur1 = cur1.next;
                } else {
                    cur.next = cur2;
                    cur2 = cur2.next;
                }
            } else if (cur1 == null && cur2 != null) {
                cur.next = cur2;
                cur2 = cur2.next;
            } else if (cur2 == null && cur1 != null) {
                cur.next = cur1;
                cur1 = cur1.next;
            }
//            cur.next.next = null;
            cur = cur.next;
        }
        return mergeHead;
    }


//测试
        HeroNode mergedHead = mergeDoubleList(
                list1.getHead(),list2.getHead()
        );
        SingleLinkedList list3 = new SingleLinkedList();
        list3.setHead(
                mergedHead
        );
        list3.list();

双向链表

  1. 单向链表，查找的方向只能是一个方向，双向链表可以向前或者向后比较。
  2. 单向链表不能自我删除，需要靠辅助节点（temp待删除节点的前一个节点），双向链表可以自我删除。

在这里插入图片描述

package dataStructure.LinkedList;

/**
 * @author
 * @date 2024-04-16 20:51
 */

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        System.out.println("This is test");
        HeroNode2 hero1 = new HeroNode2(1,"宋江","及时雨");
        HeroNode2 hero2= new HeroNode2(2,"卢俊义","玉麒麟");
        HeroNode2 hero3 = new HeroNode2(3,"吴用","智多星");
        HeroNode2 hero4 = new HeroNode2(4,"林冲","豹子头");
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);
        doubleLinkedList.list();

        System.out.println("This is update");
        HeroNode2 hero5 = new HeroNode2(4,"公孙胜","入云龙");
        doubleLinkedList.update(hero5);
        doubleLinkedList.list();

        System.out.println("This is delete");
        doubleLinkedList.delete(3);
        doubleLinkedList.list();

        System.out.println("This is addByOrder");
        doubleLinkedList.addByOrder(hero3);
        doubleLinkedList.list();
    }
}
class DoubleLinkedList {
    private HeroNode2 head = new HeroNode2(0,"","");

    public HeroNode2 getHead() {
        return head;
    }

    public void setHead(HeroNode2 head) {
        this.head = head;
    }
    //添加到双向链表末尾
    public void add(HeroNode2 heroNode) {
        //因为head节点不能动，因此我们需要一个辅助遍历temp
        HeroNode2 temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;
        heroNode.prev = temp;
    }
    public void addByOrder(HeroNode2 heroNode) {
        //因为单链表，temp是位于添加位置的前一个节点
        HeroNode2 temp = head;
        boolean flag = false;   //flag标志添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null ){
                //已经到链表的最后
                break;
            }
            if (temp.next.no > heroNode.no) {
                //在temp的d当前位置添加
                break;
            } else if (temp.next.no == heroNode.no) {
                //编号已存在
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.printf("准备插入的英雄编号 %d 已经存在",heroNode.no);
        } else {
            temp.next = heroNode;
            heroNode.prev = temp;
        }
    }
    //修改节点的信息，根据no编号来修改，no编号不能修改
    public void update(HeroNode2 newHeroNode) {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        HeroNode2 temp = head.next;
        while(true) {
            if (temp == null) {
                System.out.printf("没有找到编号%d的节点,不能修改\n",newHeroNode.no);
                break;
            }
            if (newHeroNode.no == temp.no) {
                temp.name = newHeroNode.name;
                temp.nickname = newHeroNode.nickname;
                System.out.println("修改成功");
                break;
            }
            temp = temp.next;
        }
    }
    public void delete(int no ) {
        HeroNode2 temp = head.next;
        while(true) {
            if (temp == null) {
                System.out.printf("没有找到编号%d的节点,不能删除\n",no);
                break;
            }
            if (temp.no == no) {
                temp.prev.next = temp.next;
                //如果是最后一个节点，就不需要执行下面
                if (temp.next!=null) {
                    temp.next.prev = temp.prev;
                }
                System.out.println("删除成功");
                break;
            }
            temp = temp.next;
        }
    }
    //遍历双向链表
    //toString方法不能prev和next
    public void list() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，需要辅助变量
        HeroNode2 temp = head.next;
        while (true) {
            //判断是否到链表最后
            if (temp == null ){
                break;
            }
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }
}
class HeroNode2 {
    public int no;
    public String name;
    public String nickname;
    public HeroNode2 prev;
    public HeroNode2 next;

    public HeroNode2(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    @Override
    public String toString() {
        return "HeroNode2{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

单向环形链表

Josephu问题

在这里插入图片描述

在这里插入图片描述

（helper最开始指向5，first指向1）

package dataStructure.LinkedList;

public class Josephu {
    public static void main(String[] args) {
        CircleSingleLinkedList list = new CircleSingleLinkedList();
        list.addBoy(5);
        list.showBoy();

        System.out.println("This is countBoy");
        list.countBoy(1,2,5);   //2->4->1->5->3
    }
}
//创建一个环形的单向链表
class CircleSingleLinkedList {
    //创建一个first节点,当前没有编号
    private Boy first = new Boy(-1);
    //添加小孩节点
    public void addBoy(int nums) {
        // nums数据校验
        if (nums < 1) {
            System.out.println("nums的值不正确");
            return;
        }
        Boy curBoy = null;  //辅助指针
        //使用for循环创建环形链表
        for (int i = 1; i <= nums ; i++) {
            //根据编号创建节点
            Boy boy = new Boy(i); //将要添加的boy
            //如果是第一个小孩
            if (i == 1) {
                first = boy;
                first.setNext(first);
                curBoy = first;
            } else {
                curBoy.setNext(boy);
                boy.setNext(first);
                curBoy = boy;
            }
        }
    }
    //遍历
    public void showBoy() {
         //判断链表是否为空
        if (first == null) {
            System.out.println("链表为空");
            return;
        }
        //辅助指针
        Boy curBoy = first;
        while(true) {
            System.out.printf("小孩的编号 %d \n", curBoy.getNo());
            if (curBoy.getNext() == first) {
                //遍历完成
                break;
            }
            curBoy = curBoy.getNext();  //后移
        }
    }
    //根据用户的输入，计算出圈顺序
    /*
    *
    * @author 
    * @date 2024/4/18 22:25
     * @param startNo   第几个开始(先移动startNo-1次)
     * @param countNum  数几下
     * @param nums  表示最初有多少人
    */
    public void  countBoy(int startNo, int countNum, int nums){
        if (first == null || startNo < 1 || startNo > nums) {
            System.out.println("参数输入有误，请重新输入");
            return;
        }
        Boy helper = first;
        //创建辅助指针helper，指向环形链表的最后一个节点
        while (true) {
            if (helper.getNext() == first) {
                //当前helper已经指向最后一个小孩了
                break;
            }
            helper = helper.getNext();
        }
        //小孩报数前，先让first和helper移动k-1次
        for (int i = 0; i < startNo - 1; i++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        //当小孩报数时，让first和helper指针同时的移动 m - 1次，然后出圈
        //循环直到圈中只有一个节点
        while (true) {
            if (helper == first) {
                break;
            }
            //让first和helper指针同时的移动 m - 1次，然后出圈
            for (int i = 0; i < countNum - 1; i++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            //现在first指向的节点就是要出圈的小孩节点
            System.out.printf("小孩%d出圈\n",first.getNo());
            first = first.getNext();    //后移
            helper.setNext(first);
        }
        System.out.printf("小孩%d出圈\n",first.getNo());
    }
}
//表示一个节点
class Boy {
    private int no; //编号
    private Boy next;   //指向下一个节点,默认null

    public Boy(int no) {
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Boy getNext() {
        return next;
    }

    public void setNext(Boy next) {
        this.next = next;
    }

}
栞かん
关注
  • 26
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
一篇讲完Java链表（单链表、循环链表和双向链表）
qq_42592994的博客
07-31 5068
链表，是Java中的一种重要的链式数据结构。 众所周知，我们日常用手机电脑收发信息，下载视频和软件，都要进行数据的传输。这些数据都要以一种特定的数据结构来进行传输和存储，否则数据将会是一串毫无意义的0和1，无法生成我们想要的文件。一般来说有两种最常见的基本数据结构，一种是线性结构的数组，一种是链式结构的链表。
链表(单链表，双向链表，单向环形链表)_java实现
zhangan_的博客
05-05 117
链表 单链表 不考虑排名，直接往最后一个位置插入元素 package com.zhangan.linkedlist; public class SingleLinkedListDemo { public static void main(String[] args) { //创建节点 HeroNode hero1 = new HeroNode(1, "宋江", "及时雨"); HeroNode hero2 = new HeroNode(2
【数据结构】单链表 双向链表
yj20040627的博客
07-11 3247
单链表 双向链表实现
java链表----＞之单向，双向，循环链表
A_cup的博客
01-04 862
对吧，然后这俩都往后移动m-1，这个时候first指向的就是要被嘎的那个，helper指向的是要被嘎的前一个啊！2.单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面我们单链表删除节点时，总是找到要删除的前一个节点的下一个节点来删除的。还有一个删除没写，思路都是差不多的，找到指定数据的位置，然后把前一个节点的next指针指向该数据的next节点。你看你看，咱们在数组中删除和插入数据的时候，后面的数据都得移动，毕竟数据得连续存储，这个链表就不需要，性能不就上升了嘛。
数据结构：单链表和双向链表
Jocab_jl的博客
03-12 2665
1、链表 链表是有序的列表，但是它在内存中是存储如下 小结： 链表是以节点的方，来存储是链式存储 每个节点包含data域，next域：指向下一个节点 如图：发现链表的各个节点不一定是连续存储 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表(带头结点)逻辑结构示意图如下 2、单链表的应用 使用带head头的单向链表实现-水浒英雄排行榜管理完成对英雄人物的増删改査操作， 第一种方法在添加英雄时，直接添加到链表的尾部 第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果
链表（单链表、双链表、单向环形链表）
weixin_52347460的博客
06-17 905
Josephu问题为：设编号为1,2，...n的n个人围坐一圈，约定编号为k（1
(java)链表中单链表、双向链表、单向环形链表的原理及例子代码
fjswcjswzy的博客
10-19 278
文章目录1 链表介绍 1 链表介绍 链表是以节点的方式来存储的，是链式存储 每个节点包含data域，next域：指向下一个节点 如下图，发现链表的各个节点不一定是连续存储的 链表分带头节点的链表和没有头节点的链表，根据实际需求来确定 ...
【数据结构篇】手写双向链表、单向链表（超详细）
热爱编程、热爱生活、热爱探索
08-05 3105
什么是链表？链表（Linked List）是用链式存储结构实现的线性表。链表的组成数据域引用域（数据域和引用域合称结点或元素）数据域存放数据元素自身的数据引用域存放相邻结点的地址链表的特点链表中元素的联系依靠引用域具有线性结构的特点，链表所使用的逻辑结构是线性结构具有链式存储结构的特点，所使用的物理存储结构是链式存储链表的分类单向链表：单链表是一种最简的链表，只有一个引用域1next特点：通过next可以访问到后继结点，终端结点的引用域指向null双向链表：具有两个引用域prev和next。
单链表和双链表
SHUIHAN_007的博客
04-06 2917
单链表 链表是有序的列表，但是它在内存中的存储如下： 链表是以节点的方式来存储, 是链式存储 每个节点包含 data 域（存储数据），next 域（指向下一个节点） 链表的各个节点不一定是连续存储 链表分为带头节点的链表和 没有头节点的链表，根据实际的需求来确定 单链表的应用实例 使用带 head 头的单向链表实现 –水浒英雄排行榜管理完成对英雄人物的增删改查操作， 注: 删除和修改,查找 可以考虑学员独立完成，也可带学员完成 1) 第一种方法在添加英雄时，直接添加到链表的尾部 第二种方式在添加英
java 环形链表的示例
孤舟残月梦还长存的专栏
10-15 643
环形链表是解决像约瑟夫环问题的类似问题的求解。
长风破浪会有时：单向链表、双向链表和循环链表图文解析
yaotai8135的博客
09-22 976
链表的种类有很多。我们常常会用到的链表有：单向链表、双向链表和循环链表。 链表不同于数组的地方在于：它的物理存储结构是非连续的，也就是说链表在内存中不是连续的，并且无序。它是通过数据节点的互相指向实现，当前节点除了存储数据，还会存储下一个节点的地址。我们不必在创建时指定链表的长度，因为链表可以无限的插入节点延伸，且插入和删除数据时，其时间复杂度都是 O(1)。 1. 单向链表 1.1 单向链表结构...
学习笔记-双向链表与环形链表
touteng55的博客
02-17 261
双向链表 在单链表的基础上，每个节点增加了一个pre属性指向前一个节点。 因为单链表只有next指针，因此只能单向遍历。而双向链表可以从前或从后遍历。另外也可以自我删除，也就是不用借助被删节点的前一个节点进行删除，直接靠自己就行。 增删改查 节点增加了pre指向前一个节点 //双向链表的节点 class StudentNode2{ public int no; public String name; StudentNode2 next; StudentNode2 pre;
数据结构与算法--双向链表(Double Linked List)、单向环形链表(Circular Linked List)
ZZay's
01-22 1398
此文章仅作为自己学习过程中的记录和总结，同时会有意地去用英文来做笔记，一些术语的英译不太准确，内容如有错漏也请多指教，谢谢！ 一、双向链表-概述 -双向链表的基本组成结构： Node：自定义的结点结构。 (Node) head：指向单链表头结点的“头指针”。 -自定义结点的基本组成结构： 数据域：存放具有实际意义的数据。 “指针”域(next)：存放一个指向下一结点的“指针”。 “指针”域(pre)：存放一个指向上一结点的“指针”。【与单链表的区别】 -优点： 遍历方向：单链表只能朝向一个方向
双向链表和环形链表（单向和双向）约瑟夫环实例
wardo_l的博客
03-06 509
双向链表 数组优缺点：根据下标直接查找和修改，增删需要移动后续数据，效率低。 单向链表的缺点：增删快速，查找需要从头遍历，效率低。 双线链表可以向前或向后查找。 单向链表查找的方向只能是一个方向（双向链表可以向前向后查找），且不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面我们单链表删除节点时，总是找到temp的下一个节点来删除的（就是指temp.next.data == data，因为要对该节点的前一个节点及后一个节点操作。) 双向链表节点包含数据域data、前驱指针域prev
spring事务详细讲解-深入浅出
小电玩
09-08 458
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1444
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 512
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
自定义Stater
m0_63624484的博客
09-07 707
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值