JavaSE 数组、多维数组、稀疏数组
1 数组基础
1.1 数组定义
- 数组是相同类型数据的有序组合。
- 每个数据称为一个数组元素，每个数据元素可以通过一个下标来访问。
- 数组下标从0开始，到n-1结束。
1.2 数组的声明与初始化
数组的声明
-
使用前必须声明。语法如下：
dataType[] arrayRefVar;//首选 //or dataType arrayRefVar[];//效果相同，但不是首选 -
Java语言使用new操作符来创建，语法如下：
dataType[] arayRefVar = new dataType[arraySize]; //例： int[] nums = new int[10]; //声明一个数组并创建 -
数组一旦创建，不可改变长度。
-
获取数组长度可以使用Arrays.length()方法。
数组的初始化
-
静态初始化
int[] a = {1,2,3}; -
动态初始化（包含默认初始化）
int[] b = new int[10];//此时数组中元素均为默认值 b[0] = 10; -
数组默认初始化
数组是引用类型，它的元素相当于类的实例变量，一经分配空间，其中每个元素也按照实例变量同样的方式被隐式初始化。
1.3 数组的使用
话不多说，直接展示代码：
package com.targetu.array;
public class ArrayDemo01 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5,6};
//原数组打印
printArray(a);
//计算所有元素的和
int sum = 0;
for (int i = 0; i<a.length; i++){
sum += a[i];
}
System.out.println("sum: " +sum);
//查找最大元素
int max = a[0];
for (int i = 0; i < a.length; i++) {
if (a[i] > max){
max = a[i];
}
}
System.out.println("max: " +max);
//反转数组并打印
printArray(reverse(a));
}
//打印数组
public static void printArray(int[] arrays){
for (int array : arrays) {
System.out.print(array + " ");
}
System.out.println();
}
//反转数组
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;
}
}
//运行结果：
//1 2 3 4 5 6
//sum: 21
//max: 6
//6 5 4 3 2 1
2 Java内存说明
-
Java内存：
类型 功能 堆 (1)存放所有new出来的对象和数组
(2)可以被所有的线程共享，不会存放别的对象引用栈 （1）存放基本变量类型（包含这个基本类型的基本数值）
（2）存放引用对象的变量（存放引用在堆里面的具体地址）
(3)数组保存在堆中方法区 （1）可以被所有的线程共享
（2）包含了所有的class和static变量 -
数组声明使用过程流程图展示：（使用的是一款在线画图工具processOn，非常nice！）
3 Java重点补充
3.1 二维数组
-
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素是一个一维数组。
-
二维数组举例：
int a[][] = new int[3][2];此二维数组a可以看成一个三行两列的数组。
图示：
-
二维数组使用
package com.targetu.array; public class ArrayDemo02 { public static void main(String[] args) { //创建2*3的二维数组 int[][] array = {{1,1},{2,2},{3,3}}; //打印数组元素 for (int i = 0; i < array.length; i++) { for (int j = 0; j < array[i].length; j++){ System.out.print(array[i][j]+" "); } System.out.println(); } } } //运行结果： //1 1 //2 2 //3 3
3.2 Arrays类
-
数组的工具类java.util.Arrays
-
类中方法均为static开头，故可直接调用
-
案例展示
package com.targetu.array; //此例中展示打印、排序、填充的使用 import java.util.Arrays; public class ArrayDemo03 { public static void main(String[] args) { int[] a = {1,1,2,33,21,44,9,10}; //打印数组元素Arrays.toString() System.out.println(Arrays.toString(a)); //数组排序：升序 Arrays.sort(a); System.out.println(Arrays.toString(a)); //数组填充 Arrays.fill(a,2,4,0); System.out.println(Arrays.toString(a)); } }
3.3 冒泡排序
注意本例中对冒泡排序的优化！
package com.targetu.array;
import java.util.Arrays;
public class ArrayDemo04 {
public static void main(String[] args) {
int[] a = {1,2,3,5,2,9,4,7};
System.out.println(Arrays.toString(mysort(a)));
}
public static int[] mysort(int[] array){
//外层循环，判断要走多少次
int temp = 0;
for (int i = 0; i < array.length; i++) {
boolean flag = false; //通过flag标示,若后续数组元素已排好序，直接退出循环
//内层循环，比较前后两个数，若前者大于后者，交换顺序
for (int j = 0; j < array.length-1-i; j++){
if (array[j] > array[j+1]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
if (!flag){
break;
}
}
return array;
}
}
//运行结果：
//[1, 2, 2, 3, 4, 5, 7, 9]
注：冒泡排序是最基础的排序，其中的优化算法需重点学习。
4 稀疏数组(重点在案例部分！)
-
稀疏数组是一种数据结构。
-
若数据量很小，其他值则均为默认值0，会造成资源浪费。
-
稀疏数组处理方式：（使用三元组的方式）
- 记录数组一共有几行几列，有多少个不同值。
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序规模。
-
案例展示（共包含三个步骤）
- 原始数组的创建与输出
- 原始数组转换为稀疏数组并输出
- 稀疏数组转换为原始数组并输出
package com.targetu.array;
public class ArrayDemo05 {
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;
//2. 输出原始数组
System.out.println("原始数组为：");
for (int[] ints : array1) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
System.out.println("=========================================");
// 二、原始数组转换为稀疏数组
//1. 首先应该获取有效值的个数
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);
//2. 创建一个稀疏数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//3. 遍历二维数组，将非零的值，存放到稀疏数组中
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];
}
}
}
//4. 输出稀疏数组
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]);
}
System.out.println("=========================================");
// 三、稀疏数组转换为原始数组
//1. 读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//2. 给其中的元素赋值(注意从i = 1 开始读取)
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();
}
System.out.println("=========================================");
}
}
//运行结果：
/*
原始数组为：
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
=========================================
有效值个数为：2
稀疏数组为：
11 11 2
1 2 1
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
=========================================
Process finished with exit code 0
*/
注：
- 稀疏数组中第一行存储的是原始数组中行、列数及元素个数信息。
- 读取稀疏数组时，从第二行开始读取。（即从i = 1开始）
174
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
