本文详细介绍了Java中的数组，包括定义、声明创建、初始化、内存分析、特征总结及常见操作。通过示例展示了静态和动态初始化、数组操作如排序、填充、比较以及冒泡排序算法。此外，还讲解了二维数组、稀疏数组的概念及其应用。
数组
数组概述
数组的定义
- 数组是相同类型数据的有序集合
- 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
- 每一个数组被称作一个数组元素，每个数组元素可以通过一个下标来访问它们
数组声明创建
-
声明数组变量
数据类型[] 数组名称；(首选的方法)
数据类型 数组名称[];（效果是相同的） -
创建数组 (Java使用new操作符来创建数组)
数据类型[] 数组名称 = new 数据类型[ 数组长度length ]；
-
Java中必须先声明变量，才能在程序中使用。
-
数组的元素是通过索引来访问的，数组索引从0开始。
-
获取数组长度可以采用：数组名称.length。
数组的三种初始化
-
静态初始化
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;
-
数据的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
package com.Hrstudy.array;
public class demo01 {
public static void main(String[] args) {
//静态初始化 : 创建 + 赋值
int[] a = {1,2,3,4,5,6};
System.out.println(a[2]); //3
//动态初始化 : 包含默认初始化
int[] b = new int[10];
b[0] = 1;
b[1] = 2;
System.out.println(b[0]); //1
System.out.println(b[1]); //2
System.out.println(b[2]); //0
System.out.println(b[3]); //0
}
}
Java数组的内存分析
Java内存可分为：
- 堆
- 可以存放 new 的 对象 和 数组。
- 可以被所有的线程共享，不会存放别的对象引用
- 栈
- 存放基本变量类型（会包含这个基本类型的具体数值）
- 引用对象的变量（会存放这个引用在堆里面的具体地址）
- 方法区
- 可以被所有的线程共享
- 包含所有的 class 和 static 变量
数组的特征总结
- 数组也是对象。数组元素相当于对象的成员变量。
- 数组的长度是确定的，不可变的，如果越界，会报出：ArrayIndexOutofBounds
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
数组的使用
-
普通for循环
-
for-each（增强for）循环
-
数组做方法入参
-
数组做返回值
代码参考：
package com.Hrstudy.array; public class demo02 { public static void main(String[] args) { int[] arrays = {1,2,3,4,5}; //JDK1.5开始 数组没有下标 for (int array : arrays) { System.out.println(array); //1,2,3,4,5 } ptintArray(arrays); //1,2,3,4,5 int[] result = reverse(arrays); //返回的结果是一个数组 ptintArray(result); //5,4,3,2,1 } //反转数组 public static int[] reverse(int[] array){ int[] result = new int[array.length]; //新建一个和传入参数数组长度相同的result数组 //反转的操作 for (int i = 0,j = result.length - 1; i < array.length; i++,j--) { result[j] = array[i]; //把array数组正序的每个数值赋值给result数组倒序每个位置 } return result; } //打印数组元素 public static void ptintArray(int[] array){ for (int i = 0; i < array.length; i++) { System.out.println(array[i] + ""); } } }
二维数组
-
二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
int a[ ] [ ] = new int[2] [5]; //行数、列数
- 代码演示
Arrays类
-
由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类 Arrays
（工具类：java.util.Arrays）供我们使用，从而对数据对象进行一些基本的操作。（查看JDK帮助文档）
-
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类型进行调用，而不用使用对象来调用。（注意：是”不用“，而不是“不能”）
-
Arrays类中常用的方法有
-
给数组赋值 ： 通过 fill 方法。
-
对数组排序 ： 通过 sort 方法，按照升序排序。
-
比较数组 ： 通过 equals 方法比较数组中元素值是否相等。
-
查找数组元素 ： 通过binarySearch 方法能对排序好的数组进行二分查找法操作。
-
-
代码演示
package com.Hrstudy.array;
import java.util.Arrays;
public class demo03 {
public static void main(String[] args) {
int[] a = {1,22,65,43,89,111,0,12};
System.out.println("直接打印原数组会获得原数组的地址:"+a); //[I@119d7047
//使用工具类Arrays.toString方法输出数组
System.out.println("使用工具类Arrays.toString方法输出数组:"+ Arrays.toString(a)); //[1, 22, 65, 43, 89, 111, 0, 12]
//自己仿写toString的功能
printArray(a); //[1, 22, 65, 43, 89, 111, 0, 12]
//使用工具类Arrays.sort方式对数组排序
Arrays.sort(a);
System.out.println(Arrays.toString(a)); //[0, 1, 12, 22, 43, 65, 89, 111] 按照升序进行排列
//使用工具类Arrays.fill方式对数组进行填充
Arrays.fill(a,0);
System.out.println(Arrays.toString(a)); //[0, 0, 0, 0, 0, 0, 0, 0]
}
public static void printArray(int[] array){
for (int i = 0; i < array.length; i++) {
if(i==0){
System.out.print("[");
}
if(i==array.length-1){
System.out.println(array[i]+"]");
}else{
System.out.print(array[i]+", ");
}
}
}
}
冒泡排序
-
总共有八大排序，冒泡排序无疑是最出名的排序算法之一。
-
冒泡排序，使用两层循环，外层循环控制冒泡轮数，内层循环依次进行比较。
-
当看到嵌套循环的时候，应该马上可以得出这个算法的时间复杂度是O(n^2)。
-
代码演示
package com.Hrstudy.array; import java.util.Arrays; public class demo04 { //冒泡排序 //1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，就交换它们的位置 //2.每一次比较，都会产生出一个最大的，或者最小的数字 //3.下一轮则可以减少一次排序 //4.依次循环，直至结束 public static void main(String[] args) { int[] a = {1,5,6,7,8,10,5,6}; int[] b = sort(a);//返回一个排序后的数组 System.out.println(Arrays.toString(b)); //[1, 5, 5, 6, 6, 7, 8, 10] } public static int[] sort(int[] a){ //定义一个临时变量 int temp = 0; //外层循环 for (int i = 0; i < a.length-1; i++) { boolean flag = false; //通过flag标识位减少没有意义的比较 for (int j = 0; j < a.length-1-i; j++) { if(a[j+1] < a[j]){ //升序还是降序 可以通过大于小于号进行调整 temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; flag = true; } } if(flag == false){ //如果没有执行交换数组元素位置，外层本次循环结束，无需在和后面进行比较 break; } } return a; } }
稀疏数组
-
当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
-
稀疏数组的处理方式是：
- 记录数组一共有几行几列
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
-
如下图，左边是原始数组，右边是稀疏数组。
-
代码演示
package com.Hrstudy.array; public class demo05 { public static void main(String[] args) { //稀疏数组 //需求：模拟保存黑白五子棋的下棋位置 //1.创建一个二维数组 11*11 0:没有棋子 1:黑棋 2:白棋 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("================================"); //2.转换为稀疏数组保存 //*获取有效值的个数 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 < array1.length; i++) { for (int j = 0; j < array1[i].length ; j++) { if(array1[i][j] != 0){ count++; array2[count][0] = i;//存放有效值的行数 array2[count][1] = j;//存放有效值的列数 array2[count][2] = array1[i][j];//存放有效值的数值 } } } //*输出稀疏数组 System.out.println("输出稀疏数组:"); for (int i = 0; i < array2.length; i++) { System.out.println(array2[i][0] + "\t" +array2[i][1] + "\t" +array2[i][2] + "\t"); } System.out.println("================================"); System.out.println("还原"); //通过稀疏数组还原原始数组 //1.读取稀疏数组 int[][] array3 = new int[array2[0][0]][array2[0][1]]; //2.给其中的元素还原它的值 for (int i = 1; i < array2.length; i++) { array3[array2[i][0]][array2[i][1]] = array2[i][2];//将有效值复制到正确的位置上 } //3.打印 System.out.println("输出还原后的数组:"); for (int[] ints : array3) {//遍历二维数组的行数 for (int anInt : ints) {//遍历二维数组的列数 System.out.print(anInt + "\t"); } System.out.println(); } } }
代码演示效果如图：
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
