数组的定义
- 数组是指相同类型数据的有序集合
- 数组描述的是相同类型的若干数据，按照一定的先后次序排列组合而来
- 其中，每个数据称作一个数组元素，每个元素可以通过一个下标来访问他们。
数组的声明和创建
-
首先必须声明数组变量才能在程序中使用数组，下面是声明数组的语法：
dataType[] arrayRefVar;//首选方法 or dataType arrayRefVar[]; -
java里面使用new操作符来创建数组，语法如下：
dataType[] arrayRefVar = new dataType[arraySize]; -
数组的元素是通过索引访问的，数组索引从0开始。
-
获取数组长度：array.length()
//数据类型[]:定义一个元素类型为该数据类型的数组 //eg：int[]:定义一个元素类型为int的数组 public static void main(String[] args) { int[] nums;//声明数组 nums = new int[7];//创建一个数组 nums[0]=1; nums[1]=2; nums[2]=3; nums[3]=4; nums[4]=5; nums[5]=6; nums[6]=7;//赋值 System.out.println(nums[4]); //计算所以元素的和 int sum = 0; for (int i = 0; i < nums.length; i++) { sum += nums[i]; } System.out.println("和为" + sum); //int nums2[];//c和c++的数组定义方式
数组的四个基本特点
- 其长度是确定的。数组一旦创建，它的大小就是不可改变的。
- 其元素必须是相同类型，不允许出现其他混合类型
- 数组中的元素可以是任何数据类型，它包括基本类型和引用类型
- 数组变量属引用类型，数组也可以看成对象，数组中每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此不论数组保存原始类型还是其他对象类型，数组对象本身是在堆中的
数组的内存分析
访问超过数组长度：java.lang.ArrayIndexOutOfBoundsException
三种初始化
-
静态初始化：
int[] a = {1,2,3}; Man[] mans = {new Man(1,1),new Man(2,2)}; -
动态初始化：
int a = new int[2]; a[0] = 1; a[1] = 2; -
数组默认初始化
- 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
public class ArrayDemo02 { public static void main(String[] args) { //静态初始化:创建并赋值 int[] a = {1,2,3}; Man[] mans = {new Man(),new Man()};//引用数据类型Man方法 //动态初始化:若不赋值则初始化int为0（默认初始化） int[] b = new int[10]; b[0] = 1; b[1] = 2; System.out.println(a[1]); System.out.println(b[1]); } }
数组的使用
-
for-each循环
-
普通的for循环
-
数组作为方法入参
-
数组作为返回值
public static void main(String[] args) { int[] arrays = {1,2,4,5}; //jdk1.5，把arrays的值赋给array输出，没有下标 // for (int array : arrays){ // System.out.println(array); // } int[] reverse = reverse(arrays); printArrays(reverse); } //反转数组(数组作为返回值） public static int[] reverse(int[] arrays) { int[] result = new int[arrays.length]; for (int i = 0, j = arrays.length-1; i < arrays.length; i++, j--) { result[j] = arrays[i]; } return result; } //数组作方法入参 public static void printArrays(int[] arrays) { for (int i = 0; i < arrays.length; i++) { System.out.print(arrays[i]); } } }
多维数组
-
多维数组可以看成数组的数组，比如二维数组就是一个特殊的一位数组，其每一个元素都是一个一位数组。（数组的元素还是数组）
-
二维数组
int a[][] = new int[2][5];可以将上述数组a看成一个两行五列的数组
public static void main(String[] args) { int[][] array = {{1, 2}, {2, 3}, {3, 4}};//数组内的元素还是数组 /* [3][2] 1,2 array[0] 2,3 array[1] 3,4 array[2] */ for (int i = 0; i < array.length; i++) { for (int j = 0; j < array[i].length; j++) { System.out.print(array[i][j] + " "); } } printArrays(array[0]); } public static void printArrays(int[] arrays) { for (int i = 0; i < arrays.length; i++) { System.out.print(arrays[i]); } }
Arrays类
-
java的工具类java.util.Arrays
-
由于数组本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作
-
查看jdk帮助文档
-
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来进行调用。
-
具有以下常用功能
- 给数组赋值：fill方法
- 给数组排序：sort方法，按升序
- 比较数组：equals方法比较数组中元素值是否相等
- 查找数组元素：binarySearch方法能堆排序好的数组进行二分查找操作
public class ArrayDemo06 { public static void main(String[] args) { int[] a = {2,4,6,1,9,8}; System.out.println(a);//打印的是对象的hashcode //打印数组元素Array.toString方法 System.out.println(Arrays.toString(a)); printArray(a);//自己写的打印数组方法 System.out.println(); Arrays.sort(a); System.out.println(Arrays.toString(a));//升序排序数组a } public static void printArray(int[] a){ for (int i = 0; i < a.length; i++) { if (i == 0){ System.out.print("[" + a[i] + ", "); }else if(i == a.length-1){ System.out.print(a[i] + "]"); }else { System.out.print(a[i] + ", "); } } } }
冒泡排序
-
冒泡排序一共两层循环，外层冒泡次数，内层依次比较
-
时间复杂度为O(n2)
public class ArrayDemo07 { public static void main(String[] args) { //冒泡排序 //比较数组中相邻的两个元素，如果第一个比第二个大，就交换他们的位置 //每次排序完成找到一个元素的位置 //下一次排序可以减少一次对比 int[] a = {1,3,5,3,7,4,8,9,2}; System.out.println(Arrays.toString(sort(a))); } public static int[] sort(int[] array){ int temp = 0;//临时变量 //外层循环，判断走多少次 for (int i = 0; i < array.length-1; i++) { //内层循环用于比较两个数是否要交换 for (int j = 0; j < array.length-1-i; j++) {//每次排序都有一个元素位置被确定，第i次即i个元素被确定 if (array[j+1] < array[j]){ temp = array[j+1]; array[j+1] = array[j]; array[j] = temp; } } } return array; } }
稀疏矩阵
- 当一个数组中很多元素为0或者同一值时，可以使用稀疏数组来保存该数组
- 稀疏数组的处理方式：
- 记录数组有几行几列，有多少不同的值
- 把具有不同值得元素和行列记录在一个小规模的数组里，从而缩小程序的规模
public static void main(String[] args) {
//创建一个二维数组，11x11,
int[][] a = new int[11][11];
a[1][2] = 1;
a[2][3] = 2;
//输出原始数组
System.out.println("输出原始数组");
for (int[] ints : a) {//把数组a的值赋给数组ints输出
for (int anInt : ints) {//把数组ints的值赋给anInt输出
System.out.print(anInt + "\t");
}
System.out.println();
}
//转换为稀疏矩阵保存
//获取有效值的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if ((a[i][j])!=0){
sum++;
}
}
}
System.out.println("有效值的个数为" + sum);
//创建一个保存稀疏数组的数组
int[][] b = new int[sum+1][3];
b[0][0] = 11;
b[0][1] = 11;
b[0][2] = sum;
//遍历二维数组a，将非零的值存放进稀疏数组
int count = 0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
if (a[i][j]!=0){
count++;//第count个元素
b[count][0] = i;//行值
b[count][1] = j;//列值
b[count][2] = a[i][j];//数据值
}
}
}
//打印稀疏数组
System.out.println("稀疏数组为：" );
for (int i = 0; i < b.length; i++) {
System.out.println(b[i][0] + "\t" + b[i][1] + "\t" + b[i][2]);
}
System.out.println("===================================");
System.out.println("还原");
//读取稀疏矩阵
int[][] c = new int[b[0][0]][b[0][1]];//c的矩阵大小对应b的行列值
//还原其中的值
for (int i = 1; i < b.length; i++) {
c[b[i][0]][b[i][1]] = b[i][2];//取行列值=b的数据值
}
//打印
System.out.println("输出还原的值为：");
for (int[] ints : c) {//把数组a的值赋给数组ints输出
for (int anInt : ints) {//把数组ints的值赋给anInt输出
System.out.print(anInt + "\t");
}
System.out.println();
}
}
}
浙公网安备 33010602011771号