Java初级学习（十）Java数组
1.数组的定义
相同数据类型的数据的有序集合
特点：
1）数组的长度是固定的，数组一旦被创建，长度不可以改变；
2）数组中的元素的数据类型可以是任何类型，包括基本类型和引用类型
3）数组变量是引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
2.数组的声明与创建
1）写法一
声明：
dataType[] arrayRefVar; //首选
dataType arrayRefVar1[]; //效果相同，但不是首选，是c，c++的风格
创建：
arrayRefVar=new dataType[10];
例子：
int[] nums; //声明数组
nums =new int[10]; //创建数组
2）写法二
声明和创建：
dataType[] arrayRefVar=new dataType[arraySize];
例子：
int[] nums = new int[10];
3）最常用，直接静态初始化
int[] array = {1,2,3,4,5,6,7,8,9,10};
1 public class Demo02 { 2 public static void main(String[] args) { 3 //变量类型 变量名=变量值 4 //int[] nums; //声明数组 5 //nums =new int[10]; //创建数组 6 int[] nums = new int[10]; //声明+创建一个包含10个数的数组 7 nums[0]=1; //数组下标从0开始，代表给数组的第一个元素赋值 8 nums[1]=2; //给数组的第二个元素赋值 9 nums[2]=3; 10 nums[3]=4; 11 nums[4]=5; 12 nums[5]=6; 13 nums[6]=7; 14 nums[7]=8; 15 nums[8]=9; 16 nums[9]=10; 17 18 int sum=0; 19 //求数组所有元素的和 20 for (int i=0;i<=nums.length;i++){ 21 sum=sum+i; 22 } 23 System.out.println(sum); 24 } 25 }
3.内存分析
Java内存
1）堆：存放new的对象和数组；可以被所有线程共享，不会存放别的对象引用
2）栈：存放基本变量类型（会包含这个基本类型的具体数值）；引用对象的变量（会存放这个引用在堆里面的具体地址）
3）方法区：可以被所有的线程共享；包含了所有的class和static变量
4.数组的三种初始化
1 public class Demo03 { 2 public static void main(String[] args) { 3 //静态初始化：创建+赋值 4 int a[]={1,2,3}; 5 System.out.println(a[0]); 6 7 //动态初始化，包含默认初始化 8 int[] b = new int[3]; 9 b[0]=1; 10 b[1]=2; 11 System.out.println(b[0]); 12 13 //默认初始化,c[0]的默认值是int的默认值0 14 int[] c = new int[3]; 15 System.out.println(c[0]); 16 } 17 }
5.数组下标越界
报错信息为：ArrayIndexOutOfBoundsException
数组下标的范围为：[0 ~ length-1]
1 int a[]={1,2,3}; 2 System.out.println(a[0]); 3 //数组下标越界 4 System.out.println(a[4]); //报错ArrayIndexOutOfBoundsException
6.数组的使用例子
1）for循环遍历数组，打印数组元素，计算和，查找最大数
1 package com.rzd.Method; 2 3 public class Demo04 { 4 public static void main(String[] args) { 5 int[] array = {1,2,3,4,5,6,7,8,9,10}; 6 7 //打印全部的数组元素，也就是遍历数组 8 for (int i=0;i<array.length;i++){ 9 System.out.print(array[i]+"\t"); 10 } 11 System.out.println(); 12 13 //增强for循环遍历数组,array表示该数组，i表示数组中的每一个元素。适合遍历，但取不到数组的下标 14 for (int i : array) { 15 System.out.print(i+"\t"); 16 } 17 System.out.println(); 18 19 //计算数组所有元素的和 20 int sum=0; 21 for (int i=0;i<array.length;i++){ 22 sum+=array[i]; //sum=sum+array[i]; 23 } 24 System.out.println(sum); 25 26 //查找数组的最大元素 27 int max=array[0]; 28 for (int i=0;i<array.length;i++){ 29 if (array[i]>max){ 30 max=array[i]; 31 } 32 } 33 System.out.println(max); 34 35 // 36 } 37 38 }
2）数组作为方法的入参，反转数组
1 public static void main(String[] args) { 2 int[] newarrays={1,2,3,4}; 3 printarray(newarrays); 4 System.out.println(); 5 //reverse(newarrays)调用reverse方法，并将newarrays作为参数传入。然后创建一个数组reverse来接收 6 int[] reverse = reverse(newarrays); 7 //调用printarray方法来打印reverse[] 8 printarray(reverse); 9 10 } 11 //打印数组元素,数组作方法入参 12 public static void printarray(int[] arrays){ 13 for (int i=0;i<arrays.length;i++){ 14 System.out.print(arrays[i]+" "); 15 } 16 } 17 18 //数组作为返回值，用于反转数组 19 /*public static int[]中的int[]表示返回值类型是数组类型 20 reverse:反转的意思 21 (int[] arrays)该方法的参数是一个数组 22 */ 23 public static int[] reverse(int[] arrays){ 24 //先定义一个数组，这个数组是要返回的数组,这个数组的长度与arrays的长度相等 25 int result[]=new int[arrays.length]; 26 27 //反转,注意这里int i=0,j=arrays.length-1;中间是逗号不是分号，i++,j--中间也是。 28 for (int i=0,j=arrays.length-1;i < arrays.length; i++,j--){ 29 result[j] = arrays[i]; 30 } 31 return result; 32 }
7.二维数组
定义二维数组：表示三行两列的数组
int a[][]=new int[3][2];
1 public class Demo05 { 2 public static void main(String[] args) { 3 int[][] array={{1,2},{3,4},{5,6}}; 4 5 //for遍历数组 6 //遍历二维数组，array[i].length表例如array[0]={1,2}，它的长度是2 7 for (int i = 0; i < array.length; i++) { 8 for (int j = 0; j < array[i].length; j++) { 9 System.out.print(array[i][j]+"\t"); 10 } 11 } 12 System.out.println(); 13 //for-each遍历数组 14 for (int[] ints : array) { 15 for (int anInt : ints) { 16 System.out.print(anInt+"\t"); 17 } 18 } 19 } 20 }
8.Arrays类
如何查找一个类的所有方法
1）先输入这个类，并导入这个类的包
2）鼠标放置在Arrays上按住Ctrl，点进去查看这个类的源码
3）点击IDE右下角的structure
4）然后可以看到这个类的所有方法
Array类有几种常用的方法
1）打印数组元素
2）数组排序
3）填充数组
1 import java.util.Arrays; 2 3 //Arrays类 4 public class Demo06 { 5 public static void main(String[] args) { 6 int a[]={1,22,3,44,555,90}; 7 8 System.out.println(a); //[I@119d7047 这里只能打印出这个数组的哈希 9 //打印数组元素 10 System.out.println(Arrays.toString(a)); 11 //用下面自己写的方法打印数组元素 12 printArray(a); 13 14 //对数组进行排序 15 Arrays.sort(a); 16 System.out.println(Arrays.toString(a)); 17 18 //给数组填充，将第2个数到第4个数的值赋为1000，这里2到4是左闭右开[2,4) 19 Arrays.fill(a,2,4,1000); 20 System.out.println(Arrays.toString(a)); 21 } 22 //自己写一个打印数组的方法,使它的效果和Array.toString()效果一样 23 public static void printArray(int[] a){ 24 for (int i = 0; i < a.length; i++) { 25 if (i==0){ 26 System.out.print("["); 27 } 28 if (i==a.length-1){ 29 System.out.println(a[i]+"]"); 30 }else { 31 System.out.print(a[i]+", "); 32 } 33 } 34 } 35 }
9.冒泡排序
两层循环，外层冒泡轮数，里层依次比较
1 import java.util.Arrays; 2 //冒泡排序 3 public class Demo08 { 4 public static void main(String[] args) { 5 int[] array={17,5,20,8,11}; 6 //输出原数组 7 System.out.println(Arrays.toString(array)); 8 9 //对数组进行冒泡排序 10 int temp=0; 11 for (int i = 0; i < array.length - 1; i++) { 12 for (int j = 0; j < array.length - 1 - i; j++) { 13 if (array[j]<array[j+1]){ 14 temp=array[j]; 15 array[j]=array[j+1]; 16 array[j+1]=temp; 17 } 18 } 19 } 20 System.out.println(); 21 for (int num : array) { 22 System.out.print(num+"\t"); 23 } 24 } 25 }
冒泡排序程序运行详解：
//在这个方法里详解冒泡排序 public void maopaopaixu(){ int[] array={17,5,20,8,11}; int temp=0; /* 1.外层控制比较的轮数，内层控制每轮比较的次数。 那么就是比较4轮（array.length - 1），i为0, 1, 2, 3。每一轮比较的次数依次为（array.length - 1 - i）： 第一轮：i=0, j<4; j可以为0, 1, 2, 3 第二轮：i=1, j<3; j可以为0, 1, 2 第二轮：i=2, j<2; j可以为0, 1 第二轮：i=3, j<1; j可以为0 2.程序运行过程 此时数组为： a[0] a[1] a[2] a[3] a[4] 17 5 20 8 11 判断a[j]是否 < a[j+1] 第一轮： 第一次比较：i=0, j=0, a[0]<a[1] 17<5 false, 无操作。 第二次比较：i=0, j=1, a[1]<a[2] 5<20 true, 交换a[1] a[2]。=====>17 20 5 8 11 第三次比较：i=0, j=2, a[2]<a[3] 5<8 true, 交换a[2] a[3]。=====>17 20 8 5 11 第四次比较：i=0, j=3, a[3]<a[4] 5<11 true, 交换a[3] a[4]。=====>17 20 8 11 5 第一轮比较结束，由于这里已经比较了a[3] a[4]，交换后a[3]一定是>a[4]的，所以下一轮就少一次比较。 此时数组为： a[0] a[1] a[2] a[3] a[4] 17 20 8 11 5 第二轮： 第一次比较：i=1, j=0, a[0]<a[1] 17<20 true, 交换a[0] a[1]。=====>20 17 8 11 5 第二次比较：i=1, j=1, a[1]<a[2] 17<8 false, 无操作。 第三次比较：i=1, j=2, a[2]<a[3] 8<11 true, 交换a[2] a[3]。=====>20 17 11 8 5 此时数组为： a[0] a[1] a[2] a[3] a[4] 20 17 11 8 5 第三轮： 第一次比较：i=2, j=0, a[0]<a[1] 20<17 false, 无操作。 第二次比较：i=2, j=1, a[1]<a[2] 17<11 false, 无操作。 此时数组为： a[0] a[1] a[2] a[3] a[4] 20 17 11 8 5 第三轮： 第一次比较：i=3, j=0, a[0]<a[1] 20<17 false, 无操作。 经过以上4轮比较，可以得到冒泡排序的结果。 */ for (int i = 0; i < array.length - 1; i++) { for (int j = 0; j < array.length - 1 - i; j++) { if (array[j]<array[j+1]){ temp=array[j]; array[j]=array[j+1]; array[j+1]=temp; /*想要交换a b 两个数，要先创建一个c。 1)将a的值赋给c，c=a 2)将b的值赋给a，a=b，此时a的值已经取到了b 3）将c=a的值赋给b，b=c=a，此时b的值已经取到了a 结束 */ } } } }
10.稀疏数组
当一个数组中大部分元素为0，或者为同一值时，可以使用稀疏数组来保存该数组。
例子
//原始数组，这是一个6行7列的数组，共有8个有效数字，其余都是0
0 0 0 22 0 0 15
0 11 0 0 0 17 0
0 0 0 -6 0 0 0
0 0 0 0 0 39 0
91 0 0 0 0 0 0
0 0 28 0 0 0 0
//稀疏数组
行 列 值
[0] 6 7 8 //第一行存放的是这个数组有6行，7列，8个有效数字
[1] 0 3 22 //第二行存放的是第一个有效数字，它的位置是0行、3列，值是22
[2] 0 6 15 //第二行存放的是第二个有效数字，它的位置是0行，6列，值是15
[3] 1 1 11 //以此类推
[4] 1 5 17
[5] 2 3 -6
[6] 3 5 39
[7] 4 0 91
[8] 5 2 28
练习：一个原始数组如下，用稀疏数组表示：
//11行11列的数组
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
//那么它的稀疏数组为
11 11 2
1 2 1
2 3 2
1 public class Demo07 { 2 public static void main(String[] args) { 3 //先构造一个原始的数组 4 int[][] array=new int[11][11]; 5 array[1][2]=1; 6 array[2][3]=2; 7 //然后用循环打印出这个二位数组 8 System.out.println("原始数组为："); 9 for (int[] ints : array) { //输入array.for 10 for (int anInt : ints) { //输入ints.for 11 System.out.print(anInt+"\t"); 12 } 13 System.out.println(); 14 } 15 //转换为稀疏数组 16 //查找有多少个有效值 17 int sum=0; 18 // for (int[] ints : array) { 19 // for (int anInt : ints) { 20 // if (anInt!=0){ 21 // sum++; 22 // } 23 // } 24 // } 25 //for循环写法 26 for (int i = 0; i < array.length; i++) { 27 for (int j = 0; j < array[i].length; j++) { 28 if (array[i][j]!=0){ 29 sum++; 30 } 31 } 32 } 33 System.out.println("数组中的有效值个数为："+sum); 34 35 //构造稀疏数组 36 int[][] array1=new int[sum+1][3]; //稀疏数组的行数为有效值的个数+1，也就是加上第一行。列固定为3 37 //稀疏数组第一行 38 array1[0][0]=11; 39 array1[0][1]=11; 40 array1[0][2]=sum; 41 42 //取有效值，构造稀疏数组第一行下面的行 43 int count=0; //表示稀疏数组的行数 44 for (int i = 0; i < array.length; i++) { 45 for (int j = 0; j < array[i].length; j++) { 46 if (array[i][j]!=0){ 47 count++; 48 array1[count][0]=i; 49 array1[count][1]=j; 50 array1[count][2]=array[i][j]; 51 } 52 } 53 } 54 //输出稀疏数组 55 System.out.println("稀疏数组为："); 56 for (int[] ints : array1) { //输入array.for 57 for (int anInt : ints) { //输入ints.for 58 System.out.print(anInt+"\t"); 59 } 60 System.out.println(); 61 } 62 63 //还原稀疏数组，也就是根据上面的稀疏数组重新构建一个原始数组 64 System.out.println("还原为原始数组："); 65 int[][] array2=new int[array1[0][0]][array1[0][1]]; 66 for (int i = 1; i < array1.length; i++) { 67 array2[array1[i][0]][array1[i][1]]=array1[i][2]; 68 } 69 for (int[] ints : array2) { //输入array.for 70 for (int anInt : ints) { //输入ints.for 71 System.out.print(anInt+"\t"); 72 } 73 System.out.println(); 74 } 75 } 76 }
11.数组排序算法
浙公网安备 33010602011771号