【JavaSE】10-数组
10-数组
- ①.什么是数组
- ②.数组的声明与创建
-
- Array内存分析
- 数组的初始化
- ③.数组的基本特点
-
- 数组的边界
- ④.数组的使用
- ⑤.多维数组
- ⑥.Arrays类
-
- 冒泡排序法
- ⑦.稀疏数组
①.什么是数组
定义：数组是相同数据类型的有序集合。它是若干相同类型的数据，按照一定的先后顺序排列组合而成。
每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们。
②.数组的声明与创建
- 首先需要声明，才能使用数组：
dataType[ ] arrayRefVar; //Java声明数组推荐的呀
dataType arrayRefVar[ ]; //效果相同，但不推荐这样的用法- 通过new关键字创建数组
dataType[ ] arrayRefVar = new dataType[ arraySize];数组中的元素是通过索引访问的，数组的索引从0开始。
获取数组长度的语法：arrays.length
Array内存分析
Java中的内存：
- 堆：
存放new的对象和数组
可以被所有线程共享，不会存放别的对象引用- 栈：
存放基本变量类型(包含基本类型的具体数值)
引用对象的变量(会存放引用在堆里边的地址)- 方法区：
可以被所有的线程共享
包含了所有的class和static变量
数组的初始化
三种初始化：
- 静态初始化：
int[ ] a = {1,2,3,5,6};
Man[ ] men = { new Man (1,1),new Man (1,2) }; //引用类型的初始化- 动态初始化：
int[ ] a = new int[10];
a[0] = 10;
a[1] = 20; …- 默认初始化：
数组是引用类型，他的元素相当于类的实例变量，因此数组一旦分配了空间，其中的每个元素也会被按照实例变量同样的方式被隐式初始化。
③.数组的基本特点
- 数组的长度是确定的。一旦被创建，大小不可改变
- 数组的元素必须是相同类型的，不允许出现混合类型。
- 数组中的元素可以是任何的数据类型，包括基本类型和引用类型。
- 数组的变量属于引用类型，数组也可以看成是对象，数组中的每一个元素就相当于数组的成员变量。
因为数组本身就是对象，而Java的对象是保存在堆中的，因此无论数组保存的是原始类型还是其他的对象类型，数组对象本身是在堆中的。
数组的边界
-数组下边的合法区间[0,length - 1],如果越界将会报错。
ArrayIndexOutOfBoundsException : 数组下标越界异常
④.数组的使用
- For-Each循环：
数组可以通过for循环来进行遍历，也可以通过增强的for( : )循环来进行操作- 数组可以作为方法入参
- 数组也可以作为返回值
public class ArrayUse {
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 5}; //定义一个数组，并赋值
int [] reverse = reverse(arrays); // 定义反转数组，用于存储反转后的值
//打印所有元素
for (int i = 0; i < reverse.length; i++) {
System.out.println(reverse[i]);
}
}
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[ ] [ ] array = { {12,13,14} , {22,23,24} ,{32,33,34} , {…} , …}
public class ArrayTwo {
public static void main(String[] args) {
/*
1 , 2 array[0]
3 , 4 array[1]
5 , 6 array[2]
7 , 8 array[3]
*/
int[][] array = {{1,2},{3,4},{5,6},{7,8}};
System.out.println(array[0][1]); //输出 2 {1，2}
System.out.println(array.length); //输出 4{{}，{}，{}，{}}
System.out.println(array[1].length); // 输出 2 {3，4}
//遍历数组元素
for(int i = 0;i < array.length;i++){
for(int j = 0;j < array[i].length;j++){
System.out.println(array[i][j] + " ");
}
}
}
}
⑥.Arrays类
定义：Arrays类是数组的工具类，在java.util.Arrays当中。
public class ClassArrays {
public static void main(String[] args) {
int[] a = {1,34,45,56,67,87,89,56,4,35,34,34242,3,1313};
System.out.println(Arrays.toString(a)); //输出：[1, 34, 45, 56, 67, 87, 89, 56, 4, 35, 34, 34242, 3, 1313]
printArray(a); //输出数组的类也可以自定义。 输出：[1, 34, 45, 56, 67, 87, 89, 56, 4, 35, 34, 34242, 3, 1313]
//与官方文档不同的是，官方文档会返回一个String对象，而自己写的方法暂时没有返回值
//对数组进行排序
Arrays.sort(a);
System.out.println("\n" + Arrays.toString(a)); //输出：[1, 3, 4, 34, 34, 35, 45, 56, 56, 67, 87, 89, 1313, 34242]
//填充数组元素
// Arrays.fill(a,0);
// printArray(a); //输出：[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Arrays.fill(a,2,6,0);
printArray(a); //输出：[1, 3, 0, 0, 0, 0, 45, 56, 56, 67, 87, 89, 1313, 34242]
}
static void printArray(int[] a){
for (int i = 0; i < a.length; i++) {
//检测是否为头一个元素，是则输出括号
if (i == 0) System.out.print("[");
//检测是否为最后一个元素，是则输出最后的元素和反括号
if (i == a.length - 1) System.out.print(a[i] + "]");
//否则输出, 分隔符
else System.out.print(a[i] + ", ");
}
}
}
冒泡排序法
将相邻两个数相比较，如果一方比另一方大则交换位置，依次排序。
public class ArrayBulbble {
public static void main(String[] args) {
//冒泡排序
//1，比较较相邻两个元素的大小，如果第一个数比第二个数大，则交换他们的顺序
//2，每一轮比较都会产生一个最大或者最小数字
//3，下一轮可相应减少一次排序
//4，依次循环，直到结束
int[] a = {34,45,56,5,6,7,8689,7,8972,3,12,3,1,22,3,53,45,46,4,6,45,64,566};
a = sort(a);
System.out.println(Arrays.toString(a));
}
static int[] sort(int[] a){
int temp = 0; //转移数据的临时变量
for (int i = 0; i < a.length - 1; i++) { // 两两比较，遍历时会少一个元素
//比较两个相邻元素，前一个比后一个大的话，交换位置
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;
}
}
}
return a;
}
}
⑦.稀疏数组
需求：编写五子棋游戏中，实现存盘和记录上一盘的功能。
分析问题：因为二维数组中很多值都是0，记录了很多没有意义的数据。
稀疏数组的使用：当一个数组中大部分的元素为0或者为同一个值时，可以用稀疏数组来存储该组数据。
处理方式：
- 记录数组有几行几列，有多少个不同的值。
- 把具有不同值的元素和行列的值记录在一个小规模数组当中，进而压缩程序规模。
public class ArrayZip {
public static void main(String[] args) {
int[][] a = new int[11][11];
a[1][2] = 1;
a[2][3] = 2;
//初始化原始数组
/*
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
*/
//打印原始数据
for (int[] ints : a) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
//转换为稀疏数组保存
//获取有效值的个数
int sum = 0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
if(a[i][j] != 0) sum++;
}
}
System.out.println("有效值个数" + sum);
//创建一个稀疏数组
int[][] a2 = new int[sum + 1][3];
//原数组有几行 几列 几个有效数字
a2[0][0] = a.length;
a2[0][1] = a[0].length;
a2[0][2] = sum;
//遍历二维数组，将非零值存放在稀疏数组中
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++; //用于存放稀疏数组的行数据
a2[count][0] = i; //保存原数组的行信息
a2[count][1] = j; //保存原数组的列信息
a2[count][2] = a[i][j]; //保存原数组的值信息
}
}
}
//检查数据是否存储正确
for (int[] ints : a2) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
//定义还原数组
int[][] a3 = new int[a2[0][0]][a2[0][1]];
//给还原数组赋值
for (int i = 1; i < a2.length; i++) {
a3[a2[i][0]][a2[i][1]] = a2[i][2];
}
//打印还原的数据
for (int[] ints : a3) {
for (int anInt : ints) {
System.out.print(anInt + "\t");
}
System.out.println();
}
}
}