1.什么是数组？
1.数组的定义
数组是相同类型数据的有序集合。
数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。
2.数组的声明与创建
1.数组的声明
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
dataType[] arrayRefVar; // 首选的方法dataType arrayRefVar[]; // 效果相同，但不是首选方法
demo01
double[] myList; // 首选的方法double myList[]; // 效果相同，但不是首选方法
2.数组的创建
Java语言使用new操作符来创建数组，语法如下：
arrayRefVar = new dataType[arraySize];
上面的语法语句做了两件事：
- 一、使用 dataType[arraySize] 创建了一个数组。
- 二、把新创建的数组的引用赋值给变量 arrayRefVar。
数组变量的声明，和创建数组可以用一条语句完成，如下所示：
dataType[] arrayRefVar = new dataType[arraySize];
另外，还可以使用如下的方式创建数组。
dataType[] arrayRefVar = {value0, value1, ..., valuek};
数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。
demo02
下面的语句首先声明了一个数组变量 myList，接着创建了一个包含 10 个 double 类型元素的数组，并且把它的引用赋值给 myList 变量。
public class TestArray {public static void main(String[] args) {// 数组大小int size = 10;// 定义数组double[] myList = new double[size];myList[0] = 5.6;myList[1] = 4.5;myList[2] = 3.3;myList[3] = 13.2;myList[4] = 4.0;myList[5] = 34.33;myList[6] = 34.0;myList[7] = 45.45;myList[8] = 99.993;myList[9] = 11123;// 计算所有元素的总和double total = 0;for (int i = 0; i < size; i++) {total += myList[i];}System.out.println("总和为： " + total);}}
以上实例输出结果为：
总和为： 11367.373
3.数组的三种初始化
1.静态初始化
int[] a={1,2,3};Man[] mans={new Man(1,1),new Man(2,2)};
2.动态初始化
int[] a=new int[2];a[0]=1;a[1]=2;
3.数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组- -经分配空间,其中的每个元素也被按照实例变量同样的方式被隐式初始化。
4.数组的内存分析
5.数组的基本特点
- 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
- 其元素必须是相同类型,不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
数组变量属引用类型，数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
6.数组边界
下标的合法区间：[0,length-1],如果越界就会报错：
public static void main(String[] args){int[] a=new int[2];System.out.println(a[2]);}
ArrayIndexOutOfBoundsException :数组下标越界异常!
7.数组的使用
1.For——Each循环遍历数组
For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。
语法格式如下：for(type element: array){System.out.println(element);}
demo
该实例用来显示数组 myList 中的所有元素：
public class TestArray {public static void main(String[] args) {double[] myList = {1.9, 2.9, 3.4, 3.5};// 打印所有数组元素for (double element: myList) {System.out.println(element);}}}
以上实例编译运行结果如下：
1.92.93.43.5
2.数组作为函数的参数
数组可以作为参数传递给方法。
例如，下面的例子就是一个打印 int 数组中元素的方法:public static void printArray(int[] array) {for (int i = 0; i < array.length; i++) {System.out.print(array[i] + " ");}}
下面例子调用 printArray 方法打印出 3，1，2，6，4 和 2：
printArray(new int[]{3, 1, 2, 6, 4, 2});
3.数组作为函数的返回值
public static int[] reverse(int[] list) {int[] result = new int[list.length];for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {result[j] = list[i];}return result;}
1.数组的输出，求和，求最大元素demo
public class ArrayDemo03 {public static void main(String[] args) {int[] arrays={1,2,3,4,5};//打印全部的数组元素for (int i = 0; i <arrays.length ; i++) {System.out.println(arrays[i]);}System.out.println("===============================");//计算所有元素的和int sum=0;for (int i = 0; i <arrays.length ; i++) {sum+=arrays[i];}System.out.println("sum="+sum);System.out.println("===============================");//查找最大元素int max=arrays[0];for (int i = 0; i <arrays.length ; i++) {if (arrays[i]>max){max=arrays[i];}}System.out.println("max="+max);}}
2.数组的反转demo
```java public class ArrayDemo04 { public static void main(String[] args) {
int[] arrays={1,2,3,4,5};
// for (int array:arrays) { // System.out.println(array); // } int[] reverse=reverse(arrays); printArray(arrays); System.out.println(); printArray(reverse); }
//打印数组元素public static void printArray(int[] arrays) {for (int i = 0; i <arrays.length ; i++) {System.out.print(arrays[i]+" ");}}//反转数组public static int[] reverse(int[] arrays){int[] result=new int[arrays.length];//反转的操作for (int i = 0,j=result.length-1; i <arrays.length ; i++,j--) {result[j]=arrays[i];}return result;}
}
<a name="xUltR"></a># 8.多维数组（以二维数组为例进行说明）<a name="YyNxI"></a>### 1.多维数组的动态初始化<a name="nYhyh"></a>#### 1.直接为每一维分配空间```javatype[][] typeName = new type[typeLength1][typeLength2];
type 可以为基本数据类型和复合数据类型，typeLength1 和 typeLength2 必须为正整数，typeLength1 为行数，typeLength2 为列数。
例如：
int[][] a = new int[2][3];
2.从最高维开始，分别为每一维分配空间，
例如：
String[][] s = new String[2][];s[0] = new String[2];s[1] = new String[3];s[0][0] = new String("Good");s[0][1] = new String("Luck");s[1][0] = new String("to");s[1][1] = new String("you");s[1][2] = new String("!");
s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间，也就是为最高维限制其能保存数据的最长的长度，然后再为其每个数组元素单独分配空间 s0=new String(“Good”) 等操作。
2.多维数组的引用
对二维数组中的每个元素，引用方式为 arrayName[index1][index2]，例如：
num[1][0];
9.Arrays 类
java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
具有以下功能：
- 给数组赋值：通过 fill 方法。
- 对数组排序：通过 sort 方法,按升序。
- 比较数组：通过 equals 方法比较数组中元素值是否相等。
- 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
10.冒泡排序
1.算法说明
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢”浮”到数列的顶端。
2.算法步骤
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
3.时间复杂度分析
1.最快的情况
2.最坏的情况
4.代码实现
public class Bubble {public static void main(String[] args) {//冒泡排序算法int[] numbers = new int[]{1, 5, 8, 2, 3, 9, 4};bubble1(numbers);}public static void bubble1(int[] numbers) {//需进行length-1次冒泡for (int i = 0; i < numbers.length - 1; i++) {for (int j = 0; j < numbers.length - 1 - i; j++) {if (numbers[j] > numbers[j + 1]) {int temp = numbers[j];numbers[j] = numbers[j + 1];numbers[j + 1] = temp;}}}System.out.println("从小到大排序后的结果是:");for (int i = 0; i < numbers.length; i++)System.out.print(numbers[i] + " ");}}
11.稀疏数组
1.稀疏数组的使用场景
当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组，稀疏数组的处理方法是：
- 记录数组一共有几行几列，有多少个不同的值。
把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。
2.稀疏数组的表示
即第一行第一列记录记录原始数组行数，第一行第二列记录原始数组列数，第一行第三列总共有多少个值，第二行记录第一个有效数据，第三行记录第二个有效数据。3.稀疏数组的应用实例
使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)
- 把稀疏数组存盘，可以重新恢复原来的二维数组数
- 整体思路分析
二维数组转稀疏数组的思路
1.遍历原始的二维数组，得到有效数据的个数sum
2.根据sum就可以创建稀疏数组sparseArr int[sum+ 1] [3]
3.将二维数组的有效数据数据存入到稀疏数组
稀疏数组转原始的二维数组的思路
1.先读取稀疏数组的第一行，根据第一行的数据， 创建原始的二维数组，比如上面的chessArr2 = int [11][11]
2.在读取稀疏数组后几行的数据，并赋给原始的二维数组即可.
4.代码实现
public class SparseArr {public static void main(String[] args) {//创建一个二维数组 11*11//0表示没有棋子，1表示黑棋，2表示蓝棋int[][] chessArr = new int[11][11];chessArr[1][2] = 1;chessArr[2][3] = 2;//输出原始的二维数组System.out.println("原始的二维数组：");for (int i = 0; i < chessArr.length; i++) {for (int j = 0; j < chessArr[i].length; j++) {System.out.print(chessArr[i][j]+"\t");}System.out.println();}//将二维数组转换为稀疏数组//1.先遍历二维数组得到非零数据的个数int sum = 0;for (int i = 0; i < 11; i++) {for (int j = 0; j < 11; j++) {if (chessArr[i][j] != 0){sum++;}}}//2.创建对应的系数数组int[][] sparseArr = new int[sum+1][3];//给系数数组赋值sparseArr[0][0] = 11;sparseArr[0][1] = 11;sparseArr[0][2] = sum;//遍历二维数组将非零的值存放到稀疏数组int count = 0;for (int i = 0; i < chessArr.length; i++) {for (int j = 0; j < chessArr[i].length; j++) {if (chessArr[i][j] != 0){count++;sparseArr[count][0] = i;sparseArr[count][1] = j;sparseArr[count][2] = chessArr[i][j];}}}//输出稀疏数组System.out.println();System.out.println("稀疏数组：");for (int i = 0; i < sparseArr.length; i++) {System.out.println(sparseArr[i][0]+"\t"+sparseArr[i][1]+"\t"+sparseArr[i][2]);}//将稀疏数组恢复成二维数组//1.先读取稀疏数组的第一行，根据第一行创建二维数组int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];//2.读取稀疏数组后几行赋值给二维数组//注意这里是从第二行开始for (int i = 1; i < sparseArr.length; i++) {chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];}System.out.println();System.out.println("恢复后的二维数组：");for (int[] row : chessArr2) {for (int data : row) {System.out.print(data+"\t");}System.out.println();}}}
若有收获，就点个赞吧
0 人点赞
