【数据结构与算法】ArrayList与顺序表

news2025/7/5 2:46:07

请添加图片描述

✨个人主页：bit me
✨当前专栏：数据结构
✨每日一语：上海就是商海，北京就是背景，誓言就是失言，彩礼就是财力，理想就是离乡，而平民就要拼命
在这里插入图片描述

ArrayList与顺序表

  • 💦一.线性表
  • 💞二.顺序表
    • 💕2.1 接口的实现
  • ⚡️三. ArrayList简介
  • 🎶四. ArrayList使用
    • 🎵4.1 ArrayList的构造
    • 🎵4.2 ArrayList常见操作
    • 🎵4.3 ArrayList的遍历
    • 🎵4.4 ArrayList的扩容机制（源码实现）
  • 💤五. 顺序表的一般用途及优缺点：

 

💦一.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、串…

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

顺序表：
在这里插入图片描述

链表：
在这里插入图片描述

 

💞二.顺序表

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

顺序表底层是一个数组，为什么不直接操作数组就好了，还需要单独写个类？

例如我们在数组中放置一部分元素
在这里插入图片描述

问在这个数组里面，有几个有效数据？

肯定有人会说3个，在Java里数组没有元素默认为0，判断的时候遇到0就停止，然后总数就是元素个数，那如果这三个元素中加了一个0呢？我们又该如何去判断呢？

这里正确的做法是用计数器，先创建一个对象，我们定义一个usedSize来记录有效的数据个数，然后添加一些方法，最后进行增删查改（CURD）。

💕2.1 接口的实现

在数组中是否可以隔着空的数组位插入元素？答案是不可以，在数据结构当中，每次储存元素的时候，一定要有一个前驱信息的，可以在两个元素中间插入

例如我们写的顺序表的相关操作：
我们还需要对他们进行完善和改进
步骤：

  1. 定义一个类：
public class MyArraylist {
    public int[] elem;
    public int usedSize;//0
    private static final int DEFAULT_SIZE = 4;//定义数组长度的

    public MyArraylist(){
        this.elem = new int[DEFAULT_SIZE];
    }
    ...
    ...
}

成员变量包含数组，数组里的元素个数，数组长度(可以使用final修饰让数据不被改变)

  1. 顺序表的打印：
 public void display() {
    //usedSize = 0
    for (int i = 0; i < this.usedSize; i++) {
        System.out.print(this.elem[i]+" ");
    }
    System.out.println();
}

用循环把每个元素都遍历一次，中间用空格分开

  1. 新增元素：
// 新增元素,默认在数组最后新增
public void add(int data) {
    //1.判断是否是满的，如果满的，那么进行扩容
    if(isFull()){
        //扩容2倍
        this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
    }
    //2.不满进行插入
    this.elem[this.usedSize] = data;
    this.usedSize++;
}

默认在数组最后新增

①需要判断数组是否是满的，满的就需要扩容，
②不满的话就进行元素插入，判断数组满不满状态的函数实现

isFull判断函数实现：

//判断当前数组是不是满的  true:满   false：空
public boolean isFull(){
    if(this.usedSize == this.elem.length){
        return true;
    }
    return false;
    //在这里可以直接优化为一行代码
    //return this.usedSize == this.elem.length;
}
  1. 在pos位置新增元素：
// 在 pos 位置新增元素
public void add(int pos, int data) {
    //1.判断pos位置合法性
    if(!checkPosInAdd(pos)){
        throw new MyArraylistIndexOutofException("添加方法的Pos不合理！");
    }

    //2.判断是否是满的，如果满的，那么进行扩容
    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++;
}

①先判断pos位置合法性，既不能是负数，又必须要有前驱信息的支持
②判断组数元素是否满了，继续调用isFull()函数
③我们插入数据的时候，需要先把插入元素后面的元素都往后挪一位，挪数据实现
从数组的最后一个元素开始往后挪，一次挪到当pos位置空出，没有元素的时候即可
④挪完数据之后，我们把pos位置赋值为data，并且把数组大小扩容一位，方便再进行新增元素

判断pos位置合法性函数checkPosInAdd实现：

private boolean checkPosInAdd(int pos){
    //1.判断pos位置合法性
    if(pos < 0 || pos > this.usedSize){
        System.out.println("pos位置不合法");
        return false;
    }
    return true;//合法
}
  1. 判定是否包含了某个元素
public boolean contains(int toFind) {
    for (int i = 0; i < this.usedSize; i++) {
        if(this.elem[i] == toFind){
            return true;
        }
    }
    return false;
}
  1. 查找某个元素对应的位置
// 查找某个元素对应的位置
public int indexOf(int toFind) {
    for (int i = 0; i < this.usedSize; i++) {
        if(this.elem[i] == toFind){
            return i;
        }
    }
    return -1;
}
  1. 获取pos下标的元素
// 获取 pos 位置的元素
public int get(int pos) {
    if(!checkPosInGet(pos)){
        throw new MyArraylistIndexOutofException("获取pos下标时，位置不合法！");
    }
    //判断是否为空(可有可无)
    if(isEmpty()){
        throw new MyArrayListEmptyException("获取元素的时候，顺序表为空！");
    }
    return this.elem[pos];
}

①先判断pos位置合法性
②判断数组是否为空（可有可无）

判断pos位置合法性函数checkPosInGet实现：

private boolean checkPosInGet(int pos){
    //1.判断pos位置合法性
    if(pos < 0 || pos >= this.usedSize){
        System.out.println("pos位置不合法");
        return false;
    }
    return true;//合法
}

判断数组是否为空isEmpty函数实现：

private boolean isEmpty(){
    return this.usedSize == 0;
}
  1. 给pos位置的元素替换成value

①先要进行合法性判断再替换

// 给 pos 位置的元素设为 value
public void set(int pos, int value) {
    if(!checkPosInGet(pos)){
        throw new MyArraylistIndexOutofException("更新pos下标的元素，位置不合法！");
    }
    //如果合法，那么其实不用判断顺序表为空的状态了
    if(isEmpty()){
        throw new MyArrayListEmptyException("顺序表为空！");
    }
    //顺序表为满的情况也可以更新
    this.elem[pos] = value;
}
  1. 删除第一次出现的关键字key
//删除第一次出现的关键字key
//判断条件：1.顺序表不为空   2.顺序表当中有我们要删除的元素  3.找到它的下标  4.把i+1的值赋给i，i还要小于usedSize-1
public void remove(int key) {
    if(isEmpty()){
        throw new MyArrayListEmptyException("顺序表为空，不能删除！");
    }
    int index = indexOf(key);
    if(index == -1){
        System.out.println("不存在你要找的数据！");
        return;
    }
    for (int i = index; i < this.usedSize-1; i++) {
        this.elem[i] = this.elem[i+1];
    }
    //删除完成
    this.usedSize--;
    this.elem[usedSize] = 0;//此处不能置为null是因为elem是int类型 如果是引用类型则置为null
}

①顺序表不为空
②顺序表当中有我们要删除的元素
③找到它的下标
④把i+1的值赋给i，i还要小于usedSize-1
（只要涉及到删除数据，如果是引用数据类型，那么就要把elem[i] = null;否则就会发生内存泄漏）

  1. 获取顺序表长度
// 获取顺序表长度
public int size() {
    return this.usedSize;
}
  1. 清空顺序表
// 清空顺序表
public void clear() {
    //因为是基本类型，所以置为0即可
    this.usedSize = 0;
    /*当它是引用类型时
    for (int i = 0; i < this.usedSize; i++) {
        this.elem[i] = null;
    }
    this.usedSize = 0;
    */
}

①基本类型置为0即可，若是引用类型则循环打印置为null，再置为0

注意：
此处可以把elem置为null可以吗？可以，但是很暴力，数组直接被回收了，顺序表只执行了一次就没了，再次使用的时候还需开辟新的数组，相当于我们每次使用的时候还需new一次，很麻烦也没必要

在这里面添加，获取pos下标不合法的时候我们也可以写我们需要的异常类来更好的实现我们需要的异常，实现异常的抛出是我们赋值命名的异常名：

public class MyArrayListEmptyException extends RuntimeException{
    public MyArrayListEmptyException(){

    }

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

public class MyArraylistIndexOutofException extends RuntimeException{
    public MyArraylistIndexOutofException(){

    }

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

在主函数里对顺序表的操作：

public static void main(String[] args) {
    MyArraylist myArraylist = new MyArraylist();
    myArraylist.add(0,1);//给0下标赋值为1
    myArraylist.add(1,2);
    myArraylist.add(2,3);
    myArraylist.add(3,4);
    myArraylist.add(4,5);
    myArraylist.display();//输出顺序表
    myArraylist.set(4,199);//把下角标为4的元素替换成199
    myArraylist.display();

    System.out.println("=============");
    myArraylist.clear();//清空顺序表
    myArraylist.display();
}

 

⚡️三. ArrayList简介

在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：
在这里插入图片描述

  1. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
  2. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
  3. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
  4. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList
  5. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

 

🎶四. ArrayList使用

🎵4.1 ArrayList的构造

在这里插入图片描述

方法一ArrayList()不带参数的构造方法的使用：

ArrayList<Integer> arrayList = new ArrayList<>();
arrayList.add(1);//往数组最后的一个位置存元素
arrayList.add(2);
arrayList.add(3);
arrayList.add(4);
System.out.println(arrayList);//用字符串的形式打印出来所有的元素
System.out.println(arrayList.size());//获取当前有效数据的个数
System.out.println(arrayList.get(1));//获取指定下标的元素

方法二的使用：

ArrayList<Integer> arrayList2 = new ArrayList<>(arrayList);
arrayList2.add(99);
arrayList2.add(199);
System.out.println(arrayList2);

arrayList2承接了arrayList1的数据（使用其他的集合 来构造当前的List，底层源码实现是数组的拷贝）

方法三的使用：

ArrayList<Integer> arrayList3 = new ArrayList<>(15);

指定初始化数组容量大小

在源码的实现里：
①：第一次add的时候，我们底层的数组才变成了10，如果只是调用了不带参数的构造方法，默认还是0
②：grow函数就是扩容函数，扩容的方式是1.5倍的扩容

例如整体的举例使用：

public static void main(String[] args) {
	// ArrayList创建，推荐写法
	// 构造一个空的列表
	List<Integer> list1 = new ArrayList<>();
	// 构造一个具有10个容量的列表
	List<Integer> list2 = new ArrayList<>(10);
	list2.add(1);
	list2.add(2);
	list2.add(3);
	// list2.add("hello"); // 编译失败，List<Integer>已经限定了，list2中只能存储整形元素
	// list3构造好之后，与list中的元素一致
	ArrayList<Integer> list3 = new ArrayList<>(list2);
	// 避免省略类型，否则：任意类型的元素都可以存放，使用时将是一场灾难
	List list4 = new ArrayList();
	list4.add("111");
	list4.add(100);
}

🎵4.2 ArrayList常见操作

方法解释
boolean add(E e)尾插 e
void add(int index, E element)将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)尾插 c 中的元素
E remove(int index)删除 index 位置元素
boolean remove(Object o)删除遇到的第一个 o
E get(int index)获取下标 index 位置元素
E set(int index, E element)将下标 index 位置元素设置为 element
void clear()清空
boolean contains(Object o)判断 o 是否在线性表中
int indexOf(Object o)返回第一个 o 所在下标
int lastIndexOf(Object o)返回最后一个 o 的下标
List< E > subList(int fromIndex, int toIndex)截取部分 list

在这里面我们不解释过多的方法，许多都是和原来的方法一样，直接套用换参数就可以

①第二个add方法：

ArrayList<Integer> arrayList = new ArrayList<>();
arrayList.add(0,1);
arrayList.add(1,2);
arrayList.add(2,99);
System.out.println(arrayList);

在这里插入图片描述

需要注意的是：在我们实现元素插入赋值的时候，不能隔着空的元素插入，否则就报错了，而且结果打印的顺序也是随机的

②第三个addAll方法：

ArrayList<Integer> arrayList2 = new ArrayList<>();
arrayList2.addAll(arrayList);
arrayList2.add(19);

System.out.println(arrayList2);

在这里插入图片描述

arrayList2把arrayList的元素都拿过来了，在最后添加一个元素19

③第四个remove方法：

arrayList.remove(0);//删除下标的元素
System.out.println(arrayList);
int index = arrayList.lastIndexOf(new Integer(99));//直接删除选定的元素
System.out.println(arrayList);

在这里插入图片描述

这里面又分为按照下标来删除和按照元素来删除，如上代码演示

④第十一个lastIndexOf方法：

int index = arrayList.lastIndexOf(new Integer(99));
System.out.println(index);

在这里插入图片描述

查找元素下标

⑤最后一个subList方法

ArrayList<Integer> arrayList = new ArrayList<>();
arrayList.add(0,1);
arrayList.add(1,2);
arrayList.add(2,99);
arrayList.add(3,199);
arrayList.add(4,299);
System.out.println(arrayList);

List<Integer> list = arrayList.subList(1,3);//区间左闭右开
System.out.println(list);

在这里插入图片描述

相当于字符串的截取，区间左闭右开
这里面我们如果把list里面的数值改变了，是否会影响原来的arraylist数组呢？

System.out.println("===================");
list.set(0,999999999);
System.out.println(list);
System.out.println("原来的list" + arrayList);

在这里插入图片描述

当我们改变list里的元素时，arraylist里的元素也被改变了
在这里也可以说明截取函数，是在本身函数上进行截取的

🎵4.3 ArrayList的遍历

ArrayList 可以使用三方方式遍历：for循环+下标、foreach、使用迭代器

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
// 使用下标+for遍历
for (int i = 0; i < list.size(); i++) {
    System.out.print(list.get(i) + " ");
}
System.out.println();
// 借助foreach遍历
for (Integer x : list) {
    System.out.print(x + " ");
}
System.out.println();
//使用迭代器
Iterator<Integer> it = list.listIterator();
while(it.hasNext()){
    System.out.print(it.next() + " ");
}
System.out.println();

🎵4.4 ArrayList的扩容机制（源码实现）

ArrayList是一个动态类型的顺序表，即：在插入元素的过程中会自动扩容：以下是ArrayList源码中扩容方式

Object[] elementData; // 存放元素的空间
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 默认空间为0
private static final int DEFAULT_CAPACITY = 10; // 默认容量大小
public boolean add(E e) {
	ensureCapacityInternal(size + 1); // Increments modCount!!
	elementData[size++] = e;
	return true;
}
private void ensureCapacityInternal(int minCapacity) {
	ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
	if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
	return Math.max(DEFAULT_CAPACITY, minCapacity);
	}
	return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
	modCount++;
	// overflow-conscious code
	if (minCapacity - elementData.length > 0)
	grow(minCapacity);
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
	// 获取旧空间大小
	int oldCapacity = elementData.length;
	// 预计按照1.5倍方式扩容
	int newCapacity = oldCapacity + (oldCapacity >> 1);
	// 如果用户需要扩容大小 超过 原空间1.5倍，按照用户所需大小扩容
	if (newCapacity - minCapacity < 0)
	newCapacity = minCapacity;
	// 如果需要扩容大小超过MAX_ARRAY_SIZE，重新计算容量大小
	if (newCapacity - MAX_ARRAY_SIZE > 0)
	newCapacity = hugeCapacity(minCapacity);
	// 调用copyOf扩容
	elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
	// 如果minCapacity小于0，抛出OutOfMemoryError异常
	if (minCapacity < 0)
	throw new OutOfMemoryError();
	return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

总结：

  1. 检测是否真正需要扩容，如果是调用grow准备扩容
  2. 预估需要库容的大小
    ①初步预估按照1.5倍大小扩容
    ②如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容
    ③真正扩容之前检测是否能扩容成功，防止太大导致扩容失败
  3. 使用copyOf进行扩容

 

💤五. 顺序表的一般用途及优缺点：

  1. 用途及优点：一般来说，顺序表使用在频繁查找数据，给定下标，可以快速查找O(1)，会使用它，如果你的数据需要频繁的进行插入或者删除，那么就不适合使用顺序表
  1. 缺点：
    ① 顺序表中间/头部的插入删除，时间复杂度为O(N)
    ②增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
    ③增容一般是呈1.5倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到150，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了45个数据空间。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

刷题笔记之十 (小易的升级之路+找出字符串中第一个只出现一次的字符+洗牌+MP3光标位置)

刷题笔记之十 (小易的升级之路+找出字符串中第一个只出现一次的字符+洗牌+MP3光标位置)

目录 1.存取任意指定序号的元素和在最后进行插入和删除运算,利用顺序表存储最节省时间 2. 数据结构中具有记忆功能的是栈 3. 递归程序的优化一般为 尾递归优化 4.二叉树遍历,前中后序遍历用到的是栈,而层序遍历用到的队列 5. 将两个各有n个元素的有序表归并成一个有序表,最…
阅读更多...
Mybatis的增删改查操作

Mybatis的增删改查操作

增删改查操作对于我们程序员来说是最基本也是最重要的操作.那么在Mybatis框架下如何对jdbc中的数据进行增删改查操作? 首先,在介绍之前,我们先来了解一下我们在进行增删改查操作过程中会遇到的各种属性和重要方法: 属性 1.namespace: 称为命名空间,用来将dao与Mapper进行绑…
阅读更多...
[Python教程]三位数倒序

[Python教程]三位数倒序

前言 最近博主也是没有什么时间来写文章&#xff0c;估计已经快两个月没写新文章了吧&#xff0c;这不&#xff0c;今天有空&#xff0c;所以想着写一篇文章。 今天的文章主要是面对Python刚刚入门的读者写的 涉及知识点 数据的基本运算字符串与数字的拼接输入与打印 相信…
阅读更多...
Python正则表达式(持续更新，各种字符串筛选，总有一款适合您当前的功能)

Python正则表达式(持续更新，各种字符串筛选，总有一款适合您当前的功能)

前言 整个文章都是以精华部分为主&#xff0c;主要分文2个部分&#xff1a; 1、python的【re】正则表达式使用方法。 2、【re】正则表达式以及对应的demo。 第一部分让你知道【re】的几个函数的区别&#xff0c;更好的匹配项目中的需求。 第二部分让你快速的匹配具体需要的正则…
阅读更多...
学习笔记-java代码审计-表达式注入

学习笔记-java代码审计-表达式注入

java代码审计-表达式注入 0x01漏洞挖掘 spel spel表达式有三种用法&#xff1a; 注解 value("#{表达式}") public String arg; 这种一般是写死在代码中的&#xff0c;不是关注的重点。 xml <bean id"Bean1" class"com.test.xxx"><prop…
阅读更多...
Jquery

Jquery

目录 一、基本介绍 二、下载地址 三、基本使用 四、jQuery对象和dom对象 五、jQuery选择器 六、jQuery的DOM操作 七、总结 相关文章 JSP的使用JSP的使用 JSON&AjaxJSON&Ajax一、基本介绍jQuery 是一个快速的&#xff0c;简洁的 javaScript 库&#xff0c;使用户能更方便…
阅读更多...
DINO学习笔记

DINO学习笔记

DINO学习笔记 DINO: DETR with Improved DeNoising Anchor Boxes for End-to-End Object Detection Abstract 我们提出了DINO(DETR with Improved deNoising anchOr boxes)&#xff0c;一种先进的端到端对象检测器。DINO采用对比的去噪训练方法、混合查询选择方法进行锚点初…
阅读更多...
【蓝桥杯专项】动态规划_背包问题合集(Java)

【蓝桥杯专项】动态规划_背包问题合集(Java)

✨哈喽&#xff0c;进来的小伙伴们&#xff0c;你们好耶&#xff01;✨ &#x1f6f0;️&#x1f6f0;️系列专栏:【蓝桥杯专项】 ✈️✈️本篇内容:动态规划_背包问题合集&#xff01; &#x1f680;&#x1f680;码云仓库gitee&#xff1a;Java数据结构代码存放! ⛵⛵作者简介…
阅读更多...
【C++笔试强训】第二十二天

【C++笔试强训】第二十二天

&#x1f387;C笔试强训 博客主页&#xff1a;一起去看日落吗分享博主的C刷题日常&#xff0c;大家一起学习博主的能力有限&#xff0c;出现错误希望大家不吝赐教分享给大家一句我很喜欢的话&#xff1a;夜色难免微凉&#xff0c;前方必有曙光 &#x1f31e;。 &#x1f4a6;&a…
阅读更多...
动态内存管理

动态内存管理

目录 内存中的栈区和堆区 malloc free calloc realloc 内存中的栈区和堆区 我们知道php的底层是C (任何语言其实都可以分为大同小异的几块) 而C语言的内存模型分为5个区&#xff1a;栈区、堆区、静态区、常量区、代码区。每个区存储的内容如下&#xff1a; 1、栈区&…
阅读更多...
网络：IP与MAC

网络：IP与MAC

如果我们要跟对方通信&#xff0c;我们需要知道对方的IP地址与MAC地址。 一、IP IP地址&#xff0c;32位&#xff0c;工作在网络层&#xff0c;属IP协议族。在互联网中逻辑的代表某一台设备&#xff0c;但是在不同的时间&#xff0c;与我合作的主机非常多。某一个设备使用完我…
阅读更多...
2022/11/12 json格式转换对象 动态sql

2022/11/12 json格式转换对象 动态sql

PostMapping public Integer save(RequestBody User user){return userMapper.insert(user); }选择json格式。以为本人忘记选了415错误&#xff0c;media错误 mybatisx插件 sprinboot yml文件导入xml mybatis: mapper-locations: classpath:mapper/*.xml 一直报错 发现重复了…
阅读更多...
【华为ICT大赛】华为云激活设备的方法以及数据上下行

【华为ICT大赛】华为云激活设备的方法以及数据上下行

先展示一下没有激活的时候在线调试的状态 然后下面我将激活他&#xff0c;让他变为下面这个样子 官方教程 这里我从0演示一个产品的创建到MQTT.fx连接到云平台并且接收数据。 进入华为云平台控制台 然后开始创建一个产品 创建完毕产品之后就可以开始创建服务了&#xff0c;一…
阅读更多...
提高工作效率的 keychron 键盘，你还没有入手吗？

提高工作效率的 keychron 键盘，你还没有入手吗？

前言 大家好&#xff0c;今天给大家推荐一款我最近入手并且一直在使用的机械键盘 keychron K4 。我自己是一个键盘的重度使用者&#xff0c;由于工作的需求&#xff0c;对键盘有很大的依赖&#xff0c;而一款可以提高工作效率的键盘&#xff0c;往往可以让我们的工作事半功倍。…
阅读更多...
文化馆建筑方案设计原理及方案

文化馆建筑方案设计原理及方案

文化馆建筑的分类与作用 根据职能不同&#xff0c;文化馆建筑可分为文化馆、群众艺术馆和文化站等形式。 文化馆是国家设立的开展社会宣传教育、普及科学文化知识、组织辅导群众文化艺术(活动)的综合性文化事业机构和场所。 群众艺术馆是国家设立的组织指导群众文化艺术活动及…
阅读更多...
Github工程中的Markdown语言应用

Github工程中的Markdown语言应用

Github工程中的Markdown语言应用1. 介绍2. 工具2.1 下载链接2.2 编辑界面2.3 插件安装3. 基本操作3.1 标题编写3.2 正文编写3.3 代码块编写3.4 加粗倾斜3.5 有序列表3.6 无序列表3.7 行内代码编写4. 参考资料最早开源代码中&#xff0c;接触的最多的就是Readme文件&#xff0c;…
阅读更多...
Altium格式PCB转换成Allegro操作指导

Altium格式PCB转换成Allegro操作指导

Altium格式PCB转换成Allegro操作指导 首先打开Altium Design的PCB文件,输出一个“PCB ASCII File（*.pcbdoc）”格式的文件。如下图 打开Allegro，选择was performance L模式，新建空白的brd。 导入Altium PCB 选择文件转换即可 转换成功 This section is describe what t…
阅读更多...
Spring更简单的实现Bean对象的存取

Spring更简单的实现Bean对象的存取

目录 一、前言&#xff1a; 二、储存Bean对象 5大类注解 Bean方法注解 三、获取Bean对象 属性注入 优缺点 Setter注入 优缺点分析 构造方法注入 优缺点分析 经典面试题 &#xff1a;属性注入 &#xff0c;构造方法注入 和 Setter 注入 之间&#xff0c;有什么区别…
阅读更多...
大数据Presto（四）：Presto自定义函数和JDBC连接

大数据Presto（四）：Presto自定义函数和JDBC连接

文章目录 Presto自定义函数和JDBC连接 一、Presto 自定义函数 1、​​​​​​​UDF函数 2、​​​​​​​UDAF函数 二、Presto JDBC连接 Presto自定义函数和JDBC连接 ​​​​​​​一、Presto 自定义函数 我们可以登录Presto客户端&#xff0c;使用命令&#xff1a;s…
阅读更多...
JavaScript 71 JavaScript JSON 71.5 JSON.parse()

JavaScript 71 JavaScript JSON 71.5 JSON.parse()

JavaScript 文章目录JavaScript71 JavaScript JSON71.5 JSON.parse()71.5.1 实例 – 解析 JSON71.5.2 来自服务器的 JSON71.5.3 作为 JSON 的数组71.5.4 例外71.5.5 浏览器支持71 JavaScript JSON 71.5 JSON.parse() JSON 的常规用途是同 web 服务器进行数据传输。 在从 web…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023