java如何和硬件通信 java如何操作硬件

转载

karen 2024-06-26 08:30:41

文章标签 java如何和硬件通信 java 学习开发语言代码块 文章分类 Java 后端开发

一、基础知识

1.1、基本概念

计算机（computer），是现代一种用于高速计算的电子计算机器，可以进行数值计算，又可以进行逻辑计算，还具有存储记忆功能。

软件：即一系列按照特定顺序组织的计算机数据和指令的集合。分为系统软件和应用软件。

硬件：组成计算机的各种物理设备

按照冯.诺依曼原理，计算机硬件可分为五大部件，主要有运算器，控制器，存储器，输入设备、输出设备

内存世界:

bit binary digit/binary unit 二进制位\二进制单位

byte 字节

一个字节八个二进制位

一个字节八个比特

1.2、简述计算机编程语言

语言：是人与人之间沟通的一种方式。

计算机语言：人与计算机交流的方式。

计算机语言有很多。如：C、C++、JAVA、PHP、Python、GO等等

随机计算机语言的先后出现，我们对计算机语言划分了四代。

第一代语言

机器语言。指令以二进制代码形式存在。

第二代语言

汇编语言。使用助记符表示一条机器指令。

add 5,9,result

** 第三代语言**

高级语言

第一个阶段面向过程

举例：C、Pascal

第二个阶段面向对象

举例：C++、JAVA(跨平台的纯面向对象的语言)、Python、JavaScript、C#,GO

1.3、DOS常用命令

dir directory 查看当前文件夹下有多少文件及文件夹

. 表示当前文件夹

… 表示当前文件夹的上一层文件夹

md make directory 创建文件夹\目录

rd remove directory 移除文件夹\目录

cd change directory回到磁盘根目录 cd / 或者 cd \

回到上一级目录 cd …

del 主要删除文件

1.4、Java语言概述

Sun(Stanford University Network,斯坦福大学网络公司)公司1995年推出的一门高级编程语言,首次提出write once,run anywhere。

1.4.1、Java语言的特点

特点一：面向对象

两个基本概念：类、对象

三大特性：封装、继承、多态

特点二：健壮性

吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与释放等），提供了一个相对安全的内存管理和访问机制

特点三：跨平台性

跨平台性：通过Java语言编写的应用程序在不同的系统平台上都可以运行。

“Write once , Run Anywhere”原理：只要在需要运行 java 应用程序的操作系统上，先安装一个Java虚拟机 (JVM Java Virtual Machine) 即可。由JVM来负责Java程序在该系统中的运行。

1.4.2、Java语言简史

JDK (Java Development Kit Java开发工具箱，做Java开发必须安装的，这是最根本的一个环境)

JDK不是集成开发环境 (即IDE,integrated development environment)

1.5、Java程序运行机制

1.5.1、高级语言的运行机制

编译型语言

是指使用专门的编译器，针对特定平台（操作系统）将某种高级语言源代码一次性”翻译”成可被该平台硬件执行的机器码,并包装成该平台所能识别的可执行性程序的格式，这个转换过程称为编译（Compile）。编译生成的可执行性程序可以脱离开发环境，在特定的平台上独立运行。

解释型语言

是指使用专门的解释器对源程序逐行解释成特定平台的机器码并立即执行的语言。

解释型语言通常不会整体性的编译和链接处理，解释型语言相当于把编译型语言中的编译和解释过程混合到一起同时完成。

1.5.2、Java程序的运行机制

Java运行步骤

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LEZXTmC2-1655184670930)(file:///C:/Users/13992/AppData/Local/Temp/msohtmlclip1/01/clip_image002.jpg)]

1.5.3、Java是编译型语言还是解释型语言呢？

答:都是，或者都不是

1.5.4、 Java如何实现跨平台

1.6、进入Java世界的准备

1.6.1、JDK下载与安装

1.6.2、设置Path环境变量

1.7、第一个Java程序

1.7.1下载Notepad++

下载地址：https://appsitory.com/windows/notepad-plus-plus

1.7.2、编辑Java源代码

史上最牛程序”HelloWorld”

public class Veronica
{
    public static void main(String[] args)
    {
        System.out.println(“HelloWorld”);
    }
}

类名随意，但首字母大写，
文件名要与public 关键字修饰的类名一致

1.7.3、编译Java程序

javac *.java

1.7.4、运行Java程序

java 字节码文件名

1.7.5、初学者易范的错误

1、类名、源文件名问题
2、大小写问题
3、main方法问题

二、数据类型和运算符

2.1、变量

变量：存储数据的空间，计算机会给每一个变量分配一个内存地址
内存地址不便记忆，我们给变量取名
变量命名规则：
（1）由字母、数字、下户线_、美元符号$组成
（2）不能以数字开头，不建议使用美元符号开头
（3）小驼峰命名
（4）见名知意
（5）不能使用Java关键字命名

2.2、Java数据类型

基本数据类型（8个）
数值型
整型
byte、short、int、long
浮点型
float、double
非数值型
char(字符型)、boolean(true/false)
引用数据类型（3个）
类（String）、接口、数组

2.2.1、变量的声明、赋值、使用

数据类型变量名;
变量名 = 数据;
数据类型变量名 = 数据;

常量：值不能改变的量，使用final来修饰的量
（1）常量名字符全部大写
（2）常量名多个单词之间用下户线分隔
（3）常量一般在声明的时候就会赋值

2.2.2、Scanner的使用

（1）导包：import java.util.Scanner;
（2）创建Scanner类对象：Scanner input = new Scanner(System.in);
（3）获取数据：
获取字符串类型数据：input.next();
获取int类型数据：input.nextInt();
获取double类型数据：input.nextDouble();

2.2.3、数据类型转换

自动转换：小----->大

强制转换：大----->小

注意：强制类型转换有可能造成数据精度丢失；

2.3、运算符

2.3.1、赋值运算符

2.3.2、算数运算符

基本运算符：+ - * / % ++ –

++/—在变量前或者变量后，此变量都会自增1或者自减1

++/–在变量前，先进行自增或者自减

++/–在变量后，先进行运算，再进行自增或者自减

复合运算符

+= -= *= /= %=

2.3.3、关系运算符

== != > < >= <= 结果为bollen类型（true/false）

关系运算符的结果是布尔类型，要么为true要么为false

<、>=、<= 运算符的优先级别高于==、!=
<、>=、<=运算符只支持数值类型的数据比较

2.3.4、逻辑运算符

（1）参与逻辑运算的表达式结果要是布尔值

（2）逻辑运算符本身的结果也为布尔值，要么为true，要么为false

1、& 和&&(短路与）

相同点：运算规律一样，只有当&和&&两边全为true，才为true

不同点：

&&有短路功能，当&&左边为false，不再判断&&右边表达式的结果，直接输出&&d运算结果

&没有短路功能，不管&左边表达的结果为true还是false，都要先去判断&右边表达式的结果，然后再输出&运算结果

2、| 和||(短路或)

运算规律：只要|和||左右两边有一个为true，|和||的运算结果为true

（1）参与逻辑运算的表达式结果要是布尔值

（2）逻辑运算符本身的结果也为布尔值，要么为true，要么为false

异同点：

||有短路功能：当||左边表达式的结果为true，不再判断||右边表达式的结果，直接输出||运算结果
|没有短路功能：不管|左边表达式的结果为true还是false，都要先去判断|右边表达式的结果，然后再输出|运算结果

3、!（非）

运算符法的运算规律：

是非不分，黑白颠倒
true进行!运算得到false
false进行!运算得到true

2.3.5、条件运算符

又叫三目运算符

语法结构

条件？表达式1：表达式2

运算符的优先级

单目运算符包括! ++ --，优先级别高
优先级别最低的是赋值运算符
可以通过()控制表达式的运算顺序，()优先级最高
从右向左结合性的只有赋值运算符、三目运算符和单目运算符
算术运算符 > 关系运算符 > 逻辑运算符

三、选择和循环结构

3.1、if选择结构

3.3.1、单分支if选择结构

语法结构：

* 	if(条件){
 * 		//代码块
 * 	}

执行规律：

如果条件为true，执行{}中的代码块，执行完后，继续往下执行{}后面的代码
如果条件为false，执行{}后面的代码
注意：
条件不管多么简单还是多么复杂，都只能为布尔值

3.3.2、双分支if选择结构

if-else选择结构

语法结构：

if(条件){
		//代码块1;
	}else{
 		//代码块2;
 }

执行规律：

如果条件为true，执行代码块1，执行完之后，执行if-else结构后面的代码
如果条件为false，执行else{}里面的代码块2，执行完之后，执行if-else结构后面的代码

注意：

条件为布尔值
如果代码块1只有一条语句，代码块1所在的{}可以省略，但不建议

3.3.3、多重if选择结构

if-else-if选择结构

语法结构

if(条件1){
  			//代码块1
  		}else if(条件2){
  			//代码块2
  		}else if(条件3){
  			//代码块3
  		}....
  		
  		}else{
  			//代码块n
  		}

执行规律：

（1）先判断条件1，如果条件1为true，执行代码块1，执行完之后结束整个if-else-if结构，执行该结构后面的代码
（2）如果条件1为false，继续往下判断条件2，如果条件2为true，执行代码块2，执行完之后结束整个if-else-if结构，执行该结构后面的代码
（3）如果条件2为false，继续往下判断条件3，如果条件3为true，执行代码块3，执行完之后结束整个if-else-if结构，执行该结构后面的代码
（4）如果所有的条件都为false，执行else里面的代码块n

注意：
（1）条件为布尔值
（2）else if可以有1个、2个、多个
（3）else也可以省略，如果所有的条件不成立，也没有else，那么整个if-else-if结构不执行
（4）多重if选择结构中各个条件的顺序不可以任意排列，要求从上往下由严格到宽松。

/*
* 嵌套if选择结构：在一个if选择结构中存在另外一个if选择结构

**语法结构**
```
  	if(条件1){
  			//代码块1
  			if(条件2){
  				//代码块2
  			}else{
  				/代码块3
  		}
 	}else{
  		//代码块4
  	}
```

执行规律

判断条件1，条件1为true，执行代码块1，进一步判断条件2，条件为true，执行代码块2，条件2为false，执行代码块3，执行完之后，结束整个所有的if结构

条件1为发了，执行下面else里的代码块4

3.2、switch选择结构：

switch(表达式){
        case 常量值1:
        	//代码语句;
        	break;
        case 常量值2:
        	//代码语句;
        	break;
        case 常量值3:
        	//代码语句;
        	break;
        .........
        default:
        	//代码语句;
        	break;
  	}

执行规律：

根据表达式的值，来与case后面的常量值进行匹配

匹配上哪个常量值，就执行该case里面的代码语句，代码语句执行完，

执行break，退出整个Switch选择结构，执行Switch选择结构后面的代码

如果表达式的值与所有的case常量值不匹配，则执行default里面的代码语句，

执行完执行break语句，退出整个Switch选择结构

注意事项：

（1）表达式的值可以是int、short、byte、char、枚举类型、String（JDK7及以后版本可以使用）

（2）case常量值不能相同

（3）default语句可以在任意位置，一般来说写在最后，也可以省略不写

（4）break的作用是结束整个Switch选择结构，如果不写，会造成“case穿透”现象，此现象可以合理使用

3.3、循环结构

3.3.1、while循环

语法结构：

初始值
  	while(循环条件){
  		//循环操作;
  		//迭代部分
  	}

执行规律：
（1）执行1次初始值操作
（2）判断循环条件，如果循环条件满足，执行循环操作代码，循环操作执行完，进行迭代，迭代后再次去判断循环条件是否满足循环条件，不满足，则结束整个循环结构的执行，继续执行循环结构之后的代码
注意：
（1）初始值只执行1次
（2）循环条件为布尔值，要么为true，要么为false
（3）迭代部分的作用是改变循环条件的变量值，从而让其在某一时刻不满足循环条件，结束循环结构
如果没有迭代部分，容易出现死循环，要尽量避免使用死循环

Math.random()：获取一个[0,1)的随机数double
获取任意区间的随机数：(int)(Math.random*(num2-num1+num1)

3.3.2、do-while循环

语法结构：

初始值;
    do{
    	循环操作代码
    	迭代;
    }while(循环条件);

执行规律：
（1）执行一次初始值代码
（2）先执行一次循环操作和迭代，然后判断循环条件是否满足，如果循环条件满足，则继续执行循环操作和迭代
如果循环条件不满足，则结束整个do-while循环结构，执行do-while循环结构后面的代码

注意：
do-while循环结构，是先执行一次循环操作，再判断循环条件，也就是说do-while循环至少会执行一次循环操作

while循环结构，是先判断循环条件，再根据循环条件的结果决定是否执行循环操作，如果第一次循环条件就不能满足，循环操作就一次都不执行。

3.3.3、for循环

语法结构：

for(初始值;循环条件;迭代部分){
	//循环操作代码
}
//		for(int i = 0,j=num;i<=num&&j>=0;i++,j--)

执行规律：
（1）先执行一次初始值代码
（2）判断循环条件是否满足，如果循环条件为true，则执行循环操作代码，执行完循环操作，进行迭代，迭代完再次进行循环条件判断，根据循环条件判断结果决定是否继续执行循环操作
如果循环条件为false，则结束整个循环结构，继续往下执行循环结构后面的代码

注意：
for循环也是先判断循环条件再决定是否执行循环操作。如果循环条件第一次就不满足，循环操作一次都不会执行

3.4、多重循环

注意：

各循环可嵌套
一般不超过三层
外层循环变量变化一次，内层循环变量要变化一遍

\t的作用
\t是补全当前字符串长度为 8的整数倍，最少1倍，最多8倍
补多少要看\t前字符串长度
如果当前字符串长度3，那么 \t 后长度是8，也就是补5个空格
如果当前字符串长度10，那么 \t 后长度是16，也就是补6个空格
后面以此类推

代码举例

public static void main(String[] args) {
		for(int i = 1; i <= 9; i++){				
			for(int j = 1; j <= i; j++){
				System.out.print(j + "*" + i + "=" +(i*j) + "\t");
			}
			System.out.println();
		}
	}

java如何和硬件通信 java如何操作硬件_学习

break语句

1、作用场景
在switch选择结构中和循环结构中
2、作用
在switch选择结构中遇到break，结束整个switch选择结构，执行switch选择结构后面的代码,在循环结构中遇到break，结束循环后续所有操作，跳出整个循环结构，执行循环结构后面的代码
3、注意
（1）break语句只能作用在switch选择结构和循环结构中
（2）break语句一般结合条件语句一起使用，因为结束某个代码是需要条件

代码举例

public static void main(String[] args) {
		for(int i =1;i<=20;i++){
			//循环输出1-20，在输出完10以后，就不想在输出
			System.out.println(i);
			//在输出一个数之后，判断这个数是不是10，如果是10，就不再进行后续操作了，直接结束整个for循环
			if(i==10){
				break;
			}
		}
		System.out.println("程序执行完毕");
		}

continue语句

1、作用场景
只在循环结构中
** 2、作用**
遇到continue，结束当前循环结构，执行下一次循环
** 3、注意**
continue语句一般用于循环结构中

return语句

作用在方法中，结束方法或者返回结果

3.5、程序调试

java如何和硬件通信 java如何操作硬件_java_02

四、数组

4.1、什么是数组

4.1.1、为什么需要数组

数组是一个变量，存储相同数据类型的一组数据。

java如何和硬件通信 java如何操作硬件_学习_03

4.1.2、数组基本要素

标识符
数组元素
元素下标：：从0开始
元素类型

注意：数组长度固定不变，避免数组越界

4.2、如何使用一维数组

数组声明、分配空间（能储存多少个数据/数组长度）、赋值、使用

**1、数组声明：**数据类型数组名 [ ]；或者数据类型 [] 数组名；
int[] arr;
2、分配空间
arr = new int[5];
3、赋值

arr[0] = 10;
arr[1] = 20;
arr[2] = 45;
arr[3] = 55;
arr[4] = 75;

8大基本类型
整数类型：byte、short、int、long 数组元素默认值：0
小数：float、double数组元素默认值：0.0
非数值类型：char数组元素默认值：" "
boolen数组元素默认值：false
类（String）数组元素默认值：null (String是类类型，不是基本类型。)

合并写

String strs = new String[8];
strs[0] = “abc”;

数组声明、分配空间、赋值合并写

String[] strings = {“abc”,“qwe”,“asdf”};

4、处理数据

int[] nums = {11,22,67,89,35,61,29};		
		//使用for循环来遍历数组
		for (int i = 0; i < nums.length; i++) {
			System.out.println(nums[i]);
		}
		
		//使用增强for循环遍历数组
		/*
		 * for(数据类型 变量名:数组名或者集合名){
		 * 		//代码
		 * }	
	 	 * 执行机制：
		 * 	将数组里或者集合里的元素依次取出来之后存储到变量中，
		 * 然后可以通过操作变量达到操作数组或集合中元素的目的
		 * 
		 */
		for(int a:nums){
			System.out.println(a);
		}

数组常见错误

java如何和硬件通信 java如何操作硬件_开发语言_04

java如何和硬件通信 java如何操作硬件_java如何和硬件通信_05

java如何和硬件通信 java如何操作硬件_代码块_06

4.3、冒泡排序

冒泡排序的基本思想：对比相邻的元素值，如果满足条件就交换元素值，把较小的元素值移动到数组前面，把大的元素值移动到数组后面（即交换两个元素的位置），这样数组元素就像气泡一样从底部上升到顶部。

冒泡排序在双层循环中实现，其中外层循环控制排序轮数，总循环次数为要排序数组的长度减 1。而内层循环主要用于对比相邻元素的大小，以确定是否交换位置，对比和交换次数依排序轮数而减少。

public static void main(String[] args) {
		// 对10个整数进行按照从小到大的顺序排序 
		int[] num = {20,15,32,29,58,65,74,10,9,12};
		
		int temp = 0; 
		for (int i = 0; i < num.length; i++) {
			for (int j = 0; j < num.length -1- i; j++) {
				if(num[j] > num [j+1]){
					temp = num[j+1];
					num[j+1] = num [j];
					num[j] = temp;
				}
			}
		}
		
		System.out.println("排序后为：");
		for (int k : num) {
			System.out.print(k +" ");
		}
	}

4.4、Arrays类

使用Arrays.sort(数组名)对数组进行升序排序

public static void main(String[] args) {
		// 冒泡排序
		int[] nums1 ={11,56,34,98,62,79,88,10,22};
		
		System.out.println("排序前：");
		for (int i : nums1) {
			System.out.print(i+" ");
		}
			
		//使用Arrays.sort(数组名)对数组进行升序排序
		Arrays.sort(nums2);
		
		System.out.println("排序后：");
		for (int i : nums2) {
			System.out.print(i+" ");
		}
		System.out.println();
	}

常用Arrays类

方法名称	说明
boolean equals(array1.array2)	比较array1和array2两个数组是否相等
sort(array)	对数组array的元素进行升序排列
String toString(array)	将一个数组array转换成一个字符
void fill(array,val)	把数组array所有元素都赋值为val
copyOf(array,length)	把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致
int binarySerrch(array,val)	查询元素值val在数组array中的下标(要求数组中元素已经按升序排列)

代码示例

public static void main(String[] args) {
		
		int[] nums1 = {11,22,33,44,55};
		int[] nums2 = {11,22,33,55,44};
		
		//Arrays.equals(数组1,数组2)：比较两个数组是否相同,两个数组相同要求两个数组里的元素个数，元素内容，元素顺序都要一致
		boolean result =Arrays.equals(nums1, nums2);
		System.out.println("数组nums1和数组nums2相同："+result);
		
		//Arrays.toString(数组名)：将数组转换成字符串
		int[] nums3 = {11,42,35,68,999};
		System.out.println(nums3);//[I@7910769b 数组在内存中的地址值
		String result2 =Arrays.toString(nums3);
		System.out.println(result2);//[11, 42, 35, 68, 999]  注意：这是字符串"[11, 42, 35, 68, 999]"

		//Arrays.fill(数组名,数值)：将数组中的所有元素替换成你指定的数值
		int[] nums4 = {12,23,46,79,77,55,99};
		Arrays.fill(nums4, 88);
		for (int i = 0; i < nums4.length; i++) {
			System.out.println(nums4[i]);
		}
		
		//Arrays.copyOf(数组名,数组长度)：将数组进行复制，复制长度由你决定，当复制长度小于原来数组长度，取数组的前面几个元素，当复制长度大于原来数组长度，超过的部门赋默认值
		int[] nums5 = {11,22,33,44,55,66};
		int[] copyNums5=Arrays.copyOf(nums5, 8);
		for (int i = 0; i < copyNums5.length; i++) {
			System.out.println(copyNums5[i]);
		}
		
		//Arrays.binarySearch(数组名, 数据)：查询数组中某个数据的下标值，调用此方法之前应该先调用排序方法sort(),如果没有调用，不能保证结果的正确性,如果返回结果是负值，表示没有你要查找的数据
		int[] nums6 = {11,22,33,44,11,44,55,66,78};
		Arrays.sort(nums6);//[11,11,22,33,44,44,55,66,78]
		int index=Arrays.binarySearch(nums6, 44);
		System.out.println(index);		
	}

4.5、二维数组

4.5.1、数组声明

数据类型[ ] [ ] 数组名；或者数据类型数组名 [ ] [ ] ;

4.5.2、分配空间

数组名 = new 数据类型[长度][长度];或者数组名 = new 数据类型[长度][ ];

4.5.3、赋值

数组名[下标][下标] = 数据；

4.5.4、使用元素

数组名[下标][下标] ；

public static void main(String[] args) {
		// 声明二维数组： 数据类型[][] 数组名 ;  或者  数据类型 数组名[][];
		//声明一个int类型的二维数组nums
		int[][] nums;
		
		//分配空间： 数组名 = new 数据类型[长度][长度]; 或者 数组名 = new 数据类型[长度][];
		nums = new int[2][3];
		                    
		//赋值： 数组名[下标][下标] = 数据;
		nums[0][0] = 10;
		nums[0][1] = 20;
		nums[0][2] = 30;
		
		nums[1][0] = 100;
		nums[1][1] = 200;
		nums[1][2] = 300;
			
		//使用元素： 数组名[下标][下标];
		nums[2][3]=nums[2][3]+60;
		System.out.println(nums[2][3]);
	  //System.out.println(nums[2][5]);//ArrayIndexOutOfBoundsException
	}

4.5.5、声明二维数组

public static void main(String[] args) {
		// 声明二维数组、分配空间合并写： 数据类型[][] 数组名 = new 数据类型[数组长度][数组长度]; 或 数据类型 数组名[][] = new 数据类型[数组长度][数组长度];
		//注意：这里在分配空间的时候，第二个数组长度值可以不写
		double[][] nums = new double[2][];
		//赋值：数组名[下标][下标] = 数据;
		nums[0][0] = 12.5;
		nums[0][1] = 22.5;
		//使用元素： 数组名[下标][下标];
		nums[0][1] = 99.5;
				
		//声明数组、分配空间、赋值合并写： 数据类型[][] 数组名 = new 数据类型[][]{{数据1,数据2,...,数据n},{数据1,数据2,...,数据n},...,{数据1,数据2,...,数据n}}; 或 数据类型 数组名[][] = new 数据类型[][]{{数据1,数据2,...,数据n},{数据1,数据2,...,数据n},...,{数据1,数据2,...,数据n}};
		String[][] strs = new String[][]{{"hello"},{"java","c++"},{"html","css","js"}};
	
		//上述声明数组、分配空间、赋值可以简写成：
		//数据类型[][] 数组名 = {{数据1,数据2,...,数据n},{数据1,数据2,...,数据n},...,{数据1,数据2,...,数据n}}; 或 数据类型 数组名[][] = {{数据1,数据2,...,数据n},{数据1,数据2,...,数据n},...,{数据1,数据2,...,数据n}};
		char[][] chars = {{'a','b'},{'c','d','e'},{'f'},{'g','k'}};
	
	}

4.5.6、二维数组的遍历

public static void main(String[] args) {
		// 遍历二维数组
		int[][] nums = {{1,2,3},{4,5},{7,8,9,0},{22}}; 
		for(int i =0;i<nums.length;i++){
		//System.out.println(nums[i]); //这里输出的是这个二维数组里元素的地址（因为二维数组里的元素又是一个一维数组，所以输出的是地址值）
			for(int j = 0;j<nums[i].length;j++){
				System.out.print(nums[i][j]+" ");
			}
			System.out.println();
		}

	}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：pytorch在cuda上跑 pytorch的cuda

下一篇：java的RedissonClient 操作 hash类型 api redis在java中的用法

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯