【Java 数组解析：探索数组的奇妙世界】

数组的引入

我们先通过一段简单的代码引入数组的概念。

import java.util.Scanner;
public class TestArray01{public static void main(String[] args){//功能：键盘录入十个学生的成绩，求和，求平均数：//定义一个求和的变量：int sum = 0;Scanner sc = new Scanner(System.in);for(int i=1;i<=10;i++){//i:控制循环次数System.out.print("请录入第"+i+"个学生的成绩：");int score = sc.nextInt();sum += score;}System.out.println("十个学生的成绩之和为："+sum);System.out.println("十个学生的成绩平均数为："+sum/10);System.out.println("十个学生的成绩平均数为："+sum/(i-1));//本题的缺点：//求第6个学生的成绩：？？？？？---》不能}
}

缺点：就是不能求每个学生的成绩具体是多少

解决：将成绩进行存储  ----》 引入 ： 数组 

感受到数组的作用：数组用来存储数据的，在程序设计中，为了处理方便，数组用来将相同类型的若干数据组织起来。这个若干数据的集合我们称之为数组。

数组的定义

数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。
数组的四个基本特点：
1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2.其元素的类型必须是相同类型，不允许出现混合类型。
3.数组类型可以是任何数据类型，包括基本类型和引用类型。
4.数组有索引的：索引从0开始，到 数组.length-1 结束 
5.数组变量属于引用类型，数组也是对象。
PS:数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。

下面通过一段代码来演示数组的基本使用：

public class TestArray02{public static void main(String[] args){//数组的作用：用来存储相同类型的数据//以int类型数据为案例：数组用来存储int类型数据//1.声明(定义数组)int[] arr; //定义一个int类型的数组，名字叫arr//int arr2[];//如果数组只声明，没有后续操作，那么这个数组相当于没定义//int[] arr3 = null;//空 辨别：数组赋值为null和什么都没有赋值  不一样的效果 //2.创建arr = new int[4];//给数组开辟了一个长度为4的空间//编译期声明和创建会被合为一句话: int[] arr = new int[4];//3.赋值arr[0] = 12;arr[3] = 47;arr[2] = 98;arr[1] = 56;arr[2] = 66;/*arr[4] = 93;出现异常：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 4Array 数组Index 索引OutOf 超出Bounds 界限Exception 异常---》数组索引越界异常  *///4.使用System.out.println(arr[2]);System.out.println(arr[0]+100);//通过数组一个属性来获取  length 长度System.out.println("数组的长度是："+arr.length);}
}

数组内存空间分析：

 基于上述的简单学习，我们回头再完善最开始引入的习题，代码如下：
 

import java.util.Scanner;
public class TestArray03{public static void main(String[] args){//功能：键盘录入十个学生的成绩，求和，求平均数：//定义一个int类型的数组，长度为10 ：int[] scores = new int[10];//定义一个求和的变量：int sum = 0;Scanner sc = new Scanner(System.in);for(int i=1;i<=10;i++){//i:控制循环次数System.out.print("请录入第"+i+"个学生的成绩：");int score = sc.nextInt();scores[i-1] = score;sum += score;}System.out.println("十个学生的成绩之和为："+sum);System.out.println("十个学生的成绩平均数为："+sum/10);//求第6个学生的成绩： //System.out.println(scores[5]);/*System.out.println(scores[0]);System.out.println(scores[1]);System.out.println(scores[2]);System.out.println(scores[3]);//....System.out.println(scores[9]);*///将数组中的每个元素进行查看--》数组的遍历：//方式1：普通for循环---》正向遍历：for(int i=0;i<=9;i++){System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);}//方式2：增强for循环://对scores数组进行遍历，遍历出来每个元素都用int类型的num接收：int count = 0;for(int num:scores){count++;//每次都将num在控制台输出System.out.println("第"+count+"个学生的成绩为："+num);}/*增强for循环：优点：代码简单缺点：单纯的增强for循环不能涉及跟索引相关的操作*///方式3：利用普通for循环： 逆向遍历：for(int i=9;i>=0;i--){System.out.println("第"+(i+1)+"个学生的成绩为："+scores[i]);}}
}

用IDEA验证数组的确将数据进行存储了：

一维数组的初始化 

静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

eg:
int[] arr = {12,23,45};
int[] arr = new int[]{12,23,45};
注意：
1.new int[3]{12,23,45};-->错误
2.int[] arr ;
   arr = {12,23,45};  --->错误

动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

eg:
int[] arr ;              --->可以合并为：int[] arr = new int[3];
arr = new int[3]
arr[0] = 12;
arr[1] = 23;
arr[2] = 45;


int[] arr;
arr = new int[]{12, 23, 45};

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

int[] arr = new int[3];   ---> 数组有默认的初始化值

数组的基本操作 

最值问题

【1】实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45}; ，求出数组中最大的数。
思路图：

public class TestArray04{public static void main(String[] args){//实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45}; ，求出数组中最大的数。//1.给定一个数组int[] arr = {12,3,7,4,8,125,9,45,666,36};//2.求出数组中的最大值：//先找一个数上擂台，假定认为这个数最大：int maxNum = arr[0];for(int i=0;i<arr.length;i++){if(arr[i]>maxNum){maxNum = arr[i];}}System.out.println("当前数组中最大的数为："+maxNum);}
}

【2】将求最大值的方法提取出来：

ublic class TestArray04{public static void main(String[] args){//实现一个功能：给定一个数组int[] arr = {12,3,7,4,8,125,9,45}; ，求出数组中最大的数。//1.给定一个数组int[] arr = {12,3,7,4,8,725,9,45,666,36};//2.求出数组中的最大值：//调用方法：int num = getMaxNum(arr);System.out.println("当前数组中最大的数为："+num);}/*想提取一个方法：求数组中的最大值求哪个数组中的最大值 ---》不确定因素：哪个数组 (形参)---》返回值：最大值*/public static int getMaxNum(int[] arr){//先找一个数上擂台，假定认为这个数最大：int maxNum = arr[0];for(int i=0;i<arr.length;i++){if(arr[i]>maxNum){maxNum = arr[i];}}return maxNum;}
}

【3】画内存： 

方法的实参传递给形参的时候一定要注意：一切都是值传递
如果是基本数据类型，那么传递的就是字面值
如果是引用数据类型，那么传递的就是地址值

查询问题

【1】查询指定位置的元素

public class TestArray05{public static void main(String[] args){//查询指定位置的元素//给定一个数组：int[] arr = {12,34,56,7,3,10};//查找索引为2的位置上对应的元素是什么？System.out.println(arr[2]);}
}

上面代码体现了数组的一个优点：
在按照位置查询的时候，直接一步到位，效率非常高 

【2】查询指定元素的位置--》找出元素对应的索引  

public class TestArray06{public static void main(String[] args){//查询指定元素的位置--》找出元素对应的索引 //给定一个数组：int[] arr = {12,34,56,7,3,56};//           0  1  2  3 4  5//功能：查询元素888对应的索引：int index = -1; //这个初始值只要不是数组的索引即可for(int i=0;i<arr.length;i++){if(arr[i]==12){index = i;//只要找到了元素，那么index就变成为ibreak;//只要找到这个元素，循环就停止}}if(index!=-1){System.out.println("元素对应的索引："+index);}else{//index==-1System.out.println("查无此数！");}}
}

【3】将查指定元素对应的索引的功能提取为方法：

public class TestArray06{public static void main(String[] args){//查询指定元素的位置--》找出元素对应的索引 //给定一个数组：int[] arr = {12,34,56,7,3,56};//           0  1  2  3 4  5//功能：查询元素888对应的索引：//调用方法：int index = getIndex(arr,999);//后续对index的值进行判断：if(index!=-1){System.out.println("元素对应的索引："+index);}else{//index==-1System.out.println("查无此数！");}}/*定义一个方法：查询数组中指定的元素对应的索引：不确定因素：哪个数组，哪个指定元素  （形参）返回值：索引*/public static int getIndex(int[] arr,int ele){int index = -1; //这个初始值只要不是数组的索引即可for(int i=0;i<arr.length;i++){if(arr[i]==ele){index = i;//只要找到了元素，那么index就变成为ibreak;//只要找到这个元素，循环就停止}}return index;}
}

添加元素

【1】实现一个功能：
添加逻辑：

public class TestArray07{public static void main(String[] args){//功能：给定一个数组,在数组下标为2的位置上添加一个元素91//1.给定一个数组：int[] arr = {12,34,56,7,3,10,55,66,77,88,999,89};//           0  1   2 3 4 5//2.输出增加元素前的数组：System.out.print("增加元素前的数组：");for(int i=0;i<arr.length;i++){if(i!=arr.length-1){System.out.print(arr[i]+",");}else{//i==arr.length-1 最后一个元素不用加,System.out.print(arr[i]);}}//3.增加元素/*arr[5] = arr[4];arr[4] = arr[3];arr[3] = arr[2];*/int index = 1;//在这个指定位置添加 元素for(int i=arr.length-1;i>=(index+1);i--){arr[i] = arr[i-1];}arr[index] = 666;//4.输出增加元素后的数组：System.out.print("\n增加元素后的数组：");for(int i=0;i<arr.length;i++){if(i!=arr.length-1){System.out.print(arr[i]+",");}else{//i==arr.length-1 最后一个元素不用加,System.out.print(arr[i]);}}}	
}

【2】将添加功能提取为一个 方法：

import java.util.Scanner;
public class TestArray07{public static void main(String[] args){//功能：给定一个数组,在数组下标为2的位置上添加一个元素91//1.给定一个数组：int[] arr = {12,34,56,7,3,10,55,66,77,88,999,89};//           0  1   2 3 4 5//2.输出增加元素前的数组：/*System.out.print("增加元素前的数组：");for(int i=0;i<arr.length;i++){if(i!=arr.length-1){System.out.print(arr[i]+",");}else{//i==arr.length-1 最后一个元素不用加,System.out.print(arr[i]);}}*///从键盘接收数据：Scanner sc = new Scanner(System.in);System.out.println("请录入你要添加元素的指定下标：");int index = sc.nextInt();System.out.println("请录入你要添加的元素：");int ele = sc.nextInt();//3.增加元素//调用方法：insertEle(arr,index,ele);//4.输出增加元素后的数组：System.out.print("\n增加元素后的数组：");for(int i=0;i<arr.length;i++){if(i!=arr.length-1){System.out.print(arr[i]+",");}else{//i==arr.length-1 最后一个元素不用加,System.out.print(arr[i]);}}}	/*提取一个添加元素的方法：在数组的指定位置上添加一个指定的元素。在哪个数组的哪个位置添加哪个元素！不确定因素：形参：哪个数组，哪个位置，哪个元素返回值：无*/public static void insertEle(int[] arr,int index,int ele){for(int i=arr.length-1;i>=(index+1);i--){arr[i] = arr[i-1];}arr[index] = ele;}
}

删除元素

【1】实现一个功能：删除指定位置上的元素

删除逻辑：

import java.util.Arrays;
public class TestArray08{public static void main(String[] args){//功能：给定一个数组,删除下标为2元素//1.给定一个数组：int[] arr = {12,34,56,7,3,10,34,45,56,7,666};//           0  1   2 3 4 5//2.输出删除前的数组：System.out.println("删除元素前的数组："+Arrays.toString(arr));//3.删除/*arr[2] = arr[3];arr[3] = arr[4];arr[4] = arr[5];*/int index = 0;for(int i=index;i<=arr.length-2;i++){arr[i] = arr[i+1];}arr[arr.length-1] = 0;//4.输出删除后的数组：System.out.println("删除元素后的数组："+Arrays.toString(arr));}
}

【2】实现一个功能：删除指定元素

import java.util.Arrays;
import java.util.Scanner;
public class TestArray09{public static void main(String[] args){//功能：给定一个数组,删除元素3：//1.给定一个数组：int[] arr = {12,34,56,7,3,10,34,45,56,7,666};//2.输出删除前的数组：System.out.println("删除元素前的数组："+Arrays.toString(arr));Scanner sc = new Scanner(System.in);int num = sc.nextInt();//num为删除元素值//找到要删除的元素对应的索引即可：int index = -1 ;for(int i=0;i<arr.length;i++){if(arr[i]==num){index = i;break;}}//3.删除if(index!=-1){for(int i=index;i<=arr.length-2;i++){arr[i] = arr[i+1];}arr[arr.length-1] = 0;}else{//index==-1System.out.println("根本没有你要删除的元素！");}//4.输出删除后的数组：System.out.print("删除元素后的数组："+Arrays.toString(arr));}
}

详解main方法 

刚学完数组的基本知识，现在我们来解释下main方法中参数里面的数组是什么含义

【1】main方法：程序的入口，在同一个类中，如果有多个方法，那么虚拟机就会识别main方法，从这个方法作为程序的入口
【2】main方法格式严格要求：
public static void main(String[] args){}

public static --->修饰符 ，暂时用这个 -->在Java面向对象章节里面详细讲过修饰符，需要的可以去查看
void --->代表方法没有返回值 对应的类型void
main --->见名知意名字
String[] args  --->形参  ---》不确定因素

【3】问题：程序中是否可以有其他的方法也叫main方法？
可以，构成了方法的重载。

public class TestArray10{public static void main(String[] args){}public static void main(String str){}
}

【4】形参为String[] 那么实参到底是什么？
 

public class TestArray10{public static void main(String[] args){//从侧面验证：//int[] arr1; //如果对数组只声明，没有后续操作，那么相当于 白定义了。//int[] arr2 = null; //System.out.println(arr2.length);//Exception in thread "main" java.lang.NullPointerException//int[] arr3 = new int[0];//System.out.println(arr3.length);//int[] arr4 = new int[4];//System.out.println(arr4.length);//System.out.println(args.length);//0//从这个结果证明，参数是String[],实参是  new String[0] //默认情况下，虚拟机在调用main方法的时候就是传入了一个长度为0的字符数组System.out.println(args.length);for(String str:args){System.out.println(str);}}
}

手动传入实参：
有特殊符号的时候可以加上“”

没有特殊符号用空格隔开即可：

可变参数 

1.可变参数：作用提供了一个方法，参数的个数是可变的,解决了部分方法的重载问题
int...num
double...num
boolean...num
2.可变参数在JDK1.5之后加入的新特性
3.方法的内部对可变参数的处理跟数组是一样
4.可变参数和其他数据一起作为形参的时候，可变参数一定要放在最后
5.我们自己在写代码的时候，建议不要使用可变参数

public class TestArray12{public static void main(String[] args){//method01(10);//method01();//method01(20,30,40);method01(30,40,50,60,70);//method01(new int[]{11,22,33,44});}public static void method01(int num2,int...num){System.out.println("-----1");for(int i:num){System.out.print(i+"\t");}System.out.println();System.out.println(num2);}
}

Arrays工具类的简单使用

为了方便我们对数组进行操作，系统提供一个类Arrays，我们将它当做工具类来使用。

import java.util.Arrays;
public class TestArray13{public static void main(String[] args){//给定一个数组：int[] arr = {1,3,7,2,4,8};//toString:对数组进行遍历查看的，返回的是一个字符串，这个字符串比较好看System.out.println(Arrays.toString(arr));//binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：//这个方法的使用前提：一定要查看的是一个有序的数组：//sort：排序 -->升序Arrays.sort(arr);System.out.println(Arrays.toString(arr));System.out.println(Arrays.binarySearch(arr,4));int[] arr2 = {1,3,7,2,4,8};//copyOf:完成数组的复制：int[] newArr = Arrays.copyOf(arr2,4);System.out.println(Arrays.toString(newArr));//copyOfRange:区间复制：int[] newArr2 = Arrays.copyOfRange(arr2,1,4);//[1,4)-->1,2,3位置System.out.println(Arrays.toString(newArr2));//equals:比较两个数组的值是否一样：int[] arr3 = {1,3,7,2,4,8};int[] arr4 = {1,3,7,2,4,8};System.out.println(Arrays.equals(arr3,arr4));//trueSystem.out.println(arr3==arr4);//false ==比较左右两侧的值是否相等，比较的是左右的地址值，返回结果一定是false//fill：数组的填充：int[] arr5 = {1,3,7,2,4,8};Arrays.fill(arr5,10);System.out.println(Arrays.toString(arr5));}
}

数组的复制操作

原理：

import java.util.Arrays;
public class TestArray14{public static void main(String[] args){//给一个源数组：int[] srcArr = {11,22,33,44,55,66,77,88};//给一个目标数组：int[] destArr = new int[10];//复制：System.arraycopy(srcArr,1,destArr,3,3);//遍历查看目标数组：System.out.println(Arrays.toString(destArr));}}

二维数组的引入

直接用一张图就可以理解什么是二维数组了。

 

public class TestArray15{public static void main(String[] args){//定义一个二维数组：int[][] arr = new int[3][];//本质上定义了一个一维数组，长度为3int[] a1 = {1,2,3};arr[0] = a1;arr[1] = new int[]{4,5,6,7};arr[2] = new int[]{9,10};}
}

对应内存：

二维数组的初始化方式

静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

eg:
int[][] arr = {{1,2},{4,5,6},{4,5,6,7,8,9,9}};
int[][] arr =new int[][] {{1,2},{4,5,6},{4,5,6,7,8,9,9}};

动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。
eg:
int[][] arr = new int[3][]; //本质上定义了一维数组长度为3，每个“格子”中放入的是一个数组
arr[0] = {1,2};
arr[1] = {3,4,5,6};
arr[2] = {34,45,56};

eg:
int[][] arr = new int[3][2]; 

public class TestArray16{public static void main(String[] args){int[][] arr = new int[3][2];//本质上：定义一维数组，长度为3，每个数组“格子”中，有一个默认的长度为2的数组：arr[1] = new int[]{1,2,3,4};//数组遍历：for(int[] a:arr){for(int num:a){System.out.print(num+"\t");}System.out.println();}}
}

 

默认初始化

数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。默认初始值参考一维数组的默认初始化一样的。

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

电机（一）：直流有刷电机和舵机

电机（一）：直流有刷电机和舵机

声明&#xff1a;以下图片来自于正点原子&#xff0c;仅做学习笔记使用 电机专题&#xff1a; 直流电机&#xff1a;直流有刷BDC&#xff08;内含电刷&#xff09;&#xff0c;直流无刷BLDC&#xff08;大疆的M3508和M2006&#xff09;,无刷电机有以下三种形式&#xff1a;&a…
阅读更多...
软件测试卷王在2024年初开卷。。。

软件测试卷王在2024年初开卷。。。

前言 转眼就到了2024年了&#xff0c;工作这几年我的薪资也从12k涨到了18k&#xff0c;对于工作只有3年多的我来说&#xff0c;还是比较满意的&#xff0c;毕竟一些工作4、5年的可能还没我高。 我可能就是大家说的卷王&#xff0c;感觉自己年轻&#xff0c;所以从早干到晚&am…
阅读更多...
常用的 MySQL 可视化客户端

常用的 MySQL 可视化客户端

数据库可视化客户端&#xff08;GUI&#xff09;让用户在和数据库进行交互时&#xff0c;能直观地查看、创建和修改对象&#xff0c;如&#xff1a;表、行和列。让数据库操作变得更方便了。 今天&#xff0c;我们来了解下目前市场上最常用的 MySQL 可视化客户端。 官方&#x…
阅读更多...
uni-appcss语法

uni-appcss语法

锋哥原创的uni-app视频教程&#xff1a; 2023版uniapp从入门到上天视频教程(Java后端无废话版)&#xff0c;火爆更新中..._哔哩哔哩_bilibili2023版uniapp从入门到上天视频教程(Java后端无废话版)&#xff0c;火爆更新中...共计23条视频&#xff0c;包括&#xff1a;第1讲 uni…
阅读更多...
回顾2023在CSDN的足迹与2024展望

回顾2023在CSDN的足迹与2024展望

目录 一、关于博主 二、2023的历程 1、博客分类 2、年度创作数据 3、解锁勋章 4、主要的方向 二、技术感悟 1、技术深入 2、还是实践 三、展望2024 今天是2024年的第一天&#xff0c;告别2023年&#xff0c;让我们以全新的姿态&#xff0c;去迎接新的一年的挑战。2023年…
阅读更多...
主域控活动目录配置工作任务

主域控活动目录配置工作任务

题目 配置Windows防火墙&#xff0c;仅允许配置的服务通过防火墙&#xff1b;禁止ICMP回显请求。在DCserver上配置如下服务与设置&#xff1a;为ChinaSkills.cn安装和配置活动目录域服务&#xff1b;只有域管理员和IT部门员工可以登陆服务器。创建如下全局AD组与用户&#xff…
阅读更多...
Qt重载事件

Qt重载事件

重载event 事件类型 (EventType) 事件类型是 QEvent 类的一个枚举 &#xff0c;包含了 Qt 能够处理的所有不同类型的事件。这个枚举包括但不限于以下常见类型&#xff1a; QEvent::MouseButtonPress: 鼠标按钮按下事件。QEvent::MouseButtonRelease: 鼠标按钮释放事件。Q…
阅读更多...
不同语言告别2023，迎接2024

不同语言告别2023，迎接2024

一、序言 1.一名合格的程序员&#xff0c;始于Hello World&#xff0c;终于Hello World&#xff0c;用不同语言表达2023最后一天。 2.在这一年里&#xff0c;博主新接触了VUE、Python、人工智能、JAVA的框架SprinBoot、微服务等&#xff0c;然后一路来感谢大家的支持&#xf…
阅读更多...
【深度解析C++之运算符重载】

【深度解析C++之运算符重载】

系列文章目录 &#x1f308;座右铭&#x1f308;&#xff1a;人的一生这么长、你凭什么用短短的几年去衡量自己的一生&#xff01; &#x1f495;个人主页:清灵白羽 漾情天殇_计算机底层原理,深度解析C,自顶向下看Java-CSDN博客 ❤️相关文章❤️&#xff1a;【深度解析C之this…
阅读更多...
2023年“中银杯”四川省职业院校技能大赛“云计算应用”赛项样题卷①

2023年“中银杯”四川省职业院校技能大赛“云计算应用”赛项样题卷①

2023年“中银杯”四川省职业院校技能大赛“云计算应用”赛项&#xff08;高职组&#xff09; 样题&#xff08;第1套&#xff09; 目录 2023年“中银杯”四川省职业院校技能大赛“云计算应用”赛项&#xff08;高职组&#xff09; 样题&#xff08;第1套&#xff09; 模块一…
阅读更多...
【IP-Adapter】进阶 - 同款人物【2】 ☑

【IP-Adapter】进阶 - 同款人物【2】 ☑

测试模型&#xff1a;###最爱的模型\flat2DAnimerge_v30_2.safetensors [b2c93e7a89] 原图&#xff1a; 加入 control1 [IP-Adapter] 加入 control 2 [OpenPose] 通过openpose骨骼图修改人物动作。 加入 control 3 lineart 加入cotrol3 …
阅读更多...
在 Spring 中操作 Redis

在 Spring 中操作 Redis

&#x1f9f8;欢迎来到dream_ready的博客&#xff0c;&#x1f4dc;相信您对博主首页也很感兴趣o (ˉ▽ˉ&#xff1b;) &#x1f4dc;redis和缓存及相关问题和解决办法 什么是缓存预热、缓存穿透、缓存雪崩、缓存击穿 目录 1、引入依赖 2、对 Redis 的配置文件进行书写 3、S…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023