《Java数据结构》--顺序表

已于 2024-04-17 10:01:29 修改
阅读量891 收藏 8
点赞数 19
分类专栏： 数据结构 文章标签： java 数据结构 开发语言
于 2024-04-17 09:46:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73290424/article/details/137825845
版权

📕前言

📖文章吸纳了一些大佬的文章，但大部分纯手敲哦，欢迎光临小林课堂！！！

在学习顺序表之前呢，我们得先了解以下  " 何为线性表？"

线性表：是一种在实际中广泛使用得数据结构，常见的线性表有：顺序表，链表，栈，队列 ...

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

我们的今天学习的顺序表的底层结构其实就是 一个数组

顺序表 是使用数组 来完成的一种结构

顺序表介绍：

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

顺序表一般可以分为：

  1. 静态顺序表：使用定长数组存储元素。( 本篇内容主要围绕静态顺序表展开 )
  2. 动态顺序表：使用动态开辟的数组存储

模拟实现 顺序表

为什么要模拟实现：
自己模拟实现 简易版的 顺序表的增删查改等主要功能，大致理解顺序表的设计思想
再对比学习 Java 提供的集合类当中的 ArrayList ，在学习 Java 的 ArrayList 常用方法的同时，也能学习源码的思想

 📒本文将创建两个Java文件：

My ArraysList.java 用于顺序表的实现，

Test.java 用于对顺序表里的各个接口的测试

顺序表功能接口概览

import java.util.Arrays;

public class MyArrayList {
    private int[] elem;//用来存放数据元素
    private int usedSize; //代表当前顺序表当中的有效数据个数
    //为什么不初始化 usedSize 因为引用类型不初始化的话，默认值就是 零
    //

    private static final int DEFAULT_SIZE = 2;//定义一个静态常量，更加安全
    
    //初始化顺序表
    public MyArrayList() {//这就默认大小是2
        this.elem = new int[DEFAULT_SIZE];
    }

    /*
     * 指定容量
     *  initCapacity
     * */
    public MyArrayList(int initCapacity) {
        this.elem = new int[initCapacity];
    }



    // 新增元素,默认在数组最后新增
    public void add(int data) { }

    // 在 pos 位置新增元素
    public void add(int pos, int data) { }

    // 判定是否包含某个元素
    public boolean contains(int toFind) { return true; }

    // 查找某个元素对应的位置
    public int indexOf(int toFind) { return -1; }

    // 获取 pos 位置的元素
    public int get(int pos) { return -1; }

    // 给 pos 位置的元素设为 value
    public void set(int pos, int value) { }

    //删除第一次出现的关键字key
    public void remove(int toRemove) { }

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

    // 清空顺序表
    public void clear() { }

    // 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
    public void display() { }
}

  基本功能的实现

🌰判断顺序表内存是否已经满了

public boolean isFull() {
        if (this.usedSize == this.elem.length) {
            return true;
        }
        return false;
    }

🌰对顺序表进行扩容

 //对顺序表进行扩容
private void expand() {
        this.elem = Arrays.copyOf(
                this.elem, this.elem.length * 2);
        System.out.println("已经成功扩容至原来的两倍");
    }

🌰打印顺序表

    /*
     * 打印顺序表
     * 实际上是 遍历数组
     * */
    
//打印的第一种方式
    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + "  ");
        }
        System.out.println();
    }

//打印的第二种方式,用Arrays.toString直接打印
     public void display(){
        System.out.println(Arrays.toString(this.elem));
    }

🌰获取顺序表的有效长度

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

🌰清空顺序表

// 清空顺序表
    public void clear() {
        /*for (int i = 0; i < this.usedSize; i++) {
            this.elem[i] = null;
        }
        //如果这是引用类型,就要这么写,要把一个个对象置为 null 空
        */
        this.usedSize = 0;// 注意有效数组长度也要清零
    }

 🌰自定义异常 （检查 pos 位置是否合法）

    /*
     * 检查 pos 位置是否合法
     * @param pos
     * */

    private void checkPos(int pos) {//用 private 只是希望在这个类里面使用
        if (pos < 0 || pos >= this.usedSize) {
            throw new PosOutOfBoundException(pos + "  位置不合法");//自定义异常

//            System.out.println("新增位置不合法");
//            return;

        }
    }

定义的异常接口功能

越界时，抛出异常

/**
 * @Author XiaoLin
 * @Description: 位置超过，越界，抛出异常
 * 自定义异常
 */

public class PosOutOfBoundException extends RuntimeException{
    public PosOutOfBoundException() {
    }

    public PosOutOfBoundException(String message) {
        super(message);
    }
}

顺序表四大功能（增删查改）

一，增加数据

🔢头插

//新增元素，在数组最前面新增
    public void addHead(int data) {
        if (isFull()) {
            System.out.println("数组满了，需要扩容");
            expand();
        }else {
            // 从usedSize下标开始，不会数组越界( 此时的 elem.length > usedSize )
            for (int i = this.usedSize; i > 0 ; --i) {
                this.elem[i] = this.elem[i - 1]; //从后往前挪动数据，为的是给顺序表的表头腾出来
            }
            this.elem[0] = data; //在顺序表开头插入
            this.usedSize++;     //数组有效长度加一
        }
        
    }

🔢尾插

 // 新增元素,默认在数组最后新增
 //数据结构是一门逻辑非常严谨的学科

    public void add(int data) {
        if (isFull()) {
            System.out.println("数组满了,需要扩容");
            //扩容
            expand();
        }
        this.elem[this.usedSize] = data;
        this.usedSize++;
    }

🔢指定下标插入

  1. 判断pos位置是否合法 （在顺序表中，数据是连续的，中间不能有空缺）
  2. 判断顺序表是否满了，如果满了，需要扩容
  3. 插入数据（可能需要挪动元素） 
 // 在 pos 位置新增元素
    public void add(int pos, int data) {
        if (pos < 0 || pos > this.usedSize) {
            throw new PosOutOfBoundException(pos + "  位置不合法");//自定义异常

            //System.out.println("新增位置不合法");
            //return;

        }
        //重载
        if (isFull()) {
            //扩容
            this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);
        }
        for (int i = this.usedSize - 1; i >= pos; i--) {
            this.elem[i + 1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
    }

 二，删除数据

🔢头插

//删除表头元素
    public void removeHead() {
        if (isempty()){
            System.out.println("顺序表为空，删除不合法");
            return;
        }
        //从第一个元素开始，用后面元素的值覆盖掉前面的值，遍历整个数组就相当于把第一个元素用覆盖的方式抹去了
        for (int i = 1; i < this.usedSize; i++) {
            this.elem[i - 1] = this.elem[i];
        }
        this.elem[this.usedSize -1] = 0;// 现在的最后一个元素是原来的倒数第二个元素，所以原来的最后一个有效元素要置0
        this.usedSize--;// 不要忘记改变有效数组的长度
    }

🔢尾插

//删除表尾元素
    public void removeTail() {
        if (isempty()){
            System.out.println("顺序表为空，删除不合法");
            return;
        }
        this.elem[this.usedSize - 1] = 0;// 直接将最后一个元素置0就完成了尾删
        this.usedSize--;
    }

🔢指定下标元素的删除

//指定下标元素的删除
    public void removePos(int pos) {
        if (isempty()){
            System.out.println("顺序表为空，删除不合法");
            return;
        }
        checkPos(pos);// 检查输入的pos下标合不合法
        for (int i = pos; i < this.usedSize - 1; ++i) {
            this.elem[i] = this.elem[i + 1];// 从要删除的下标开始，用后边元素的值覆盖掉前面的值，就完成了删除
        }
        this.elem[this.usedSize - 1] = 0;// 要完整的删除，将挪动的最后一个元素的原本位置 置空
        this.usedSize--;
    }

 🔢删除首次出现的指定元素

//删除第一次出现的关键字key
    public void remove(int toRemove) {
        int index = indexOf(toRemove);
        if (index == -1) {
            System.out.println("没有这个数据！！");
            return;
        }
        for (int i = index; i < this.usedSize - 1; i++) {
            this.elem[i] = this.elem[i + 1];
        }
        //this.elem[usedSize-1] = null; //如果这是引用类型就要这句,
        
        this.usedSize--;
    }

三，查找数据

 🔢获取指定位置的元素

  1. 考虑要获取的位置是否合法
  2. 返回指定位置的元素 
// 查找某个元素对应的位置
    public int indexOf(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return i;
            }
        }
        return -1;
    }

  🔢获取指定元素所在的位置

// 获取 pos 位置的元素
    public int get(int pos) {
        checkPos(pos);//调用自定义异常方法
        //没找到就会报异常
        return this.elem[pos];
    }

  🔢查找表中是否包含某个元素

// 判定是否包含某个元素
    public boolean contains(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }

四，修改数据

🙌首先考虑修改的位置是否合法

🙌考虑特殊情况

// 给 pos 位置的元素设为 value  [ 更新 ]

public void set(int pos, int value) {
        checkPos(pos); //判断要修改的位置合不合法
        this.elem[pos] = value;
    }

总代码

📖MyArrayList.java 

import java.util.Arrays;

/**
 * @Author XiaoLin
 * @Description:
 */
public class MyArrayList {
    private int[] elem;//用来存放数据元素
    private int usedSize; //代表当前顺序表当中的有效数据个数
    //为什么不初始化 usedSize 因为引用类型不初始化的话，默认值就是 零
    //

    private static final int DEFAULT_SIZE = 2;//定义一个静态常量

    public MyArrayList() {//这就默认大小是2
        this.elem = new int[DEFAULT_SIZE];
    }



    /*
     * 指定容量
     *  initCapacity
     * */
    public MyArrayList(int initCapacity) {
        this.elem = new int[initCapacity];
    }


    /*
     * 打印顺序表
     * 实际上是 遍历数组
     * */
    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + "  ");
        }
        System.out.println();
    }
    public void display2(){
        System.out.println(Arrays.toString(this.elem));
    }

    
    //新增元素，在数组最前面新增
    public void addHead(int data) {
        if (isFull()) {
            System.out.println("数组满了，需要扩容");
            expand();
        }else {
            // 从usedSize下标开始，不会数组越界( 此时的 elem.length > usedSize )
            for (int i = this.usedSize; i > 0 ; --i) {
                this.elem[i] = this.elem[i - 1]; //从后往前挪动数据，为的是给顺序表的表头腾出来
            }
            this.elem[0] = data; //在顺序表开头插入
            this.usedSize++;     //数组有效长度加一
        }

    }


    // 新增元素,默认在数组最后新增
    //数据结构是一门逻辑非常严谨的学科
    public void add(int data) {
        if (isFull()) {
            System.out.println("数组满了,需要扩容");
            //扩容
            expand();
        }
        this.elem[this.usedSize] = data;
        this.usedSize++;
    }
    

    //扩容
    private void expand() {
        this.elem = Arrays.copyOf(
                this.elem, this.elem.length * 2);
        System.out.println("已经成功扩容至原来的两倍");
    }
    


    public boolean isFull() {
        if (this.usedSize == this.elem.length) {
            return true;
        }
        return false;
    }
    

    // 在 pos 位置新增元素
    public void add(int pos, int data) {
        if (pos < 0 || pos > this.usedSize) {
            throw new PosOutOfBoundException(pos + "  位置不合法");//自定义异常
//            System.out.println("新增位置不合法");
//            return;
        }
        //重载
        if (isFull()) {
            //扩容
            this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);
        }
        for (int i = this.usedSize - 1; i >= pos; i--) {
            this.elem[i + 1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;

    }


    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }

    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return i;
            }
        }
        return -1;
    }
    

    // 获取 pos 位置的元素
    public int get(int pos) {
        checkPos(pos);//调用自定义异常方法
        return this.elem[pos];
    }

    
    // 给 pos 位置的元素设为 value  [ 更新 ]
    public void set(int pos, int value) {
        checkPos(pos);
        this.elem[pos] = value;
    }


    /*
     * 检查 pos 位置是否合法
     * @param pos
     * */

    private void checkPos(int pos) {//用 private 只是希望在这个类里面使用
        if (pos < 0 || pos >= this.usedSize) {
            throw new PosOutOfBoundException(pos + "  位置不合法");//自定义异常

//            System.out.println("新增位置不合法");
//            return;

        }
    }
    

    //判断当前顺序表是否为空
    public boolean isempty() {
        if(this.usedSize == 0){
            return true;//空的
        }
        else return false; //还没空
    }

    
    //删除表头元素
    public void removeHead() {
        if (isempty()){
            System.out.println("顺序表为空，删除不合法");
            return;
        }
        //从第一个元素开始，用后面元素的值覆盖掉前面的值，遍历整个数组就相当于把第一个元素用覆盖的方式抹去了
        for (int i = 1; i < this.usedSize; i++) {
            this.elem[i - 1] = this.elem[i];
        }
        this.elem[this.usedSize -1] = 0;// 现在的最后一个元素是原来的倒数第二个元素，所以原来的最后一个有效元素要置0
        this.usedSize--;// 不要忘记改变有效数组的长度
    }
    

    //删除表尾元素
    public void removeTail() {
        if (isempty()){
            System.out.println("顺序表为空，删除不合法");
            return;
        }
        this.elem[this.usedSize - 1] = 0;// 直接将最后一个元素置0就完成了尾删
        this.usedSize--;
    }


    //指定下标元素的删除
    public void removePos(int pos) {
        if (isempty()){
            System.out.println("顺序表为空，删除不合法");
            return;
        }
        checkPos(pos);// 检查输入的pos下标合不合法
        for (int i = pos; i < this.usedSize - 1; ++i) {
            this.elem[i] = this.elem[i + 1];// 从要删除的下标开始，用后边元素的值覆盖掉前面的值，就完成了删除
        }
        this.elem[this.usedSize - 1] = 0;// 要完整的删除，将挪动的最后一个元素的原本位置 置空
        this.usedSize--;
    }


    //删除第一次出现的关键字key
    public void remove(int toRemove) {
        int index = indexOf(toRemove);
        if (index == -1) {
            System.out.println("没有这个数据！！");
            return;
        }
        for (int i = index; i < this.usedSize - 1; i++) {
            this.elem[i] = this.elem[i + 1];
        }
//        this.elem[usedSize-1] = null; //如果这是引用类型就要这句,
        this.usedSize--;
    }


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

    // 清空顺序表
    public void clear() {
        /*for (int i = 0; i < this.usedSize; i++) {
            this.elem[i] = null;
        }
        //如果这是引用类型,就要这么写,要把一个个对象置为 null 空
        */
        this.usedSize = 0;// 注意有效数组长度也要清零
    }

    // 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
    
}

📖Test.java

import java.util.ArrayList;
import java.util.List;

/**
 * @Author XiaoLin
 * @Description:
 */
public class Test01_顺序表 {

    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(1);
        myArrayList.add(2);
        myArrayList.add(3);
        myArrayList.add(4);
        myArrayList.add(5);

        myArrayList.display();

        myArrayList.add(3, 15);
        myArrayList.display();

        System.out.print(myArrayList.contains(3));
        System.out.println("   下标为：" + myArrayList.indexOf(3));
        System.out.println("============================");
        System.out.println("获取 pos 位置的元素   " + myArrayList.get(3));//获取 pos 位置的元素
        System.out.println("============================");
        System.out.println("给 pos 位置的元素设为 value  [ 更新 ]");
        myArrayList.set(2, 11);
        myArrayList.display();
        System.out.println("============================");
        System.out.println("删除关键字key");
        myArrayList.remove(2);
        myArrayList.display();
        System.out.println("============================");
        System.out.println("清空顺序表");
        myArrayList.clear();
        myArrayList.display();

    }
}

 最后

本篇内容主要是对数据结构中【顺序表】内容的介绍，一方面介绍了如何模拟实现简易的顺序表，另外一方面介绍了Java集合框架中的【ArrayList】类的基本使用【ArrayList】

😎顺序表的优点

😣当然也有缺点！！！ 

所以： 怎么做到随用随分配呢？？？

 

总结：什么功能就用其最适的数据结构，写功能前先画图，把思路画出来，先完成功能再考虑优化其时间复杂度和空间复杂度！ (致：小菜狗的小林同学！！！)

小林同学7319
关注
  • 19
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Java数据结构——顺序表
Racheil的博客
05-07 551
一、线性表 线性表是数据结构中最基本、也是最简单的数据存储结构，可以理解为"线性的表"。 在线性表中数据元素之间的关系是线性的，所谓的"线性关系"，是指数据一个挨着一个，中间没有空隙，除第一个和最后一个数据元素外，每个数据元素只有一个前驱数据元素和一个后继数据元素。 数据在逻辑结构呈线性分布，称这样的存储结构为线性表 1.1 线性表特点 存储的元素数据类型相同 各个数据元素之间的相...
【Java】数据结构——顺序表的实现
qq_43464809的博客
08-18 287
线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构. 常见的线性表有：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就是连续的一条直线；但在物理结构上并不一定是连续的。 因为线性表在物理存储时，通常以数组和链式结构的形式存储。 （线性表在逻辑上连续，在物理结构上不一定连续） 顺序表 顺序表是...
Java数据结构-认识顺序表
weixin_55752048的博客
01-16 1412
目录 二.顺序表 1.概念及结构 2.顺序表的实现 打印顺序表 获取顺序表的有效长度 在pos位置新增元素 判断是否包含某个元素 查找某个元素对应的位置 获取/查找pos位置的元素 给pos位置的元素设为value 删除第一次出现的关键字key 清空顺序表 3.顺序表的优、缺点 三.顺序表的实现代码汇总 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见 的线性表：顺序表、链表、栈、队列、字符串...
《Java数据结构入门》顺序表详解
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-25 5546
带你手把手自己模拟实现Java数据结构中的顺序表，很详细的哟😁
【Java 数据结构】顺序表
程序猿教你打篮球的博客
11-01 3731
本期主要讲解： 1、什么是顺序表？ 2、模拟实现ArrayList 2.1 模拟实现前的约定 2.2构造方法 2.3 add方法 2.4 contains 方法 2.5 indexOf 方法 2.6 get 方法 2.7 set 方法 2.8 remove 方法 2.9 getSize 和 clear 方法 3、ArrayList 的学习 3.1 ArrayList的成员属性 3.2 ArrayList的构造方法 4、ArrayList的使用 4.1 ArrayList的遍历 4.2 扑克牌例子
JavaScript数据结构-2-顺序表
01-20
 //我又想到JAVA里有构造函数，我设想的js的构造函数应该跟java类似，在构造函数里初始化  //找了半天，没找到，还是慢慢找吧  //卧槽，居然让我百度到了，还是MDN靠谱啊，CSDN和博客园搜索‘构造函数’都没有...
数据结构-链表 JAVA语言实现
08-24
数据结构-链表 JAVA语言实现,包含单向链表、双向链表、循环链表的遍历、删除和插入 详细介绍：http://blog.csdn.net/z740852294/article/details/77369439
数据结构顺序表-存储学生信息(Java)
03-25
本话题将深入探讨“数据结构顺序表”在Java中的实现，特别是如何利用顺序表来存储学生信息。顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储，就像数组一样。下面我们将详细讲解这个过程。 首先，`...
数据结构线性表-顺序表（c++、java）.pdf
11-12
顺序表是一种基本的数据结构，它在线性表的基础上采用了顺序存储的方式。在线性表中，元素之间存在一对一的逻辑关系，而顺序表则是将这些逻辑上相邻的元素在内存中也保持相邻，通常通过数组实现。顺序表有静态分配和...
Java数据结构篇-链表与数组实现栈.pptx.pptx
12-19
Java数据结构是编程中至关重要的组成部分，它们定义了如何有效地存储和操作数据。在这个话题中，我们将重点关注两种常见的数据结构——链表和数组，并探讨它们如何被用来实现栈这一特定的抽象数据类型。 栈是一种...
Elsaticsearch java基本操作
最新发布
qq_62383709的博客
07-13 334
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
配置Java开发环境
Broken_x的博客
07-10 1470
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 373
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 435
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1434
在 Java 中，可以通过多种方法将一个Object转换为Integer。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2372
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java占位符替换五种方式
weixin_61478518的博客
07-08 566
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
elk部署springboot
Chihirozy的博客
07-11 273
elk部署springboot。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 3325
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
最新数据结构(Jva版)-线性表的实现与应用完整版.pdf
06-11
。。。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小林同学7319

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值