目录
一 数组概述
数组的定义：相同类型数据的有序集合。每一个数据称为一个数组元素，可以通过下标来访问它们。
二 数组声明创建
（1）首先必须声明数组变量，才能在程序中使用数组。声明变量的语法：
dataType[ ] arrayRefVal; //首选方法
//或
dataType arrayRefVal [ ]; //效果相同，但不是首选方法（2）Java语言使用 new 操作符来创建数组，语法如下：
dataType[] arrayRefVal = new dataType[ arraySize];注意：数组的元素是通过索引访问的，数组索引从0开始； 或许数组长度： arrays.length
public class Demo01 {
public static void main(String[] args) {
int[] nums; //1 声明一个数组
nums = new int[10]; //2 创建一个数组
nums[0] = 1;//3 给数组赋值
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;
//计算所有元素的值
int sum = 0;
//获取数组长度 nums.length
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
}
System.out.println(sum);
System.out.println(nums[0]);
}
}三种初始化方法及内存分析
java内存分析：
（1）堆：存放new的对象和数组；可以被所有的线程共享，不会存放别的对象引用。
（2）栈：存放基本变量类型（会包含这个基本类型的具体数值）；引用对象的变量（会存放这个引用在堆里面的具体地址）
（3）方法区：可以被所有的线程共享；包含了所有的class和static变量；
定义并创建一个数组的过程：
（1）定义数组后，会在栈中压入一个array元素（2）在创建数组时会在堆中开辟一块内存。（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;数组的默认初始化：数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化.
public class Demo02 {
public static void main(String[] args){
//1 静态初始化：创建+赋值
int[] a = {1,2,3,4,5,6,7};
//假设Man是一个类,对引用类也可以进行静态初始化
Man[] mans = {new Man(),new Man()};
//2 动态初始化,动态初始化时，每个元素都有一个默认初始化赋值。
int[] b = new int[10];
b[0] = 1;
System.out.println(b[1]);//会输出默认初始化的值
System.out.println(b[0]);//会输出动态初始化的值
}
}数组的四个基本特点：
数组的长度时确定的，一旦被创建，它的大小就是不可改变的。
元素必须是相同类型，不允许出现混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
数组变量属于引用类型时，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
注意：数组本身就是对象，Java中对象是在堆中，因此数组无论保存原始类型还是其他对象累心，数组对象本身就是在堆中的。
数组边界：下标的合法区间 【0，length-1】，
如果越界就会报错：ArrayIndexOutOfBoundsException----数组下标越界异常！
三 数组使用
数组的使用：For-Each循环；数组作方法入参；数组作返回值。
例题1 定义数组并输出所有元素、输出元素的和、输出元素中最大的值
public class Demo03 {
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]);
}
//第二种输出方式,增强型for循环
for(int x:arrays){
System.out.println(x);
}
//计算数组内元素的和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
sum = sum + arrays[i];
}
System.out.println(sum);
//返回数组内最大的值
int max = arrays[0];
for (int i = 0; i < arrays.length; i++) {
max = max > arrays[i] ? max : arrays[i];
}
System.out.println(max);
}
}其他例题：---数组作为方法的参数；数组作为方法的返回值
public class Demo03 {
public static void main(String[] args) {
//定义数组并输出
int[] arrays = {1, 2, 3, 4, 5};
//数组作方法入参
printarr(arrays);
System.out.println("------数组作方法入参--------");
//返回指为数组--反转数组
int[] ans = reverse(arrays);
printarr(ans);
System.out.println("------返回指为数组--反转数组--------");
}
//数组作方法入参的方法
public static void printarr(int[] arrays) {
for (int x : arrays) {
System.out.println(x);
}
}
//返回指为数组--反转数组
public static int[] reverse(int[] arrays) {
int[] ans = new int[arrays.length];
for (int i = 0, j = arrays.length - 1; i < arrays.length; i++, j--) {
ans[j] = arrays[i];
}
return ans;
}
}
四 多维数组
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，它的每个元素都是一个一维数组。
例如 二维数组：int a[ ] [ ] = new int [2][5];
多维数组的定义及输出：
public class Demo04 {
public static void main(String[] args) {
int[][] array = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
System.out.println("数组长度:" + array.length);
System.out.println(array[0][0]);
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]);
}
System.out.println();
}
}
}五 Arrays类
数组的工具类java.util.Arrays
Arrays类中的方法都是static修饰的静态方法，在使用时可以直接使用类名进行调用。
具有以下常用功能：
（1）给数组赋值：通过fill方法
（2）对数组排序：通过sort方法，按升序；
（3） 比较数组：通过equals方法比较数组中元素值是否相等。
（4）查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。
public class Demo05 {
public static void main(String[] args){
int a[] = {1,5,2,4,7,8,3,9};
Arrays.sort(a);//调用Arrays的sort方法
System.out.println(Arrays.toString(a));//调用Arrays的toString方法
Arrays.fill(a,0);//调用Arrays的fill方法，将数组a全部重置为0；
System.out.println(Arrays.toString(a));
Arrays.fill(a,2,5,1);//调用Arrays的fill方法，将数组a的下标2到下标5全部重置为1
System.out.println(Arrays.toString(a));
}
}冒泡排序：
两层循环，外层冒泡轮数，里层依次比较。时间复杂度O(n2)
1 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3 针对所有的元素重复以上的步骤，除了最后一个。
4 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
public static void sort_1(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - i - 1; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
System.out.println(Arrays.toString(array));
}六 稀疏数组
稀疏数组：当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方式是：（1）记录数组一共有几行几列，有多少个不同值。（2）把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模。
例如：一个5行6列的数组中有2两个有效数字，则可以表示为一个二维数组，a【0】={5，6，2}，表示原数组的行列数及有效数字数。a[1] = {n,m,66} 表示第n行第m列数字为66.
棋盘棋子举例：
public class Demo07 {
public static void main(String[] args) {
//1.1 创建一个二维数组 11*11， 0：没有棋子 1：黑棋 2：白棋
int[][] arrays1 = new int[11][11];
arrays1[1][2] = 1;
arrays1[4][6] = 2;
//1.2输出原始数组
System.out.println("输出原始数组：");
for (int[] ints : arrays1) {
for (int x : ints) {
System.out.print(x + "\t");
}
System.out.println();
}
//2.1转换为稀疏矩阵保存
//2.2获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (arrays1[i][j] != 0) {
sum++;
}
}
}
//2.3创建稀疏矩阵
int[][] array2 = new int[sum + 1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//2.4遍历二维数组，将非零值存放稀疏数组中
int count = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (arrays1[i][j] != 0) {
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = arrays1[i][j];
}
}
}
//2.5输出稀疏数组
System.out.println("输出稀疏数组：");
for (int[] ints : array2) {
for (int x : ints) {
System.out.print(x + "\t");
}
System.out.println();
}
//3.1还原稀疏矩阵
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//3.2给其他的元素还原值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//3.2输出还原后的矩阵
for (int[] ints : array3) {
for (int x : ints) {
System.out.print(x + "\t");
}
System.out.println();
}
}
}