当前位置：首页 > news >正文

数组及其扩展

news 2026/4/23 3:16:42

数组

定义

相同类型的有序集合

声明创建

数组元素通过索引访问，从0开始

publicclassArrayDemo01{//变量类型 变量名字 = 变量的值；//数组类型publicstaticvoidmain(String[]args){//1.声明一个数组int[]nums;//首选intnums2[];//效果相同//2.创建一个数组nums=newint[10];//这里面可以存放10个int类型的数字//前两步可以合并成 int[] nums=new int[10];//3.给数组元素中赋值nums[0]=1;nums[1]=2;nums[2]=3;nums[3]=4;nums[4]=5;nums[5]=6;nums[6]=7;nums[7]=8;nums[8]=9;nums[9]=10;//如果不赋值，默认是0System.out.println(nums[0]);//1System.out.println(nums[1]);//2//System.out.println(nums[10]);//java.lang.ArrayIndexOutOfBoundsException: 10 数组下标越界//计算所有元素的和intsum=0;//获取数组长度：arrays.lengthfor(inti=0;i<nums.length;i++){sum=sum+nums[i];}System.out.println(sum);}}

内存分析

堆存放new的对象和数组；可以被所有线程共享

栈存放基本变量类型；引用对象的变量

方法区可以被所有线程共享；包含所有的class和static变量

三种初始化

静态初始化

动态初始化

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

publicclassArrayDemo02{publicstaticvoidmain(String[]args){//静态初始化:创建 + 赋值int[]a={1,2,3,4,5,6,7,8};System.out.println(a[0]);//1//动态初始化:包含默认初始化int[]b=newint[10];b[0]=10;System.out.println(b[0]);//10System.out.println(b[1]);//0System.out.println(b[2]);//0}}

数组的四个基本特点

长度确定，一旦被创建，大小不可改变
元素必须是相同类型，不能出现混合类型
数组中的元素可以是任何数据类型，包括基本类型和引用类型
数组变量属于应用类型，数组也可以被看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

数组边界

下标的合法区间：[0，length-1]，越界就会报错//ArrayIndexOutOfBoundsException：数组下标越界异常！

数组的使用

普通for循环

For-Each循环

数组作方法入参 //打印数组元素

数组作返回值 //反转数组

普通for循环

publicclassArrayDemo03{publicstaticvoidmain(String[]args){int[]arrays={1,2,3,4,5};//打印全部的数组元素for(inti=0;i<arrays.length;i++){System.out.println(arrays[i]);}System.out.println("——————————————————");//计算所有元素的和intsum=0;for(inti=0;i<arrays.length;i++){sum=sum+arrays[i];}System.out.println("sum="+sum);//sum=15System.out.println("——————————————————");//查找最大元素intmax=arrays[0];for(inti=1;i<arrays.length;i++){if(max<arrays[i]){max=arrays[i];}}System.out.println("max="+max);//max=5}}

For-Each循环

publicclassArrayDemo04{publicstaticvoidmain(String[]args){int[]arrays={1,2,3,4,5};// //JDK1.5,没有下标// for (int array : arrays) {// System.out.println(array);// }// }printArray(arrays);//1 2 3 4 5System.out.println();int[]reverse=reverse(arrays);printArray(reverse);//5 4 3 2 1}//打印数组元素publicstaticvoidprintArray(int[]arrays){for(inti=0;i<arrays.length;i++){System.out.print(arrays[i]+" ");}}//反转数组publicstaticint[]reverse(int[]arrays){int[]result=newint[arrays.length];//反转的操作for(inti=0,j=result.length-1;i<arrays.length;i++,j--){result[j]=arrays[i];}returnresult;}}

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

二维数组

inta[][]=newint[2][4];

publicclassArrayDemo05{publicstaticvoidmain(String[]args){//[2][4]/* 1,2,3,4 array[0] 5,6,7,8 array[1] */int[][]array={{1,2,3,4},{5,6,7,8}};System.out.println(array[0]);//[I@1ee0005System.out.println(array[0][0]);//1System.out.println(array[0][1]);//2printArray(array[0]);//1 2 3 4System.out.println();System.out.println(array.length);//2System.out.println(array[0].length);//4for(inti=0;i<array.length;i++){for(intj=0;j<array[i].length;j++){System.out.print(array[i][j]+" ");//1 2 3 4 5 6 7 8}}}//打印数组元素publicstaticvoidprintArray(int[]arrays){for(inti=0;i<arrays.length;i++){System.out.print(arrays[i]+" ");}}}

扩展

Arrays 类

数组的工具类java.util.Arrays

importjava.util.Arrays;importjava.util.Scanner;publicclassArrayDemo06{publicstaticvoidmain(String[]args){int[]a={1,2,3,4,34,214,4567,3};System.out.println(a);//[I@1ee0005//打印数组元素System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 34, 214, 4567, 3]printArray(a);//[1, 2, 3, 4, 34, 214, 4567, 3]Arrays.sort(a);//对数组进行排序System.out.println(Arrays.toString(a));//[1, 2, 3, 3, 4, 34, 214, 4567]Arrays.fill(a,2,6,5);//数组填充[2,6)System.out.println(Arrays.toString(a));//[1, 2, 5, 5, 5, 5, 214, 4567]}publicstaticvoidprintArray(int[]a){for(inti=0;i<a.length;i++){if(i==0){System.out.print("[");}if(i==a.length-1){System.out.println(a[i]+"]");}else{System.out.print(a[i]+", ");}}}}

冒泡排序

最出名的排序算法之一，总共有八大排序

时间复杂度O(n2)

importjava.util.Arrays;publicclassArrayDemo07{publicstaticvoidmain(String[]args){//冒泡排序//1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置//2每一次比较，都会产生一个最大或最小的数字//3.下一轮则可以少一次排序！//4.依次循环，直到结束！int[]a={1,2,2,3,4,5,65,8,24,555};int[]sort=sort(a);//调用完我们自己写的排序方法以后，返回一个排序后的数组System.out.println(Arrays.toString(sort));//[1, 2, 2, 3, 4, 5, 8, 24, 65, 555]}publicstaticint[]sort(int[]array){//临时变量inttemp=0;//外层循环:判断我们这个要走多少次for(inti=0;i<array.length-1;i++){Booleanflag=false;//通过flag标识位减少没有意义的比较//内层循环:比较判断两个数，如果第一个数比第二个数大，则交换位置//交换位置必须使用中间变量for(intj=0;j<array.length-1-i;j++){if(array[j+1]<array[j]){//<从小到大，>从大到小temp=array[j];array[j]=array[j+1];array[j+1]=temp;flag=true;}}if(flag==false){break;}}returnarray;}}

稀疏数组

是一种数据结构
当一个数组中大部分元素为0，或者为同一值的数组时，可以用稀疏数组来保存该数组

处理方式：

记录数组一共有几行几列，有多少个不同值
把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

publicclassArrayDemo08{publicstaticvoidmain(String[]args){//1.创建一个二维数组 11*11 0：没有棋子 1：黑棋 2：白棋int[][]array1=newint[11][11];array1[1][2]=1;array1[2][3]=2;//输出原始的数组System.out.println("输出原始的数组");for(int[]ints:array1){for(intanInt:ints){System.out.print(anInt+"\t");}System.out.println();}System.out.println("——————————————————————————————————————————");//转换为稀疏数组保存//获取有效值的个数intsum=0;for(inti=0;i<11;i++){for(intj=0;j<11;j++){if(array1[i][j]!=0){sum++;}}}System.out.println("有效值的个数："+sum);//2.创建一个稀疏数组的数组int[][]array2=newint[sum+1][3];array2[0][0]=11;array2[0][1]=11;array2[0][2]=sum;//遍历二维数组，将非零的值存放到稀疏数组中intcount=0;for(inti=0;i<array1.length;i++){for(intj=0;j<array1[i].length;j++){if(array1[i][j]!=0){count++;array2[count][0]=i;array2[count][1]=j;array2[count][2]=array1[i][j];}}}//输出稀疏数组System.out.println("稀疏数组");for(inti=0;i<array2.length;i++){System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");}System.out.println("——————————————————————————————————————————");System.out.println("稀疏数组还原");//1.读取稀疏数组int[][]array3=newint[array2[0][0]][array2[0][1]];//2.给其中的元素还原它的值for(inti=1;i<array2.length;i++){array3[array2[i][0]][array2[i][1]]=array2[i][2];}//3.打印System.out.println("输出还原的数组");for(int[]ints:array3){for(intanInt:ints){System.out.print(anInt+"\t");}System.out.println();}}}