数组的定义应用，内存结构
数组：可以存储多个相同数据类型元素的容器
定义数组的格式（可以分成声明和初始化两个过程）
1.数据类型[ ] 数组名=new 数据类型 [ 数组元素的个数/数组的长度 ]
例：
int[] arr=new int[2]; //定义了一个长度为2的整型数组arr
2..数据类型[ ] 数组名=new 数据类型 [ ] {元素值1，元素值2} ————–给定元素值，长度就确定了
例：
int[] arr=new int[]{1，2，… }; //声明变量： int[] arr； -----------------存储的是堆的地址 //初始化 arr=new int[]{1，2，… }；
3.数据类型[ ] 数组名={1，2，3} —-------------------常用写法
[ I @ 2a139a55
System.out.println(arr);
[ :对象类型,代表对象是数组
I :这块区域，代表对象的元素类型
@ :代表后面是地址值
2a139a55 :哈希码值的十六进制表现形式
[I@2a139a55 ：表明数据的地址池
java会默认对数组里的元素进行编号，这个编号从0开始，通过地址值和编号（下标）共同确定唯一的元素
new：用于在内存中开辟空间
内存
计算机内存：CPU处理的速度很快，硬盘很慢，所以开辟了内存空间，CPU从内存中获取数据
java内存分为五类：栈，堆，方法区（面向对向讲），本地方法栈（不讲），寄存器（不讲）
栈：存储变量（暂时），系统默认不赋初始值
存储的内容不再使用的时候，立即清除
堆：存储对象（new），系统默认赋初始值
存储的对象如果不在使用，就会在某个时间进行回收
时间复杂度：核心代码的次数
二分查找：n/2^x=1 2^x=n x=log2n —– O(log2n)
冒泡排序：n（n-1）------n2 ———-O(n2)
Arrays.sort()———— O(nlogn)
空间复杂度：程序执行中额外开辟的内存
二分查找：O(1) —– 常数为1
冒泡排序：O(1)
选择排序：O(1)
系统默认初始值
堆里的空间系统默认初始值
byte ，short， int-------0
char-------------------’\u0000‘ \u：以u16进行编码
long---------------------0L
float----------------------0.0F
double-------------------0.0
boolean——————false
引用变量-----------------------null
public class Test { public static void main(String[] args) { int[] arr1; //声明变量，存储在栈中 arr1=new int[2]; //进行初始化，存储在堆中 int[] arr2 = arr1; //将arr1的堆地址，赋值给arr2，共享堆中的存储空间 } }
数组的应用（遍历，最值，逆序，查找，排序，扩容）
1.遍历（依次输出数组元素）
/* * 数组遍历 * */ //方法一 public class Test { public static void main(String[] args) { int[] arr ={1,5,6,9,7}; //操作循环 //arr.length---数组的长度 for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); } } } //方法二 public class Test { public static void main(String[] args) { int[] arr ={1,5,6,9,7}; //增强for循环,只能做遍历，不能做增删操作 //数组元素类型 变量名：要进行遍历的数组名 for(int i:arr){ //将数组堆中的值依次拷贝到变量i中,对堆中的值没有影响 System.err.println(i); }
}
/* * 数组转成字符串输出 * */ public class Test { public static void main(String[] args) { int[] arr ={1,5,6,9,7}; System.out.println(Arrays.toString(arr)); } }
2.最值
/* * 数组的最值 * */ public class Test { public static void main(String[] args) { //定义数组 int[] arr ={1,5,6,9,7}; //参照物 int max=arr[0]; //操作循环 for(int i=1;i<arr.length;i++){ //进行比较 if(max<arr[i]){ max=arr[i]; } } System.out.println(max); } }
3.逆序------[1,2,3,4]—>[4,3,2,1]
/* *数组逆序 * */ //方法一 public class Test { public static void main(String[] args) { //原数组 int[] arr ={1,5,6,9,7}; //新数组 int[] arr2=new int[arr.length]; for(int i=0;i<arr.length;i++){ arr2[i]=arr[arr.length-i-1]; } //改变arr的堆地址空间 arr=arr2; //转成字符串输出 System.out.println(Arrays.toString(arr2)); } } //方法二 import java.util.Arrays; /* *数组逆序 * */ public class Test { public static void main(String[] args) { //数组 int[] arr ={1,5,6,9,7}; for(int i=0;i<arr.length/2;i++){ //两个整数交换 int temp; temp = arr[i]; arr[i]=arr[arr.length-1-i]; arr[arr.length-i-1]=temp; } System.out.println(Arrays.toString(arr)); } }
4.查找（普通，二分（折半）：数组要有序）-------------给定一个目标值，找出与数组中对应值的相应下标
/* *数组二分查找（折半查找） * */ public class Test { public static void main(String[] args) { //数组 int[] arr ={1,5,6,4,9,7}; int n=4; //定义变量 //最小下标 int min=0; //最大值下标 int max=arr.length-1; //中间下标 int mid=(max+min)/2; //标志位 boolean flag = true; while(arr[mid] != n){ //中间下标大于目标值 if(arr[mid]>n){ max=mid-1; } //中间下标小于目标值 if(arr[mid]<n){ min=mid+1; } //判断目标数不在范围之内 if(min>max){ flag = false; System.out.println("查无此数"); break; } //重新计算新的下标 mid=(max+min)/2; } if(flag){ System.out.println(mid); } } }
5.排序----对数组元素进行排列顺序（冒泡 选择）
/* * 冒泡排序 * */ public class Test { public static void main(String[] args) { int[] arr ={2,3,2,1,3}; //控制轮数 for(int i=1;i<arr.length-1;i++){ //参与比较元素的范围 for(int j=1;j<=arr.length-i;j++){ //两两比较 if(arr[j-1]>arr[j]){ int temp=arr[j-1]; arr[j-1]=arr[j]; arr[j]=temp; } } } System.out.println(Arrays.toString(arr)); } } /* * 选择排序 * */ public class Test { public static void main(String[] args) { int[] arr ={2,6,4,1,3}; //控制轮数 for(int i=1;i<arr.length;i++){ //控制参与比较元素的范围 for(int j=i;j<arr.length;j++){ if(arr[i-1]>arr[j]){ int temp=arr[j]; arr[j]=arr[i-1]; arr[i-1]=temp; } } } System.out.println(Arrays.toString(arr)); } } /* *排序 * */ public class Test { public static void main(String[] args) { int[] arr ={2,6,4,1,3}; Arrays.sort(arr); System.out.println(Arrays.toString(arr)); } }
6.扩容(数组定义完成之后长度不变-------数组的复制)
/* *数组的扩容（扩大） * */ public class Test { public static void main(String[] args) { //原数组 int[] arr ={2,6,4,1,3}; //新数组 int arr2[] = new int[2*arr.length]; //数组的复制 //(原数组,起始下标,新数组,开始复制的起始下标，元素个数 ) System.arraycopy(arr, 0, arr2,0, arr.length); //数组值赋值 arr = arr2; System.out.println(Arrays.toString(arr)); } } /* *数组的扩容(扩小) * */ public class Test { public static void main(String[] args) { //原数组 int[] arr ={2,6,4,1,3}; //新数组 int arr2[] = new int[arr.length/2]; //数组的复制 //(原数组,起始下标,新数组,开始复制的起始下标，元素个数 ) System.arraycopy(arr, 0, arr2,0, arr.length/2); //数组值赋值 arr = arr2; System.out.println(Arrays.toString(arr)); } } //简化版public class Test { public static void main(String[] args) { //原数组 int[] arr ={2,6,4,1,3}; arr=Arrays.copyOf(arr, 2*arr.length);//扩容 System.out.println(Arrays.toString(arr)); } }
二维数组
存储的元素，是一维数组的数组
定义格式
数据类型[][] 数组名 = new int[有几个一维数组] [ 每个一维数组的元素个数]； // 第一种
数据类型[][] 数组名 = new 数组类型[][]; // 第二种
例如：
int[][] arr = new int[2][2];
初始化
int arr = new int[2] []; //声明了两个一维数组，未开辟内存空间 arr[0]=new int[4]; arr[1]=new int[]{2,3,4}; arr[0]={1,2,3}//不可以
最常用：
3.数据类型[ ] [ ] 数组名 = {{元素值1，元素值2，…}，{元素值1，元素值2，…}，…};
4.int [ ]x,y[ ]----------int[ ] x ,int y [ ] [ ]
如果【】在数据类型后面，随着数据类型修饰的变量一起去修饰，如果【】在变量后面，就只能修饰这个变量。
二维数组地址值：
| [[ | I | @ | 2a139a55 |
|---|---|---|---|
| 二维数组 | 整型 | 后面是地址 | 地址 |
/* *数组的扩容(扩小) * */ public class Test { public static void main(String[] args) { int[][] arr = new int[2][2]; //一维数组地址值 System.out.println(arr[0]); //一维数组元素 System.out.println(arr[0][0]); } }
应用（遍历）
/* *遍历二维数组 * */ //方法一：普通for public class Test { public static void main(String[] args) { int[][] arr = {{1,2},{1,5,6},{8,7}}; //遍历二维数组 //有几个一维数组 for(int i=0;i<arr.length;i++){ //每个数组有多少个元素 for(int j=0;j<arr[i].length;j++){ System.out.println(arr[i][j]); } } } } /* *遍历二维数组 * */ //曾强for循环 public class Test { public static void main(String[] args) { int[][] arr = {{1,2},{1,5,6},{8,7}}; //遍历二维数组 //有几个一维数组 for(int[] i : arr ){ //每个数组有多少个元素 for(int j:i){ System.out.println(j); } } } }
数据类型[ ] [ ] 数组名 = new 数组类型 [ 有几个一维数组 ] [ ];
保存redis相关笔记
