Java_简单实现无头单向非循环链表_简单实现LinkedList

已于 2024-02-03 17:23:35 修改
阅读量681 收藏 21
点赞数 20
文章标签： java 链表 开发语言
于 2024-02-03 00:33:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_66484088/article/details/135965381
版权

文章目录

一、ArrayList的优缺点

缺点：
1.插入数据必须移动其他数据，最坏情况下，就是插入到0位置。时间复杂度O(N)
2.删除数据也需要移动数据，最坏情况下，就是删除0位置。时间复杂度O(N)
3.扩容之后，有可能会浪费空间
优点：
1.在给定下标进行查找的时候，时间复杂度O(1)
总结：顺序表比较适合进行给定下标查找的场景

二、链表

1.链表的概念及结构

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。就像火车一样是一节一节的。
在这里插入图片描述
火车之间用挂钩相连，每个节点都存储下一个节点的物理地址。

在这里插入图片描述

2.链表的分类

1、单向或者双向

在这里插入图片描述

2、带头或者不带头

在这里插入图片描述

3、循环或者非循环

在这里插入图片描述
无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。

三、实现无头单向非循环链表

1.定义接口

public interface IList {
    //头插法
    public void addFirst(int data);
    //尾插法
    public void addLast(int data);
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index,int data);
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key);
    //删除第一次出现关键字为key的节点
    public void remove(int key);
    //删除所有值为key的节点
    public void removeAllKey(int key);
    //得到单链表的长度
    public int size();
    public void clear();
    public void display();
}

2.定义MySingleList

public class MySingleList implements IList{
    @Override
    public void addFirst(int data) {
        
    }

    @Override
    public void addLast(int data) {

    }

    @Override
    public void addIndex(int index, int data) {

    }

    @Override
    public boolean contains(int key) {
        return false;
    }

    @Override
    public void remove(int key) {

    }

    @Override
    public void removeAllKey(int key) {

    }

    @Override
    public int size() {
        return 0;
    }

    @Override
    public void clear() {

    }

    @Override
    public void display() {

    }
}

3.成员

1、节点类（定义在MySingList类里）

节点类包含存储数据和下一个节点引用。

   static class ListNode{
        public int val;
        public ListNode next;
        public ListNode(int val)
        {
            this.val = val;
        }
    }

2、头节点引用

 public ListNode head;

4.打印链表实现dispaly(这是方便测试写的)

  @Override
    public void display() {
        ListNode cur = this.head;
        while(cur!=null)
        {
            System.out.print(cur.val+" ");
            cur =cur.next;
        }
        System.out.print("\n");
    }

5.得到单链表的长度 size

    @Override
    public int size() {
        ListNode cur= head;
        int ret = 0;
        while(cur!=null)
        {
            ret++;
            cur = cur.next;
        }
        return ret;
    }

6.查找是否包含关键字key是否在单链表当中 contions

    @Override
    public boolean contains(int key) {
        ListNode cur= head;
        while(cur!=null)
        {
            if(key==cur.val)
            {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

7.头插法 addFirst

    @Override
    public void addFirst(int data) {
        ListNode newhead = new ListNode(data);
        newhead.next = head;
        head = newhead;
    }

8.尾插法 addLast

    @Override
    public void addLast(int data) {
        ListNode node= new ListNode(data);
        if(head==null)
        {
            head = node;
        }
        else {
            //找尾
            ListNode cur = head;
            while(cur.next!=null)
            {
                cur = cur.next;
            }
            cur.next = node;
        }
    }

9、任意位置插入,第一个数据节点为0号下标 addIndex

    private  ListNode searchPrev(int index)
    {
        ListNode cur = head;
        int count = index-1;
        while(count--!=0)
        {
            cur = cur.next;
        }
        return cur;
    }
    @Override
    public void addIndex(int index, int data) {
        if(index<0||index>size())
        {
            return;
        }
        ListNode temp = new ListNode(data);
        if(index==0)
        {
            temp.next= head;
            head=temp;
        }
        else
        {
            ListNode cur= searchPrev(index);
            temp.next = cur.next;
            cur.next =temp;

        }

    }

10、删除第一次出现关键字为key的节点 remove

    public void remove(int key) {
        if(head==null)
        {
            return;
        }
        if(head.val==key)
        {
            head = head.next;
            return;
        }
        else
        {
            ListNode cur = head;
            while(cur.next!=null)
            {
                if(cur.next.val==key)
                {
                    cur.next = cur.next.next;
                    return;
                }
                cur= cur.next;
            }
        }
        return;
    }

11.删除所有值为key的节点 removeAllKey

   @Override
    public void removeAllKey(int key) {
        if(head==null)
        {
            return;
        }
        while(head.val==key)
        {
            head = head.next;
        }

        ListNode cur = head;
        while(cur.next!=null)
        {
            if(cur.next.val==key)
            {
                cur.next = cur.next.next;

            }
            else
            {
                cur=cur.next;
            }
        }

        return;
    }

12.删除所有值为key的节点 clear

    public void clear() {
        while(head!=null)
        {
            head.val = 0;//如果用泛型就是null
            head.next = null;
            head = head.next;
        }
    }

四、练习

1.移除链表元素

移除链表元素
我这里创了一个头节点headnode，这样后面包括head都可以用一样处理方式，最后返回头节点的下一个节点。

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode headnode = new ListNode();
        headnode.next = head;
        ListNode cur = headnode;
        while(cur.next!=null)
        {
            if(cur.next.val==val)
            {
                cur.next = cur.next.next;
            }
            else 
            {
                cur= cur.next;
            }
        }

        return headnode.next;
    }
}

2.反转链表

反转链表

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while (cur!=null)
        {
            ListNode temp = cur.next;
            cur.next =pre;
            pre =cur;
            pre = cur;
            cur =temp;
        }
        return pre;
    }
}

3.链表的中间节点

快慢指针：快的一步跳俩节点，慢的跳一节点，当快的到尾，慢的就到了中间。

class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode fast = head;
        ListNode low = head;

        while(fast!=null)
        {
            if(fast.next!=null)
            {
                fast = fast.next;
                low = low.next;
            }
            fast = fast.next;
        }
        return low;

    }
}

4.链表中倒数第k个节点

链表中倒数第k个节点

import java.util.*;
/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        ListNode cur = head;
        int count = 0;
        while(cur!=null)
        {
            count++;
            cur= cur.next;
        }
        
        ListNode ret = head;
        count=count-k;
        if(count<0)
        {
            return null;
        }
        while(count--!=0)
        {
            ret = ret.next;
        }
        
        return ret;
    }
}

5.合并两个有序链表

合并两个有序链表

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode cur1 = list1;
        ListNode cur2 = list2;
        ListNode head = new ListNode();
        ListNode end = head;
        while(cur1!=null&&cur2!=null)
        {
            if(cur1.val>cur2.val)
            {
                end.next = cur2;
                cur2 = cur2.next;
            }
            else
            {
                end.next = cur1;
                cur1 =cur1.next;
            }
            end = end.next;        
        }
            if(cur1==null)
            {
                end.next = cur2;
            }
            else if(cur2==null)
            {
                end.next = cur1;
            }
        
        return head.next;
    }
}

6.链表分割

链表分割
注意要把大于k的节点最后一个的next置为null可能会出现环

public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        ListNode smallHead = new ListNode(0);
        ListNode bigHead = new ListNode(0);
        ListNode smallCur = smallHead;
        ListNode bigCur = bigHead;
        ListNode cur = pHead;
        while(cur!=null)
        {
            if(cur.val<x)
            {
                smallCur.next = cur;
                smallCur =smallCur.next;
            }
            else
            {
                bigCur.next =cur;
                bigCur = bigCur.next;
            }
            cur = cur.next;
        }
        bigCur.next = null;
        smallCur.next = bigHead.next;
        return smallHead.next;
    }
}

7.链表回文结构

链表回文结构
1、用快慢指针找到中间节点
2、反转后面节点
3、从两边向中间验证是否是回文

import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class PalindromeList {
    public boolean chkPalindrome(ListNode A) {
        ListNode fast = A;
        ListNode slow = A;
        while(fast!=null&&fast.next!=null)
        {
            fast= fast.next.next;
            slow =slow.next;
        }
        ListNode pre = slow;
        slow = slow.next;
        while(slow!=null)
        {
            ListNode temp = slow.next;
            slow.next = pre;
            pre = slow;
            slow = temp;
        }
        slow =A;
        while(slow!=pre)
        {
            if(slow.val!=pre.val)
            {
                return false;
            }
            if(slow.next==pre)
            {
                break;
            }
            slow = slow.next;
            pre = pre.next;
            
        }
        return true;

    }
}

8.相交链表

相交链表
1、先测出两链表的长度
2、遍历俩链表，让较长的先走相差长度的步数
3、比较节点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int countA=0,countB=0;
        while(curA!=null)
        {
            countA++;
            curA =curA.next;
        }
        while(curB!=null)
        {
            countB++;
            curB =curB.next;
        }
        curA = headA;
        curB = headB;
        if(countA>countB)
        {
            int differ = countA-countB;
            while(differ--!=0)
            {
                curA = curA.next;
            }
        }
        else
        {
            int differ = countB-countA;
            while(differ--!=0)
            {
                curB = curB.next;
            }
        }

        while(curA!=null)
        {
            if(curA==curB)
            {
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }
}

9.环形链表

环形链表
快慢指针，相遇即为环形

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head==null)
        {
            return false;
        }
        ListNode fast = head;
        ListNode slow = head;
        while(fast!=null&&fast.next!=null)
        {
            fast = fast.next.next;
            slow =slow.next;
            if(fast==slow)
            {
                return true;
            }
        }
        return false;
    }
}

10.环形链表2

环形链表2
在快慢相遇时，在开头在创建指针，和相遇慢指针一起走，再次相遇即为环形节点。
在这里插入图片描述

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow =head;
        while(fast!=null&&fast.next!=null)
        {
            fast = fast.next.next;
            slow = slow.next;
            if(fast==slow)
            {
                break;
            }
        }
        if(fast==null||fast.next==null)
        {
            return null;
        }
        ListNode cur = head;
        while(cur!=slow)
        {
            cur = cur.next;
            slow = slow.next;
        }
        return cur;
    }
}

五、 模拟实现LinkedList

LinkedList是无头双向链表

1.定义接口

//头插法
public void addFirst(int data){ }
//尾插法
public void addLast(int data){}
//任意位置插入,第一个数据节点为0号下标
public void addIndex(int index,int data){}
//查找是否包含关键字key是否在单链表当中
public boolean contains(int key){}
//删除第一次出现关键字为key的节点
public void remove(int key){}
//删除所有值为key的节点
public void removeAllKey(int key){}
//得到单链表的长度
public int size(){}
public void display(){}
public void clear(){}

2.定义MyLinkedList

public class MyLinkedList implements IList{

    @Override
    public void addFirst(int data) {

    }

    @Override
    public void addLast(int data) {

    }

    @Override
    public void addIndex(int index, int data) {

    }

    @Override
    public boolean contains(int key) {
        return false;
    }

    @Override
    public void remove(int key) {

    }

    @Override
    public void removeAllKey(int key) {

    }

    @Override
    public int size() {
        return 0;
    }

    @Override
    public void display() {

    }

    @Override
    public void clear() {

    }
}

3.成员

1、节点类

存储数据，指向前一个节点的引用，指向后一个节点的引用。

    class ListNode {
        public int val;
        public  ListNode prev;
        public ListNode next;
        public ListNode(int val)
        {
            this.val = val;
        }
    }

2、头引用和尾引用

    public ListNode head;
    public ListNode last;

4.打印链表 display

    public void display() {
        ListNode cur = head;
        while(cur!=null)
        {
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
        System.out.println();
    }

5.查找是否包含关键字key是否在单链表当中 contions

    public boolean contains(int key) {
        ListNode cur = head;
        while(cur!=null)
        {
            if(cur.val==key)
            {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

6.头插法 addFirst

    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        node.next = head;
        node.prev = node;
        head = node;
    }

7.尾插法 addLast

    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if(head==null)
        {
            head =node;
            last = node;
        }
        else
        {
            last.next = node;
            node.prev = last;
            last = node;
        }

    }

8.任意位置插入,第一个数据节点为0号下标 addIndex

    public void addIndex(int index, int data) {
        if(index<0||index>size())
        {
            System.out.println("不合法index");
            return;
        }
        if(index==0)
        {
            addFirst(data);
            return;
        }
        if(index==size())
        {
            addLast(data);
            return;
        }
        int count = index-1;
        ListNode cur = head;
        while(count--!=0)
        {
            cur = cur.next;
        }
        ListNode node =new ListNode(data);
        node.prev = cur;
        node.next = cur.next;
        cur.next.prev =  node;
        cur.next = node;
    }

9.得到单链表的长度 size

   public int size() {
        ListNode cur =head;
        int count =0;
        while(cur!=null)
        {
            count++;
            cur =cur.next;
        }

        return count;
    }

10.删除第一次出现关键字为key的节点 remove

注意以下特殊情况：
1、删除头一个情况
2、删除头一个情况且只有一个节点
3、删除最后一个

   public void remove(int key) {
        ListNode cur  = head;
        while(cur!=null)
        {
            if(cur.val==key)
            {
                if(cur==head){
                    head = head.next;
                    if(head==null)
                    {
                        last = null;
                    }
                    else {
                        head.prev =null;
                    }
                }
                else
                {
                    cur.prev.next = cur.next;
                    if(cur.next==null)
                    {
                        last = last.prev;
                    }
                    else {
                        cur.next.prev = cur.prev;
                    }
                }
                return;
            }
            cur =cur.next;


        }

    }

11.删除所有值为key的节点 removeAllKey

同上但删除不return

    public void removeAllKey(int key) {
        ListNode cur  = head;
        while(cur!=null)
        {
            if(cur.val==key)
            {
                if(cur==head){
                    head = head.next;
                    if(head==null)
                    {
                        last = null;
                    }
                    else {
                        head.prev =null;
                    }
                }
                else
                {
                    cur.prev.next = cur.next;
                    if(cur.next==null)
                    {
                        last = last.prev;
                    }
                    else {
                        cur.next.prev = cur.prev;
                    }
                }
            }
            cur =cur.next;
        }
    }

12.清空 clear

    public void clear() {
        ListNode cur = head;
        while(cur!=null)
        {
            cur.prev = null;
            cur.val =-1;//如果是引用要置空null
            ListNode temp = cur.next;
            cur.next = null;
            cur = temp;
        }
        head =null;
        last =null;
    }

六、LinkedList

1.遍历

    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        System.out.println(list);
        System.out.println();
        System.out.println("========");
        for(Integer x:list)
        {
            System.out.print(x+" ");
        }
        System.out.println();
        System.out.println("========");
        for(int i = 0;i<list.size();i++)
        {
            System.out.print(list.get(i)+" ");
        }
        System.out.println();

        System.out.println("========");
        ListIterator<Integer> it = list.listIterator();
        while(it.hasNext())
        {
            System.out.print(it.next()+" ");
        }
        System.out.println();

        ListIterator<Integer> it2 = list.listIterator(list.size());
        while(it2.hasPrevious())
        {
            System.out.print(it2.previous()+" ");
        }
        System.out.println();
    }

在这里插入图片描述

2.ArrayList和LinkedList的区别？

在这里插入图片描述

沧海归城
关注
  • 20
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java-无头单向非循环链表的实现！
weixin_44378053的博客
02-27 154
头插法 尾插法 任意位置插入，第一个数据节点为0下标 查找是否包含关键字key在单链表当中 删除第一次出现关键字为key的节点 删除所有值为key的节点 得到链表的长度 class Node{ //一个Java文件可以存在多个class类，但是有且只能有一个可以是public class，并且这个public类的类名和文件名完全一样 public int data;//数据 publi...
Python实现-无头单向非循环链表
12-22
无头单向非循环链表结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等 无头单向非循环链表 对于任意一个数据元素a(i)来说，储存本身的数据.（这个域叫数据域） ...
【JAVA】实现一个无头单向非循环链表
CYQAQ的博客
12-31 179
【JAVA】实现一个无头单向非循环链表 链表 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 链表的结构多样，这里列出8种链表结构： 单向带头循环、单向不带头循环、单向带头非循环、单向不带头非循环 双向带头循环、双向不带头循环、双向带头非循环、双向不带头非循环 虽然有这么多的链表的结构，但是重点掌握两种: 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。 无头双向链表：在Java的集合框
链表之无头单向非循环链表
m0_48810566的博客
10-25 156
链表之无头单向非循环链表 链表的概念及结构 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构： 1.单向、双向 2.带头、不带头 3.循环、非循环 主要掌握两种： 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如 哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。 无头双向链表：在Java的集合框架库中LinkedList底层实现就是无头双向循环链表
链表之无头单向非循环链表（Java语言）
qq_57563254的博客
11-21 663
链表（Java语言）前言链表的概念及结构无头单向非循环链表节点类——ListNode链表类——MyLinkedList打印链表查找是否包含关键字获取链表的长度（节点的个数）插入一个节点——头插法 前言 上篇博客中介绍了顺序表有关的知识，我们知道顺序表增加，删除某个元素都需要移动其他元素，增加了时间复杂度；顺序表空间不够用又需要我们进行扩容，导致可能造成空间上的浪费，增加了空间复杂度，因此有必要优化顺序表，因此我们引入链表的概念。 链表的概念及结构 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是
无头单向非循环链表及部分接口（Java实现）
Dawn_xumujie的博客
09-26 161
链表 存储在不连续的内存空间上 更擅长插入和删除 此处我们在结尾以链表的插入接口为例 用图的形式详解该操作 public class TestLinkedlist { public static void main(String[] args) { testAddFirst(); testAddLast(); testAddIndex...
数据结构 --- 顺序表 和 无头单向非循环链表
wwzzzzzzzzzzzzz的博客
11-06 371
目录 顺序表和链表 1.顺序表 1.1概念及结构 1.2 接口实现 第一步:先实现代码基础: 第二步 : 实现 // 打印顺序表 第三步: 实现 // 获取顺序表的有效数据表长度 第四步:实现 // 在 pos 位置新增元素 第五步: 实现 // 判定是否包含某个元素 第六步: 实现 // 查找某个元素对应的位置 第七步: 实现 // 获取 pos 位置的元素 第八步: 实现// 给 pos 位置的元素设为 value 第九步: 实现 //删除第一次...
[数据结构] 链表之一(胖黑)毁所有 （无头单向非循环链表实现）
Nick 的笔记
04-13 291
​ 🍹欢迎各路大佬来到 Nick 主页指点 ☀️本期文章将学习 [数据结构] 链表之一(胖黑)毁所有 （无头单向非循环链表实现），我是博主Nick。✨ ✨我的博客主页：Nick_Bears 🌹꧔ꦿ 🌹꧔ꦿ博文内容如对您有所帮助，还请给个点赞 + 关注 + 收藏✨ ​
Java无头单向非循环链表实现（实现及测试都有示例代码）
qq_45691220的博客
03-17 137
一，链表的概念及结构 概念： 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。 结构： 实际中链表的结构非常多样，以下情况组合起来就有八种链表结构； 单向 ， 双向 带头 ， 不带头 循环 ， 非循环 二，代码实现 下面只介绍无头单向非循环链表的实现 代码实现： // 一个节点 class Node { public in...
【Java 数据结构】单向链表和双向链表的实现 (LinkedList)
热门推荐
书生-w的博客
04-16 1万+
​首先我们和ArrayList一样，将MySingleList单独定义为一个Java文件，然后每一个结点我们将它定义成一个静态内部类，这样就方便我们访问结点的成员，，还是和ArrayList一样，我们再定义一个Test类用来测试我们的单链表，写一个函数可以测试一下
doublelink.zip_DoubleLink java_双向链表实现
09-24
使用java语言实现双向链表，提供测试用例说明功能
CList.zip_CList_C语言实现vector_链表 c语言
09-22
C语言版的链表实现。带头节点的双向循环链表。访STL vector的实现。
LinkedList(Book).rar_Book 2_LinkedList java_java linkedlist_java
09-23
实现一个链表称为循环链表的变化。链表应该能够被用来保留任何对象类型的数据。在一个循环链表的最后一个节点 相连字段不为空，而是指回第一个节点。你的执行应当至少包括以下操作： 1.添加到列表的末尾 2.删除...
Java之单链表篇！！！ （无头单向非循环链表实现打印、头插、尾插、任意插入、查找、删除某一关键字、删除所有所选关键字、清空单链表等基本操作）
12-21
首先对单链表的结构进行介绍，单链表是由很多个节点一个接一个串接起来的，每个节点包含两部分，数据部分和地址部分，我们这里讲的是无头的单链表，所以没有头节点，每个节点存储的是本身的数据和下一个节点的地址。...
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 383
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 553
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 650
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
SpringBoot之请求映射原理
好记性不如烂笔头
06-12 1270
我们发出的请求，SpringMVC是如何精准定位到那个Controller以及具体方法？其实这都是 HandlerMapping 发挥的作用，这篇博文我们以 RequestMappingHandlerMapping 为例并结合源码一步步进行分析。默认 HandlerMapping 主要定义在和其祖父类中获取所有类型是 Object 的 beans，并且 beanName 不以开头根据 beanName 获取 beanType如果 beanType 上存在注解则进行处理。
java用LinkedList实现一个循环链表的代码
04-14
好的，以下是使用Java的LinkedList实现循环链表的示例代码： ```java import java.util.LinkedList; public class CircularLinkedList { public static void main(String[] args) { LinkedList<String> list = new LinkedList<>(); list.add("A"); list.add("B"); list.add("C"); list.add("D"); // 将最后一个元素链接到第一个元素，形成循环 list.getLast().next = list.getFirst(); // 遍历循环链表 Node current = list.getFirst(); for (int i = 0; i < list.size(); i++) { System.out.println(current.data); current = current.next; } } private static class Node { private String data; private Node next; public Node(String data) { this.data = data; } } } ``` 该代码使用Java的LinkedList实现循环链表。它首先创建一个LinkedList对象，并向其添加元素。然后，它将最后一个元素链接到第一个元素，形成循环链表。最后，它遍历循环链表并打印每个元素的值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值