Java数据结构（三）——顺序表与ArrayList

已于 2024-07-26 16:44:53 修改
阅读量624 收藏 21
点赞数 14
分类专栏： Java数据结构 文章标签： java 数据结构 开发语言 idea
于 2024-07-20 23:00:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaokuer_/article/details/140569615
版权

文章目录

顺序表

前置知识

顺序表是线性表的一种（底层是数组），另一种是链表，说到线性表，就得了解 List接口，站在数据结构的角度上，List接口就是线性表，即n个具有相同类型元素的有限序列，在该序列上可以执行增删查改以及变量等操作。

List接口继承自Collection接口，Collection接口规范了后序容器常用的一些方法，例如求元素个数size()、添加新元素add(E)/addAll(Collection<? extends E>)等等，如下图：

在这里插入图片描述

了解完Collection接口的方法，再来看一下List接口的方法，有很多，只截取一部分：
在这里插入图片描述

很多是吧，我们列举常用的，包括接下来要讲的ArrayList类，常用方法也是这几个：

  1. boolean add(E e)：尾插e
  2. void add(int index, E element)：将 e 插入到index位置
  3. boolean addAll(Collection<? extends E> c)：尾插 c 中的所有元素(参数列表的形式我们会在泛型进阶讲解)，这里的参数可以接受任何类型的集合，只要这个集合的元素类型是 E 或其子类。
  4. E remove(int index)：删除 index 位置的元素
  5. boolean remove(Object o)：删除遇到的第一个 o
  6. E get(int index)：获取 index 下标位置元素，
  7. E set(int index, E element)：将 index 下标位置元素设置为 element
  8. void clear()：清空容器
  9. boolean contains(Object o)：判断 o 是否在线性表中
  10. int indexOf(Object o)：返回第一个 o 所在的下标
  11. int lastindexOf(Object o)：返回最后一个 o 所在的下标
  12. List<E> subList(int fromIndex, int toIndex)：截取下标区间 [fromIndex, int toIndex] 的元素

【List的使用】

List是一个接口，并不能直接用来实例化，使用时必须实例化List的实现类。 在集合框架中，ArrayList和LinkedList都实现了List接口，而ArrayList就是本篇要介绍的主角。

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。在集合框架中，对应 ArrayList类。不过要注意的是，这个数组只能依次存储，不能跳跃式的存储，比如，添加新的元素，不能跳过一个下标，存储在后面，必须依次存储。

我们先看ArrayList类的部分源码：

在这里插入图片描述

  • ArrayList是以泛型方式实现的，是一个泛型类，注意实例化
  • ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
  • ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
  • ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
  • 另外，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或CopyOnWriteArrayList
  • ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

ArrayList的构造

ArrayList的构造方法有三个：

  1. ArrayList()：无参数构造方法
  2. ArrayList(Collection<? extends E> c)：利用其他实现了Collection接口的容器构造
  3. ArrayList(int initialCapacity)：指定顺序表初始容量的构造方法
        public static void main(String[] args) {
            
            ArrayList<Integer> l1 = new ArrayList<>();//无参构造
            System.out.println(l1);
            
            ArrayList<Integer> l2 = new ArrayList<>(10);//指定初始容量构造
            l2.add(1);
            l2.add(2);
            System.out.println(l2);
            
            ArrayList<Integer> l3 = new ArrayList<>(l2);//使用l2构造
            System.out.println(l3);
        }

在这里插入图片描述

  • 如上代码，我们使用了其他ArrayList对象l2作为参数构造了l3，即将l2的所有元素作为l3初始数据

当然我们可以定义List接口的引用接收ArrayList对象：

            List<Integer> list = new ArrayList<>();
  • 优点：向上转型，从而可以实现多态
  • 缺点：无法调用ArrayList特有的方法，只能调用ArrayList中重写List接口的方法

ArrayList的常用方法

ArrayList类中的常用方法与上文列举的List接口中常用方法一致，这里仅给出演示代码，一些小的注意问题在注释给出：

    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();

        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(5);
        list1.remove(2);//删除下标为2位置的元素
        list1.remove(Integer.valueOf(5));//删除值为5的元素
        System.out.println(list1);//打印结果为[1, 2, 4]
        list2.add(6);
        list2.add(7);
        list2.add(8);
        list1.addAll(list2);//将list2中的所有元素尾插到list1中
        System.out.println(list1);//打印结果为[1, 2, 4, 6, 7, 8]
        list1.set(0, 100);//将0下标位置设置为100
        System.out.println(list1.get(0));//打印0下标位置的元素100
//        list1.add(100, 100);   error，报错！因为顺序表只允许连续存储，不允许跳跃式存储
        System.out.println(list1.contains(100));//100在表中，打印true
        List<Integer> list3 = list1.subList(0, 3);//截取[0, 3)下标位置的元素，返回一个List<Integer>的对象，用list3接收
        System.out.println(list3);//打印结果是[100, 2, 4]
    }

ArrayList的遍历

前面的演示代码中我们使用System.out.println(对象的引用);的方式打印表中的数据，这是因为ArrayList类中重写了toString方法

现在我们介绍三种ArrayList的遍历方法：for、for-each以及迭代器

直接看代码：

   public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        //for循环 + 下标遍历
        System.out.println("=====for循环=====");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();

        //for-each循环
        System.out.println("=====for-each循环=====");
        for (int x : list) {
            System.out.print(x + " ");
        }
        System.out.println();
        for(Integer x : list) {
            System.out.print(x + " ");
        }
        System.out.println();

        //使用迭代器
        System.out.println("=====使用迭代器=====");
        Iterator<Integer> it = list.iterator();
        while(it.hasNext()) {
            System.out.print(it.next() + " ");
        }
        System.out.println();

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

        System.out.println("=====逆序输出=====");
        ListIterator<Integer> lIt1 = list.listIterator(list.size());
        while(lIt1.hasPrevious()) {
            System.out.print(lIt1.previous() + " ");
        }
    }

在这里插入图片描述

  • for循环：利用方法size()和get()即可
  • for-each：以整型为例，:左边可以是Integer包装类也可以是int(自动拆箱)
  • 迭代器：Iterator和ListIterator都是接口，ListIterator接口继承了Iterator接口，使用时调用指定方法即可
  • 对于拓展的逆序输出，ListIterator可以做到，但是Iterator没有相关的方法

ArrayList的扩容机制

抛出几个问题：使用ArrayList的空构造方法实例化的顺序表初始容量是多少？；向顺序表中添加数据时，如果表满了，怎么扩容？

对于这几个问题，我们要观察ArrayList的源码：

在这里插入图片描述

对于ArrayList实现的接口以及表示的含义前面已经介绍过了，直接看定义的成员变量：

  • serialVersionUID是Java序列化机制中的一个特殊字段，用于标识类的版本

  • DEFAULT_CAPACITY是默认的初始化容量，为10

  • EMPTY_ELEMENTDATA与DEFAULTCAPACITY_EMPTY_ELEMENTDATA：

    共同点：

    • 它们都是用来表示空ArrayList实例的静态final常量。
    • 它们都是Object类型的数组。
    • 它们都被声明为private，只在ArrayList内部使用。

    区别：

    • EMPTY_ELEMENTDATA是一个真正的空数组（长度为0），而DEFAULTCAPACITY_EMPTY_ELEMENTDATA的长度等于DEFAULT_CAPACITY。
    • 当添加第一个元素时，如果使用的是EMPTY_ELEMENTDATA，则需要创建一个新的数组并设置其大小为DEFAULT_CAPACITY；如果使用的是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，则可以直接在原数组上进行调整。
    • EMPTY_ELEMENTDATA用于普通的空ArrayList实例，而DEFAULTCAPACITY_EMPTY_ELEMENTDATA用于那些初始容量已经设置为默认容量的空ArrayList实例。

  • elementData：即顺序表，存储顺序表的元素

  • size：当前顺序表的有效数据数量

接着我们看一下三个构造方法：

在这里插入图片描述

  • 初始化顺序表容量的构造方法：当传入的初始化容量为0时，将EMPTY_ELEMENTDATA赋值给顺序表elementData
  • 无参构造方法：无参构造方法初始容量其实设置为了默认容量，所以赋值DEFAULTCAPACITY_EMPTY_ELEMENTDATA
  • 利用其他Collection的构造方法：先将集合c转化为Object类型的数组，如果数组不为空，判断c的类是否为ArrayList，为真，直接赋值；为假，则通过copyOf创建新数组并拷贝，用新数组赋值；如果数组为空，直接赋值EMPTY_ELEMENTDATA

到这里，我们解决了第一个问题并且拓展了一些，并考虑一个新的问题，这个问题将和最初的问题2一并解决：空构造方法实例化的表是个空数组，那么添加时怎么操作的？

从add()方法入手：

在这里插入图片描述

如图第二个add调用了第一个add方法，而第一个和第三个add在表满时，均调用了一个grow()方法

在这里插入图片描述

然后，无参grow又调用了带有参数的grow方法

在这里插入图片描述

首先，将当前容量赋值给oldCapacity，如果if语句判断为假（oldCapacity <= 0 && elementData == DEFAULTCAPACITY_EMPTY_ELEMRNTDATA），执行else语句，即：当添加第一个元素时，如果使用的是无参构造方法，ArrayList会将内部数组的容量从0扩展到10，并赋值；如果if语句判断为真，则调用ArraysSupport.newLength方法计算新容量newCapacity，传入的第一个参数是旧容量，第二个参数是，增长的容量，即带参数的grow的参数与旧容量的差值（由于参数为size + 1，所以这里是1），第三个参数是旧容量的一半。

在这里插入图片描述

newLength方法接受三个参数：oldLength（旧数组长度）、minGrowth（最小增长量）和prefGrowth（首选增长量）。它首先计算首选长度prefLength，即旧数组长度加上minGrowth和prefGrowth中的较大值。然后，如果首选长度在0到SOFT_MAX_ARRAY_LENGTH（数组的最大长度限制）之间，就返回这个首选长度；否则，调用hugeLength方法来处理较大的长度情况。

hugeLength方法也接受两个参数：oldLength和minGrowth。它首先计算最小所需长度minLength，即旧数组长度加上最小增长量。然后，如果minLength小于0（表示溢出），就抛出一个OutOfMemoryError异常，提示所需的数组长度过大。如果minLength小于等于SOFT_MAX_ARRAY_LENGTH，则返回SOFT_MAX_ARRAY_LENGTH；否则，返回minLength。

【总结】

回归到最初的grow方法：

  1. 检测是否真正需要扩容，如果是调用grow准备扩容
  2. 预估需要库容的大小 初步预估按照1.5倍大小扩容 如果用户所需大小超过预估1.5倍大小，则按照用户所=需大小扩容，真正扩容之前检测是否能扩容成功，防止太大导致扩容失败
  3. 使用copyOf进行扩容
  4. 另外，如果使用的是无参构造方法，当添加第一个元素时，ArrayList会将内部数组的容量从0扩展到10，此后按照上3步

ArrayList的模拟实现

模拟实现一个ArrayList类是比较简单的，只需要掌握对数组的增删查改即可。

实现方式多种多样，能实现增删查改等业务即可，这里给出模拟实现的代码，感兴趣的可以看一下：

import java.util.Arrays;

public class MyArrayList {
    public int[] elem;
    public int capacity;
    public int usedSize;//0
    //默认容量
    private static final int DEFAULT_SIZE = 10;

    public MyArrayList() {
        this.elem = new int[DEFAULT_SIZE];
        this.capacity = 10;
    }

    /**
     * 打印顺序表:
     *   根据usedSize判断即可
     */
    public void display() {
        if(this.isEmpty()) {
            return;
        }
        for(int i = 0; i < this.usedSize; i++) {
            System.out.print(elem[i] + " ");
        }
        System.out.println();
    }

//     新增元素,默认在数组最后新增
    public void add(int data) {
        if(isFull()) {
            this.elem = Arrays.copyOf(this.elem, 2 * this.capacity);
        }
        this.elem[this.usedSize] = data;
        this.usedSize++;
    }

    /**
     * 判断当前的顺序表是不是满的！
     * @return true:满   false代表空
     */
    private boolean isFull() {
        if(this.usedSize == this.capacity) {
            return true;
        }else {
            return false;
        }
    }


    private boolean checkPosInAdd(int pos) {
        //在0位置添加可以，同时在最后位置也可以添加，但是不可以跳着增加
        if(pos >= 0 && pos <= this.usedSize) {
            return true;
        }else {
            throw new PosIllegalException("位置不合法！");
        }
    }

    // 在 pos 位置新增元素
    public void add(int pos, int data) throws PosIllegalException {
        if(isFull()) {
            this.elem = Arrays.copyOf(this.elem, 2 * this.capacity);
        }
        try{
            checkPosInAdd(pos);
            for(int i = this.usedSize; i > pos; i--) {
                this.elem[i] = this.elem[i - 1];
            }
            this.elem[pos] = data;
        }catch (PosIllegalException e) {
            System.out.println("输入的位置不合法！插入失败");
            e.printStackTrace();
        }
    }

    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        if(isEmpty()) {
            return false;
        }
        for(int i = 0; i < this.usedSize; i++) {
            if(toFind == this.elem[i]) {
                return true;
            }
        }
        return false;
    }
    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
        if(isEmpty()) {
            System.out.println("表为空！");
            return -1;
        }
        for (int i = 0; i < this.usedSize; i++) {
            if(toFind == this.elem[i]) {
                return i;
            }
        }
        return -1;
    }

    // 获取 pos 位置的元素
    public int get(int pos) throws PosIllegalException {
        if(isEmpty()) {
            System.out.println("表为空！返回值无效！");
            return -1;
        }
        try {
            checkPosInAdd(pos);
            return this.elem[pos];
        }catch (PosIllegalException e) {
            System.out.println("查找的位置不合法,返回值无效！");
            e.printStackTrace();
        }
        return -1;
    }

    private boolean isEmpty() {
        if(this.usedSize == 0) {
            return true;
        }else {
            return false;
        }
    }
    // 给 pos 位置的元素设为【更新为】 value
    public void set(int pos, int value) {
        if(isEmpty()) {
            System.out.println("表为空！");
            return;
        }else {
            try {
                checkPosInAdd(pos);
                this.elem[pos] = value;
            }catch (PosIllegalException e) {
                System.out.println("位置不合法！");
                e.printStackTrace();
            }
        }
    }

    /**
     * 删除第一次出现的关键字key
     * @param key
     */
    public void remove(int key) {
        if(isEmpty()) {
            System.out.println("表为空");
        }
        for(int i = 0; i < this.usedSize; i++) {
            if(this.elem[i] == key) {
                for(int j = i; j < this.usedSize - 1; j++) {
                    this.elem[j] = this.elem[j + 1];
                }
                this.usedSize--;
                return;
            }
        }
        System.out.println("没有找到关键字！");
        return;
    }

    // 获取顺序表长度
    public int size() {
        return this.usedSize;
    }

    // 清空顺序表
    public void clear() {
        this.usedSize = 0;
    }
}

public class PosIllegalException extends RuntimeException {
    public PosIllegalException() {

    }

    public PosIllegalException(String mes) {
        super(mes);
    }
}

ArrayList的相关练习

给定一个非负整数 numRows， 生成「杨辉三角」的前 numRows 行。

class Solution {
    public List<List<Integer>> generate(int numRows) {
        //补充代码
    }
}

杨辉三角大家应该不陌生，如下：

1
1 1
1 2 1
1 3 3 1
… …

题目最大的特点是返回值类型：List<List<Integer>>，即返回一个实现了List接口的集合，其每一个元素也是这个集合的类型，这意味着集合中的每个元素代表杨辉三角的一行，每个元素又是一个集合，这个集合的每个元素是杨辉三角每一行的每个元素。我们刚刚学习了ArrayList，所以我们会使用ArrayList完成。

杨辉三角的第一行一定是一个1，每一行的第一个和最后一个元素一定是1，基于这一点，我们直接实现：

class Solution {
    public List<List<Integer>> generate(int numRows) {
        ArrayList<List<Integer>> list = new ArrayList<>(numRows);
        //第一行的1
        ArrayList<Integer> l1 = new ArrayList<>();
        l1.add(1);
        list.add(l1);
        //后续行
        for(int i = 1; i < numRows; i++) {
            ArrayList<Integer> lTmp = new ArrayList<>();
            lTmp.add(1);//第一个元素一定是1
            for(int j = 1; j < i; j++) {
                lTmp.add(list.get(i - 1).get(j - 1) + list.get(i - 1).get(j));
            }//每一行的中间元素
            lTmp.add(1);//最后一个元素一定是1
            list.add(lTmp);
        }
        return list;
    }
}

可能会出现以下报错(也是裤儿出现的问题)：

Line 16: error: incompatible types: ArrayList<ArrayList<Integer>> cannot be converted to List<List<Integer>> return list;

因为：

ArrayList<ArrayList>和ArrayList<List>之间的类型不兼容，不能直接进行互相转换。

在Java泛型中，类型擦除会导致泛型类型的具体信息在编译时被擦除，因此在运行时，泛型类型的实例并不知道它们的类型参数的具体类型。这意味着，尽管ArrayList是List的子类，但在泛型类型中，它们被视为不同的类型。

原题链接：118. 杨辉三角 - 力扣（LeetCode）

完

四角小裤儿儿
关注
  • 14
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
合工大数据结构顺序表实验
04-14
本实验“合工大数据结构顺序表实验”聚焦于数据结构中的一个重要基础概念——顺序表。顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储，就像数组一样。对于18级合工大的学生来说，这个实验旨在深化他们...
Java实现数据结构中的算法------第一讲 顺序表
06-10
在本课程中，我们将深入探讨如何使用Java语言来实现数据结构中的核心算法，特别是第一讲的重点——顺序表。顺序表是一种基本的数据结构，它在内存中连续存储元素，操作直观且效率较高。以下是对顺序表及其相关算法的...
Java实现数据结构——顺序表
2303_80472275的博客
06-10 619
笔者在以前的文章中实现过顺序表本文在理论上不会有太详细的讲述如有需要可以翻看笔者之前的文章Java中已经封装好了顺序表的类但在使用之前先自己实现一遍。
java 的数据结构之路——顺序表ArrayList（附带Java、C语言 版本的代码）
m0_62747332的博客
09-10 644
线性表顾名思义就是将数据元素排列成一条线一样的表，严格来说，线性表是具有相同特性的元素的一个有序的序列。其特征有三，其一是所有的数据元素的类型相同，线性表示有有限个数据元素组成，并且数据元素与位置相关。本博客首先介绍线性表中的顺序存储结构——顺序表。
Java数据结构————顺序表（增删改查详细实现）
执梗的博客
10-19 2343
1.什么是顺序表 在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。 对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种有意义的信息，或者表示数据之间的某种关系。 这样的一组序列元素的组织形式，我们可以将其抽象为线性表。一个线性表是某类元素的一个集合，还记录着元素之间的一种顺序关系。线性表是最基本的数据..
数据结构——顺序表（java实现）
2301_77993957的博客
07-08 546
顺序表是线性表的一种所谓线性表指一串数据的组织存储在逻辑上是线性的，而在物理上不一定是线性的顺序表的底层实现是数组，其由一群数据类型相同的元素组成，其在逻辑与物理上均是线性的。
【数据结构】——顺序表
weixin_62678196的博客
08-17 350
线性表是n个具有相同特性的数据元素的有限序列,让我们一起来学习一下顺序表吧！
数据结构——顺序表
龍弟-idea的博客
11-26 3593
线性表是n个具有相同特性的数据元素的有限序列。常见的线性表：顺序表、链表、栈、队列、字符串…
java数据结构——顺序表（MyArrayList的实现）
weixin_62144403的博客
10-12 506
实现一个自己顺序表MyArrayList来体会顺序表背后对元素的存储和操作过程
JavaDS —— 顺序表ArrayList
hong_z_c的博客
07-08 1335
Java中的ArrayList
java顺序表——ArrayList详解
baixian110的博客
05-12 1431
/数组最大容量 public int [ ] elem;//第一一个数组，用于存储数据 public int useSize;//记录存储了多少数据 }// 新增元素,默认在数组最后新增 public void add(int data) {} // 在 pos 位置新增元素 public void add(int pos , int data) {} // 判定是否包含某个元素 public boolean contains(int toFind) {
[数据结构——Java]线性表、ArrayList与顺序表
qq_63492484的博客
05-19 1163
线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列... 线性表在逻辑上是线性结构，也就说是连续的一条直线。ArrayList虽然提供的方法比较多，但是常用方法如下所示，需要用到其他方法时，可以自行查看ArrayList的帮助文档。ArrayList是一个动态类型的顺序表，即：在插入元素的过程中会自动扩容。连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。ArrayList最长使用的遍历方式是：for循环+下标 以及 foreach。
数据结构与算法 （JAVA）
05-23
除了这些基础数据结构，还有一种特别重要的数据结构——哈希表，也称为散列表。在Java中，HashMap和Hashtable是实现哈希表的常用类，提供快速的键值对存取。 接下来，我们谈谈算法。算法是一系列解决问题的步骤，是...
实验一 顺序表基本操作的实现
12-18
在本实验“实验一 顺序表基本操作的实现”中，我们将深入探讨数据结构的核心概念——顺序表。数据结构是计算机科学中一个至关重要的领域，它研究如何有效地组织和存储数据，以便进行高效的检索、更新和删除等操作。...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1193
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 483
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 263
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1952
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
Java实现拼图小游戏
Aishangyuwen的博客
07-22 1343
Java实现拼图小游戏
寻找两个顶点间最短路径——数据结构与算法解析
"这篇资料主要讨论的是数据结构中的路径寻找问题，特别是在Java环境下。核心问题是如何在两个顶点之间找到最短路径。" 在计算机科学中，数据结构是组织和管理数据的重要方式，它影响着算法的效率和程序的性能。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值