1.数组概述
数组是一个类型的所有数据的一个集合，并用一个数组下标来区分或指定每一个数。数组的下标是从0开始的。
数组的定义：
-
数组是相同类型数据的有序集合.
-
数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
-
其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.
数组的四个基本特点：
-
其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
-
其元素必须是相同类型,不允许出现混合类型。
-
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
-
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组 本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象 本身是在堆中的。
1.首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
int[] nums ; //声明一个数组 使用int[]创建了一个数组 在栈中 nums = new int[10]; //创建一个数组 把创建的数组是引用赋值给变量nums 在堆中
2.声明并创建一个数组：
int[] nums = new int[10]; //数组的长度确定
数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrays.length-1。
3.获取数组长度：
arrays.length
4.内存分析
5.声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有 关。因此，声明数组时不能指定其长度(数组中元素的个数)，例如： int a[5]; //非法
6.声明一个数组的时候并没有数组被真正的创建。
7.构造一个数组，必须指定长度
8.数组下标越界：
ArrayIndexOutOfBoundsException : 数组下标越界异常！
9.数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实 例变量同样的方式被隐式初始化
数组的两种定义并赋值方式
1.动态初始化 声明创建一个数组并为其赋值。注意事项：new后面的中括号中不允许写任何内容，写了就编译失败。
数据类型[] 变量名 = new 数据类型[]{元素1，元素2，元素3};
int[] array = new int[]{45,65,78,78,1,5,9};
2.数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实 例变量同样的方式被隐式初始化。
数据类型[] 变量名 = new 数据类型[10]；
变量名[0] = 数值1；
变量名[1] = 数值2；
int[] a = new int[10]; a[0]=1; a[1]=2;
3.静态初始化 除了用new关键字来产生数组以外,还可以直接在定义数组的同时就为数组元素分配空间并赋值
数据类型[] 变量名 = {元素1，元素2，元素3}；、
int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};
3.数组的使用
1.1 For-Each循环
int[] arrays ={45,16,15,18,56,25,48,96,38}; //没有下标
//1.For-Each循环
for (int array:arrays) {
System.out.println(array);
}
1.2For-Each双循环
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
for (int[] ints : array1) { //array1.for
for (int anInt : ints) { //ints.for
System.out.print(anInt + "t"); //anInt
}
System.out.println();
}
1.3 打印数组元素 Arrays.toString(arrays); 可直接调用函数。
2.数组作方法入参
public static void main(String[] args) {
int[] arrays ={45,16,15,18,56,25,48,96,38};
printArray(arrays);
}
// 2.数组作方法入参 --- 打印数组元素
public static void printArray(int[] array){
for (int i = 0; i
3.数组作返回值 rever 数组作为函数的返回值。
public static void main(String[] args) {
int[] arrays ={45,16,15,18,56,25,48,96,38};
printArray(revers(arrays));// 3.数组作返回值
}
public static void printArray(int[] array) { // 2.数组作方法入参 --- 打印数组元素
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + "t");
}
}
public static int[] revers(int[] array){ // 3.数组作返回值 --- 反转输出数组
int[] rever = new int[array.length];
for (int i = 0,j=array.length-1; i
4.普通for循环
public static void main(String[] args) {
//1.打印全部的数组元素
int[] arrays = {12,13,45,65,42,32,89,47};
for (int i = 0; i max){
max = arrays[i];
}
}
System.out.println("数组的最大值："+ max);
}
4.多维数组
多维数组可以看成是数组的数组
比如: 二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
多维数组的动态初始化（以二维数组为例）
type[][] typeName = new type[typeLength1][typeLengt2h]
type 可以为基本数据类型和复合数据类型，typeLenght1 和 typeLenghtt2 必须为正整数，typeLenght1 为行数，typeLenght2 为列数。
比如定义一个三行五列的二维数组：
int a[][] = new int[3][5]
获取数组长度：
a.length获取的二维数组第一维数组的长度，a[0].length才是获取第二维第一个数组长度。
//二维数组为例
int a[][] = new int[3][5];
System.out.println(" 数组的行数为： "+ a.length);
System.out.println( " 数组的列数为： "+ a[0].length);
//结果：
数组的行数为： 3
数组的列数为： 5
5.Arrays类
数组的工具类java.util.Arrays，java.util.Arrays 类能方便地操作数组. 使用之前需要导包！
Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对
象来调用(注意:是"不用" 而不是 "不能")。
方法举例：
-
打印数组： 通过 toString 方法。
int a[] = {45,56,98,485,658,120,13,36};
System.out.println(a); //[I@1b6d3586 对象
System.out.println(Arrays.toString(a));//[45, 56, 98, 485, 658, 120, 13, 36]
-
给数组赋值：通过 fill 方法。
int a[] = {45,56,98,485,658,120,13,36}; Arrays.fill(a,2,3,3); //将2到3索引的元素替换为3 System.out.println(Arrays.toString(a));//[45, 56, 3, 485, 658, 120, 13, 36] -
对数组排序：通过 sort 方法,按升序。
int a[] = {45,56,98,485,658,120,13,36}; Arrays.sort(a); System.out.println(Arrays.toString(a));//[3, 13, 36, 45, 56, 120, 485, 658] -
比较数组：通过 equals 方法比较数组中元素值是否相等。
int a[] = {45,56,98,485,658,120,13,36}; int b[] = {0, 0, 13, 36, 45, 56, 120, 658}; Boolean zhi = Arrays.equals(a,b); System.out.println(zhi); //false -
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
int a[] = {45,56,98,485,658,120,13,36};
int re = Arrays.binarySearch(a,45);
System.out.println(re);//3
6.冒泡排序
冒泡排序算法的原理如下：
-
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
-
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会
是最大的数。
-
针对所有的元素重复以上的步骤，除了最后一个。
-
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
public static void main(String[] args) { int[] array = {12, 51, 61, 6, 14, 19, 89, 15, 33, 1, 42, 0}; int[] sort = sort(array); for (int num : sort) { System.out.print(num + "t"); } } public static int[] sort(int[] array) { int temp = 0; // 外层循环，它决定一共走几趟 ,-1为了防止溢出 for (int i = 0; i < array.length - 1; i++) { int flag = 0; //通过符号位可以减少无谓的比较，如果已经有序了，就退出循环 // 内层循环，它决定每趟走一次 for (int j = 0; j < array.length - i - 1; j++) { //如果后一个大于前一个,则换位 if (array[j + 1] > array[j]) { temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; flag = 1; } } if (flag == 0) { break; } } return array; } //89 61 51 42 33 19 15 14 12 6 1 0
选择排序的工作原理：
1.每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置。
2.再从剩余未排序元素中继续寻找最小（大）元素，然后放到排序序列的末尾。
3.以此类推，直到全部待排序的数据元素排完。
public static void main(String[] args) {
int[] array = {2, 5, 1, 6, 4, 9, 8, 5, 3, 1, 2, 0};
int[] sort = sort(array);
for (int num : sort) {
System.out.print(num + "t");
}
}
public static int[] sort(int arr[]) {
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
// 认为目前的数就是最小的, 记 录最小数的下标
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[minIndex] > arr[j]) {
// 修改最小值的下标
minIndex = j;
}
}
// 当退出for就找到这次的最小值,就需要交换位置了
if (i != minIndex) {
//交换当前值和找到的最小值的位置
temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
return arr;
}//0 1 1 2 2 3 4 5 5 6 8 9
8.稀疏矩阵
稀疏数组记录有效的坐标，记录原始坐标的大小以及它的有效值。
题目要求：把稀疏矩阵用三元组法保存，然后再还原数组：
public class ArrayDemo09 {
//打印二维数组 --- 稀疏矩阵 五子棋 0：没有棋子 1：黑棋 2：白棋
public static void main(String[] args) {
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
System.out.println("输出原始数组");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt + "t");
}
System.out.println();
}
System.out.println("================================================================");
//转换为稀疏数组保存
int sum = 0; //记录有效值的个数
for (int i = 0; i <11 ; i++) {
for (int j = 0; j <11 ; j++) {
if(array1[i][j] !=0){
sum++;
}
}
}
System.out.println("有效值的个数是：" +sum);
//创建一个稀疏数组的数组
int[][] array2 = new int[sum+1][3];
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=sum;
//遍历二维数组，将非零值存放到稀疏数组里
int count = 0;
for (int i = 0; i
