数组概述
- 数组是相同类型数据的有序集合
- 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
- 其中，每一个数据称作一个数组元素，每一个数组元素可以通过一个下标来访问它们
数组的下标从0开始
数组声明创建
-
首先必须声明数组变量，才能在程序中使用数组。
dataType[] arrayRefVar; //首选方法 或 dataType arrayReVar[]; //效果相同 -
Java语言使用new操作符来创建数组，
dataType[] arrayReVar = new dataTyper[arraySize]; -
数组的元素是通过索引访问的，数组索引从0开始
-
获取数组长度 arrays.length
int[] n ; n = new int[10]; //下面这个和上面意思一样 int[] n2 = new int[10];
内存分析（初步）
三种初始化
-
静态初始化
int[] a = {1,2,3}; Man[] mans = {new Man(1，1)，new Man(2,2)}; -
动态初始化
int[] a ={1,2,3}; a[0]=1; a[1]=2; -
数组的默认初始化
- 数组的引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方法被隐藏式初始化。
public class ArrayDemo01 {
public static void main(String[] args) {
//静态初始化 创建+赋值
int[] a = {1,2,3,4,5,6,7,8,9};
System.out.println(a[0]);
//动态初始化
int[] b =new int[10];
b[0]=10;//未赋值时int默认值为0
System.out.println(b[0]);
}
}
数组的四个特点
- 其长度是确定的，数组一旦被创建，它的大小就是不可以改变的
- 其元素必须是相同类型，不允许出现混合类型
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型
- 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的
数组边界
-
下标的合法区间【0，length-1】，如果越界会报错；
public static void main(String[] args){ int[] a = new int[2]; System.out.println(a[2]);//报错，越界 } -
报错提示 ***ArrayIndexOutOfBoundsException: 数组下标越界异常!
-
小结
- 数组是相同数据类型（数据类型可以为任意类型）的有序集合
- 数组也是对象。数组元素相当于对象的成员变量
- 数组长度的确定，不可变的。越界会报错。
数组使用
- 普通的for循环
- For-Each循环
- 数组做方法入参
- 数组作返回值
public abstract class Demo03 {
public static void main(String[] args) {
int[] a={1,2,3,4,5};
//打印全部数组元素
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
System.out.println("--------------------------");
//计算所有元素的和
int sum=0;
for (int i = 0; i < a.length; i++) {
sum+=a[i];
}
System.out.println(sum);
System.out.println("----------------------------");
//查找最大的数
int max=a[0];
for (int i = 0; i <a.length ; i++) {
if (a[i]>max){
max = a[i];
}
}
System.out.println(max);
//jdk1.5开始使用强循环
for (int i : a) {
System.out.println(a[i]);
}
printArray(a);
int[] reverse=reverse(a);
printArray(reverse);
// int[] array= new int[];
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.println(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;
}
}
多维数组
二维数组
-
多维数组可看成数组的数组，二维数组就是一个特殊的一维数组其中一个元素都是一个一维数组
-
二维数组
int a[][] = new int[2][5];上面是两行五列的数组
public class Demo04 {
public static void main(String[] args) {
int[][] a=new int[2][5];
int[][][] b=new int[1][2][3];
//多少个一维数组 2
System.out.println(a.length);
//在第一个数组中有几个元素 5
System.out.println(a[0].length);
}
}
Arrays 类
-
数组工具类[Java.util.Arrays](java：数组操作工具类 java.util.Arrays包 主要方法详解 - 云潇洒 - 博客园 (cnblogs.com))
-
由于数组对象本身并没有什么方法可以供调用，但API中提供了一个工具类Arrays使用，可对数据进行一些基本操作
-
查看jdk帮助文档（百度搜）
-
Arrays类中的方法都是static修饰的静态方法，在使用时可以直接使用类名进行调用，而“不用”使用对象来调用（不是不能）
-
常用方法
- 给数组赋值 fill方法
- 对数组排列 sort方法，升序
- 比较数组 equals方法比较数组中元素是否相等
- 查找数组元素 binarySearch方法对排序好的数组进行二分查找
排序算法
借鉴了一个大佬的[博客园链接](十大经典排序算法（动图演示） - 一像素 - 博客园 (cnblogs.com))放这儿了
冒泡排序
-
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
-
冒泡排序是比较出名的排序方法，一共八种
-
两层循环，外层冒泡，里层依次比较
-
时间复杂度O(n2)
-
算法描述
-
比较相邻的元素。如果第一个比第二个大，就交换它们两个；
-
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
-
针对所有的元素重复以上的步骤，除了最后一个；
-
重复步骤1~3，直到排序完成。
-
import java.util.Arrays;
public class Demo04 {
public static void main(String[] args) {
int[] a = {56,26,8,465,4,6584,532};
int[] sort=sort(a);
System.out.println(Arrays.toString(sort));
}
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++) {
if (array[j+1]<array[j]){
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
//flag=ture;
}
}
}return array;
}
}
稀疏数组(数据结构)
-
需求编写五子棋游戏中，有存盘退出和续上盘的功能
-
分析问题：因为该二维数组的很多值都是默认值0，因此记录了很多没有意义的数据
-
解决
- 当一个数组中大部分元素为0，或同一值的数组时，可以使用稀疏数组来保存该数组。
- 稀疏数组的处理方式是：
- 记录数组一共几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
public class Demo05 {public static void main(String[] args) { //二维数组转化为稀疏数组 //1.建立一个二维数组 int[][] chessArr1 = new int[6][7]; chessArr1[0][3] = 22; chessArr1[0][6] = 15; chessArr1[1][1] = 11; chessArr1[1][5] = 17; chessArr1[2][3] = -6; chessArr1[3][5] = 39; chessArr1[4][0] = 91; chessArr1[5][2] = 28; System.out.println("二维数组为："); shuchu(chessArr1); //2.得到有效数据的个数 int sum = 0; //用于记录有效数据个数 for (int i = 0;i < chessArr1.length ;i++ ) { for (int j = 0;j <chessArr1[i].length ;j++ ) { if (chessArr1[i][j] != 0) { sum++; } } } System.out.println("sum=" + sum); //3.创建稀疏数组 int[][] sparseArr = new int[sum+1][3]; //4.将二维数组有效数字存储到稀疏数组 sparseArr[0][0] = 6; sparseArr[0][1] = 7; sparseArr[0][2] = sum; int count = 1; //记录稀疏数组行数 for (int i = 0;i < chessArr1.length ;i++ ) { for (int j = 0;j <chessArr1[i].length ;j++ ) { if (chessArr1[i][j] != 0) { sparseArr[count][0] = i; sparseArr[count][1] = j; sparseArr[count][2] = chessArr1[i][j]; count++; } } } shuchu(sparseArr); //将稀疏数组转化为二维数组 //1.先读取到稀疏数组的第一行,创建二维数组 int row = sparseArr[0][0]; int col = sparseArr[0][1]; int[][] chessArr2 = new int[row][col]; //2.读取稀疏数组后几行 for (int i = 1;i < sparseArr.length ;i++ ) { chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2]; } System.out.println("转换后的二维数组为："); shuchu(chessArr2); } //输出数组 public static void shuchu(int[][] chessArr) { 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(); } } }
二维数组为：
0 0 0 22 0 0 15
0 11 0 0 0 17 0
0 0 0 -6 0 0 0
0 0 0 0 0 39 0
91 0 0 0 0 0 0
0 0 28 0 0 0 0
sum=8
6 7 8
0 3 22
0 6 15
1 1 11
1 5 17
2 3 -6
3 5 39
4 0 91
5 2 28
转换后的二维数组为：
0 0 0 22 0 0 15
0 11 0 0 0 17 0
0 0 0 -6 0 0 0
0 0 0 0 0 39 0
91 0 0 0 0 0 0
0 0 28 0 0 0 0
.out.println();
}
}
}
二维数组为：
0 0 0 22 0 0 15
0 11 0 0 0 17 0
0 0 0 -6 0 0 0
0 0 0 0 0 39 0
91 0 0 0 0 0 0
0 0 28 0 0 0 0
sum=8
6 7 8
0 3 22
0 6 15
1 1 11
1 5 17
2 3 -6
3 5 39
4 0 91
5 2 28
转换后的二维数组为：
0 0 0 22 0 0 15
0 11 0 0 0 17 0
0 0 0 -6 0 0 0
0 0 0 0 0 39 0
91 0 0 0 0 0 0
0 0 28 0 0 0 0
5076
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
