【数据结构(四)】栈（1）

文章目录

  • 1. 关于栈的一个实际应用
  • 2. 栈的介绍
  • 3. 栈的应用场景
  • 4. 栈的简单应用
    • 4.1. 思路分析
    • 4.2. 代码实现
  • 5. 栈的进阶应用(实现综合计算器)
    • 5.1. 栈实现一位数计算(中缀表达式)
      • 5.1.1. 思路分析
      • 5.1.2. 代码实现
    • 5.2. 栈实现多位数计算(中缀表达式)
      • 5.2.1. 解决思路
      • 5.2.2. 代码实现：

1. 关于栈的一个实际应用

设计一个简单的计算器：
    输入一个表达式，点击计算得出结果。
如：计算式:[7 * 2 * 2 - 5 + 1 - 5 + 3 - 3] 点击计算【如下图】

在这里插入图片描述

请问:
    计算机底层是如何运算得到结果的？ 注意不是简单的把算式列出运算, 而是计算机怎么理解这个算式的(对计算机而言，它接收到的就是一个字符串)，我们讨论的是这个问题。–> 栈

2. 栈的介绍

  • 栈(stack)是一个先入后出(FILO-First In Last Out)的有序列表。
  • 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。（允许插入和删除的）一端为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
  • 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

图解方式说明出栈(pop)和入栈(push)的概念

在这里插入图片描述

3. 栈的应用场景

  1. 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
  2. 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
  3. 表达式的转换[中缀表达式 转 后缀表达式]与求值(实际解决)。
  4. 二叉树的遍历。
  5. 图形的深度优先(depth 一 first)搜索法。

4. 栈的简单应用

问题：
    用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来储存栈的数据内容，下面我们就用数组模拟栈的出栈，入栈等操作。

4.1. 思路分析

思路分析：(使用数组来模拟栈)

在这里插入图片描述

①定义一个 top 来表示栈顶，初始化 为 -1
②入栈的操作，当有数据加入到栈时， top++; stack[top] = data;
③出栈的操作， int value = stack[top]; top--, return value

4.2. 代码实现

package stack;

import java.util.Scanner;

public class ArrayStackDemo {
    public static void main(String[] args) {
        // 创建一个ArrayStack对象-->表示栈
        ArrayStack stack = new ArrayStack(4);
        String key = "";
        boolean loop = true;// 控制是否退出菜单

        Scanner scanner = new Scanner(System.in);

        while (loop) {
            System.out.println("show: 表示显示栈");
            System.out.println("exit: 退出程序");
            System.out.println("push: 表示添加数据到栈（入栈）");
            System.out.println("pop: 表示从栈取出数据（出栈）");
            System.out.println("请输入你的选择");
            key = scanner.next();
            switch (key) {
                case "show":
                    stack.list();
                    break;
                case "push":
                    System.out.println("请输入一个数");
                    int value = scanner.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    try {
                        int res = stack.pop();
                        System.out.printf("出栈的数据是 %d\n", res);
                    } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }
}

// 定义一个ArrayStck 表示栈
class ArrayStack {
    private int maxSize;// 栈的大小
    private int[] stack;// 数组，数组模拟栈：数据放在该数组
    private int top = -1;// top表示栈顶，初始化-1

    // 构造器
    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    // 栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    // 栈空
    public boolean isEmpty() {
        return top == -1;
    }

    // 入栈(push)
    public void push(int value) {
        // 先判断栈是否满
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    // 出栈(pop),将栈顶的数据返回
    public int pop() {
        // 先判断是否为空
        if (isEmpty()) {
            // 抛出异常
            throw new RuntimeException("栈空，没有数据");
        }
        int value = stack[top];
        top--;
        return value;
    }

    // 显示栈的情况（遍历栈）:遍历时，需要从栈顶开始显示数据
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空，没有数据");
            return;
        }

        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }

}

运行结果：

在这里插入图片描述

习题拓展：
将上面的程序改成使用链表来模拟栈。

5. 栈的进阶应用(实现综合计算器)

5.1. 栈实现一位数计算(中缀表达式)

使用栈来实现综合计算器

问题：
    请输入一个表达式，通过点击“点击计算”来输出计算结果
    计算的表达式为：7 * 2 * 2 - 5 + 1 - 5 + 3 - 3

5.1.1. 思路分析

假设：
计算表达式为：3 + 2 * 6 - 2

计算思路：

1.通过一个 index 值（索引），来遍历我们的表达式

2.如果我们发现是一个数字, 就直接入数栈

在这里插入图片描述

3.如果发现扫描到是一个符号, 就分如下情况

3.1. 如果发现当前的符号栈为 空，就直接入栈

在这里插入图片描述

3.2. 如果符号栈有操作符，就进行比较
（1）如果当前的操作符的优先级小于或者等于栈中的操作符， 就需要从数栈中pop出两个数,在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈，；
（2）如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈。

因为计算表达式为：3 + 2 * 6 - 2
栈中已经存放了3和+，下一步该想数栈中存放2，直接入栈

在这里插入图片描述

接下来，扫描到符号 *
当前的操作符 * 的优先级大于栈中的操作符 + ，直接入符号栈

在这里插入图片描述

接下来，扫描到数字6，直接入数栈

在这里插入图片描述

接下来，扫描到符号 -
当前的操作符 - 的优先级小于(或等于)栈中的操作符 * ，直接入符号栈
需要从数栈中pop出两个数（6 和 2）,在从符号栈中pop出一个符号（*），进行运算，将得到结果（12），入数栈

2 * 6 = 12

在这里插入图片描述

然后将当前的操作符（ - ）入符号栈。

在这里插入图片描述

接下来，扫描到数字2，直接入数栈

在这里插入图片描述

4.当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行

①12 - 2 = 10

在这里插入图片描述

②3 + 10 =13

在这里插入图片描述

5.最后在数栈只有一个数字，就是表达式的结果（即13）

5.1.2. 代码实现

package stack;

public class Calculator {
    public static void main(String[] args) {
        // 给出一个计算表达式
        String expression = "3+2*6-2";
        // String expression = "7+2*6-4";

        // 创建两个栈：数栈 和 符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);

        // 定义相关变量
        int index = 0;// 用于扫描
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' ';// 将每次扫描得到的char保存到ch

        // 使用while循环的扫描expression
        while (true) {
            // 一次得到expression的每一个字符
            ch = expression.substring(index, index + 1).charAt(0);
            // 判断ch是什么，然后做相应的处理
            if (operStack.isOper(ch)) {// 如果是运算符
                // 判断当前的符号是否为空
                if (!operStack.isEmpty()) {
                    // 如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符， 就需要从数栈中pop出两个数
                    // 在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        // 把运算的结果入 数栈
                        numStack.push(res);
                        // 然后将当前的操作符入 符号栈
                        operStack.push(ch);
                    } else {
                        // 如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
                        operStack.push(ch);
                    }
                } else {
                    // 如果为空直接入 符号栈
                    operStack.push(ch);
                }

            } else {// 如果是数，直接入 数栈
                numStack.push(ch - 48);// ASCII码表对应数值要减去48
            }
            // 让index++，并判断是否扫描到expression最后
            index++;
            if (index >= expression.length()) {
                break;
            }

        }
        // 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行
        while (true) {
            // 如果符号栈为空，就得到了最后的计算结果，数栈中只有一个数字（即运算结果）
            if (operStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1, num2, oper);
            // 把运算的结果入 数栈
            numStack.push(res);
        }
        // 将数栈的最后的数。pop出，就是结果
        int res2 = numStack.pop();
        System.out.printf("表达式 %s = %d", expression, res2);
    }
}

// 先创建一个栈
// 定义一个ArrayStck 表示栈
class ArrayStack2 {
    private int maxSize;// 栈的大小
    private int[] stack;// 数组，数组模拟栈：数据放在该数组
    private int top = -1;// top表示栈顶，初始化-1

    // 构造器
    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    // 增加一个方法，可以返回当前栈顶的值，但不是真正的pop
    public int peek() {
        return stack[top];
    }

    // 栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    // 栈空
    public boolean isEmpty() {
        return top == -1;
    }

    // 入栈(push)
    public void push(int value) {
        // 先判断栈是否满
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    // 出栈(pop),将栈顶的数据返回
    public int pop() {
        // 先判断是否为空
        if (isEmpty()) {
            // 抛出异常
            throw new RuntimeException("栈空，没有数据");
        }
        int value = stack[top];
        top--;
        return value;
    }

    // 显示栈的情况（遍历栈）:遍历时，需要从栈顶开始显示数据
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空，没有数据");
            return;
        }

        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }

    // 返回运算符的优先级，优先级是程序员来确定的，优先级使用数字表示
    // 数字越大，优先级就越高
    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;// 假定目前的表达式只有+，-，*，/
        }
    }

    // 判断是不是一个运算符
    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

    // 计算方法
    public int cal(int num1, int num2, int oper) {
        int res = 0;// 用于存放计算结果
        switch (oper) {
            case '+':
                res = num2 + num1;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '*':
                res = num2 * num1;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }

}

运行结果：

在这里插入图片描述

注意：
上述代码在计算多位数会出现问题（比如计算：30+2*6-2，会错误的计算成10）
因为在数据读取的时候，是一个字符一个字符的读取，这样就把30拆成了 3 和 0 ，因此计算出错。

5.2. 栈实现多位数计算(中缀表达式)

5.2.1. 解决思路

1.当处理多位数时，不能发现是一个数就立即入栈，因为它可能是多位数
2.在处理数时，需要向expression的表达式的index后再看一位，如果是多位数就进行扫描，如果是符号才入栈
3.因此我们需要定义一个变量 字符串，用于拼接

5.2.2. 代码实现：

package stack;

public class Calculator {
    public static void main(String[] args) {
        // 给出一个计算表达式
        String expression = "30+2*6-2";
        // String expression = "7+2*6-4";

        // 创建两个栈：数栈 和 符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);

        // 定义相关变量
        int index = 0;// 用于扫描
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' ';// 将每次扫描得到的char保存到ch
        String keepNum = "";//用于拼接多位数

        // 使用while循环的扫描expression
        while (true) {
            // 一次得到expression的每一个字符
            ch = expression.substring(index, index + 1).charAt(0);
            // 判断ch是什么，然后做相应的处理
            if (operStack.isOper(ch)) {// 如果是运算符
                // 判断当前的符号是否为空
                if (!operStack.isEmpty()) {
                    // 如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符， 就需要从数栈中pop出两个数
                    // 在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        // 把运算的结果入 数栈
                        numStack.push(res);
                        // 然后将当前的操作符入 符号栈
                        operStack.push(ch);
                    } else {
                        // 如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
                        operStack.push(ch);
                    }
                } else {
                    // 如果为空直接入 符号栈
                    operStack.push(ch);
                }

            } else {// 如果是数，直接入 数栈
                // numStack.push(ch - 48);// ASCII码表对应数值要减去48
                //分析思路
                //1. 当处理多位数时，不能发现是一个数就立即入栈，因为它可能是多位数
                //2.在处理数时，需要向expression的表达式的index后再看一位，如果是多位数就进行扫描，如果是符号才入栈
                //3.因此我们需要定义一个变量 字符串，用于拼接

                //处理多位数
                keepNum += ch;

                //如果ch已经是expression的最后一位，就直接入栈
                if (index == expression.length() - 1) {
                    numStack.push(Integer.parseInt(keepNum));
                } else {

                    // 判断下一个字符是不是数字，如果是数字就继续扫描，如果是运算符，则入栈
                    // 注意：这里是看后一位，不是index++
                    if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                        // 如果后一位是运算符，则入栈(keepNum可能是 一位数，也可能是 多位数)
                        numStack.push(Integer.parseInt(keepNum));
                        // 注意：一定要清空keepNum
                        keepNum = "";

                    }
                }
            }
            // 让index++，并判断是否扫描到expression最后
            index++;
            if (index >= expression.length()) {
                break;
            }

        }
        // 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行
        while (true) {
            // 如果符号栈为空，就得到了最后的计算结果，数栈中只有一个数字（即运算结果）
            if (operStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1, num2, oper);
            // 把运算的结果入 数栈
            numStack.push(res);
        }
        // 将数栈的最后的数。pop出，就是结果
        int res2 = numStack.pop();
        System.out.printf("表达式 %s = %d", expression, res2);
    }
}

// 先创建一个栈
// 定义一个ArrayStck 表示栈
class ArrayStack2 {
    private int maxSize;// 栈的大小
    private int[] stack;// 数组，数组模拟栈：数据放在该数组
    private int top = -1;// top表示栈顶，初始化-1

    // 构造器
    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    // 增加一个方法，可以返回当前栈顶的值，但不是真正的pop
    public int peek() {
        return stack[top];
    }

    // 栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    // 栈空
    public boolean isEmpty() {
        return top == -1;
    }

    // 入栈(push)
    public void push(int value) {
        // 先判断栈是否满
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    // 出栈(pop),将栈顶的数据返回
    public int pop() {
        // 先判断是否为空
        if (isEmpty()) {
            // 抛出异常
            throw new RuntimeException("栈空，没有数据");
        }
        int value = stack[top];
        top--;
        return value;
    }

    // 显示栈的情况（遍历栈）:遍历时，需要从栈顶开始显示数据
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空，没有数据");
            return;
        }

        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }

    // 返回运算符的优先级，优先级是程序员来确定的，优先级使用数字表示
    // 数字越大，优先级就越高
    public int priority(int oper) {
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;// 假定目前的表达式只有+，-，*，/
        }
    }

    // 判断是不是一个运算符
    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

    // 计算方法
    public int cal(int num1, int num2, int oper) {
        int res = 0;// 用于存放计算结果
        switch (oper) {
            case '+':
                res = num2 + num1;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '*':
                res = num2 * num1;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }

}

运行结果：

在这里插入图片描述

习题拓展：

对上述代码加入功能，能够实现含小括号表达式的运算。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/172647.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

私域运营如何提高收益？

私域运营如何提高收益？

一旦建立了私域之后&#xff0c;企业需要不断地进行数据统计与分析&#xff0c;以寻找提高收益的方法。通过收集和分析用户的信息&#xff0c;了解他们的购物行为、心理需求等&#xff0c;从而制定更符合顾客口味的促销计划和产品服务。只有持续对数据进行监控&#xff0c;才能…
阅读更多...
Markdown Nice：表格

Markdown Nice：表格

第二行用来对齐&#xff1a; -表示左对齐 :-:表示居中 -:表示右对齐
阅读更多...
安防监控视频云存储平台EasyCVR页面播放卡顿的优化方法

安防监控视频云存储平台EasyCVR页面播放卡顿的优化方法

视频监控平台EasyCVR能在复杂的网络环境中&#xff0c;将分散的各类视频资源进行统一汇聚、整合、集中管理&#xff0c;在视频监控播放上&#xff0c;TSINGSEE青犀视频安防监控汇聚平台可支持1、4、9、16个画面窗口播放&#xff0c;可同时播放多路视频流&#xff0c;也能支持视…
阅读更多...
股票池(三)

股票池(三)

3-股票池 文章目录 3-股票池一. 查询股票池支持的类型二. 查询目前股票池对应的股票信息三 查询股票池内距离今天类型最少/最多的股票数据四. 查询股票的池统计信息 一. 查询股票池支持的类型 接口描述: 接口地址:/StockApi/stockPool/listPoolType 请求方式&#xff1a;GET…
阅读更多...
Jmeter监听器

Jmeter监听器

Jmeter监听器 一、监听器介绍二、监听器的类型三、监听器详解3.1 察看结果树3.2 Summary Report3.3 聚合报告3.4 后端监听器3.5 Aggregate Graph3.6 Comparison Assertion Visualizer&#xff08;比较断言可视化器&#xff09;3.7 JSR223 Listener3.8 Response Time Graph3.9 S…
阅读更多...
第三届VECCTF-2023 Web方向部分wp

第三届VECCTF-2023 Web方向部分wp

拳拳组合 题目描述&#xff1a;明喜欢保存密钥在某个文件上。请找到秘钥并读取flag文件。 开题&#xff0c;点不完的。源码提示&#xff1a; <!--据说小明很喜欢10的幂次方--> 扫一下看看&#xff0c;应该是有git泄露。 其它一些路由没什么用 git泄露拿下一堆码 pytho…
阅读更多...
API网关那些事【架构新知系列】

API网关那些事【架构新知系列】

目前随着云原生ServiceMesh和微服务架构的不断演进&#xff0c;网关领域新产品不断出现&#xff0c;各种网关使用的技术&#xff0c;功能和应用领域也不断扩展&#xff0c;在各有所长的前提下也有很多功能重合&#xff0c;网上各种技术PR文章&#xff0c;评测资料和网关落地实践…
阅读更多...
从零开始的C++（十八）

从零开始的C++（十八）

avl树中insert的模拟实现 avl树特点&#xff1a; 1.是搜索二叉树 2.每个结点的左右子树高度差的绝对值不超过2 inser模拟实现&#xff1a; // 右单旋void RotateR(Node* pParent){Node* parent pParent;Node* pr parent->_pRight;Node* prl pr->_pLeft;//记录父节点…
阅读更多...
spring boot项目未将resource目录标志为资源目录导致配置文件无效因而运行报错问题

spring boot项目未将resource目录标志为资源目录导致配置文件无效因而运行报错问题

能编译&#xff0c;但不能运行。感觉配置文件没有生效。 将程序代码发给同事&#xff0c;我自己能跑&#xff0c;他不能跑&#xff0c;提示无法构造redis对象。redis的链接写在配置文件里&#xff0c;其实是可以连接的。然后从GIT库下载代码&#xff0c;也同样不能跑。同事的操…
阅读更多...
CV计算机视觉每日开源代码Paper with code速览-2023.11.16

CV计算机视觉每日开源代码Paper with code速览-2023.11.16

点击CV计算机视觉&#xff0c;关注更多CV干货 论文已打包&#xff0c;点击进入—>下载界面 点击加入—>CV计算机视觉交流群 1.【基础网络架构】ConvNet vs Transformer, Supervised vs CLIP: Beyond ImageNet Accuracy 论文地址&#xff1a;https://arxiv.org//pdf/23…
阅读更多...
VBA技术资料MF85：将工作簿批量另存为PDF文件

VBA技术资料MF85：将工作簿批量另存为PDF文件

我给VBA的定义&#xff1a;VBA是个人小型自动化处理的有效工具。利用好了&#xff0c;可以大大提高自己的工作效率&#xff0c;而且可以提高数据的准确度。我的教程一共九套&#xff0c;分为初级、中级、高级三大部分。是对VBA的系统讲解&#xff0c;从简单的入门&#xff0c;到…
阅读更多...
基于SSM的社区生鲜商城的设计与实现

基于SSM的社区生鲜商城的设计与实现

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;采用JSP技术开发 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#x…
阅读更多...
【探索嵌入式虚拟化技术与应用】— 虚拟化技术深入浅出自学系列

【探索嵌入式虚拟化技术与应用】— 虚拟化技术深入浅出自学系列

&#x1f308;个人主页: Aileen_0v0&#x1f525;系列专栏:【探索嵌入式虚拟化技术与应用】&#x1f4ab;个人格言:"没有罗马,那就自己创造罗马~" 目录 一、虚拟技术的发展历史 1.1传统技术的局限性&#xff1a; ​编辑 1.2云计算和万物互联技术的发展机遇&#x…
阅读更多...
Altium Designer学习笔记6

Altium Designer学习笔记6

原理图库的制作&#xff0c;SMA元件的制作&#xff1a; 图形不是很重要&#xff0c;重要的是管脚的功能。 Design Item ID和Designator两个值是要注意的。 进行Place放置&#xff0c;切换到原理图工作区&#xff0c;测试下功能。 AD9851元件库制作&#xff1a; 不需要再新建原…
阅读更多...
UE4 基础篇十四：自定义插件

UE4 基础篇十四：自定义插件

文末有视频地址和git地址 一、概念 虚幻里插件都是用C++写的，C++包括.h文件和.cpp文件，.h头文件通常包含函数类型和函数声明，cpp文件包含这些类型和函数的实现， 你为项目编写的所有代码文件都必须位于模块中，模块就是硬盘里的一个文件夹，包含名为“Build.cs”的C#文件…
阅读更多...
股票指标信息(六)

股票指标信息(六)

6-指标信息 文章目录 6-指标信息一. 展示股票的K线图数据,用于数据统计二. 展示股票指标数据,使用Java处理,集合形式展示三. 展示股票目前的最新的指标数据信息四. 展示股票指标数据,某一个属性使用Java处理五. 展示股票的指标数据,用于 Echarts 页面数据统计六. 展示股票指标数…
阅读更多...
企业软件定制开发的重点是什么？|app小程序网站建设

企业软件定制开发的重点是什么？|app小程序网站建设

企业软件定制开发的重点是什么&#xff1f;|app小程序网站建设 企业软件定制开发的重点是满足企业的独特需求&#xff0c;提供高效、灵活、可靠的解决方案。随着企业信息化程度的不断提升&#xff0c;越来越多的企业开始意识到传统的软件产品无法完全满足其实际需求&#xff0c…
阅读更多...
安全领航，共筑敏捷开发新时代【云驻共创】

安全领航，共筑敏捷开发新时代【云驻共创】

安全领航&#xff0c;共筑敏捷开发新时代。网络安全形势虽然严峻&#xff0c;但得益于企业安全意识的提升&#xff0c;近两年来遭受网络攻击的网站不断减少&#xff0c;普通网民的个人隐私及其他敏感数据得到了更多的保证。华为云基于自身多年的安全经验研发了可以帮助开发者实…
阅读更多...
板块概念相关(五)

板块概念相关(五)

5-板块概念相关 文章目录 5-板块概念相关一. 查询所有的版块列表二. 查询所有的概念列表三. 查询所有的地域列表四. 查询所有的版块资金支持的类型五. 查询某个版块历史记录列表,形成图表形式六. 查询某个版块历史记录列表七. 查询某个版块今日资金,形成图表形式八. 查询该板块…
阅读更多...
Java精品项目源码基于SpringBoot的樱花短视频平台(v66)

Java精品项目源码基于SpringBoot的樱花短视频平台(v66)

Java精品项目源码基于SpringBoot的樱花短视频平台(v66) 大家好&#xff0c;小辰今天给大家介绍一个樱花短视频平台&#xff0c;演示视频公众号&#xff08;小辰哥的Java&#xff09;对号查询观看即可 文章目录 Java精品项目源码基于SpringBoot的樱花短视频平台(v66)难度指数&…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站