Java-05数组
-
多写（代码），多写（笔记），多写（文章）
-
多练（交流），多练（思维），多练（技能）
-
多分享（知识），多分享（怎么了），多分享（为什么）
-
最重要（坚持）
-
每个牛B人物背后都有一段苦B的岁月，只要像傻B一样坚持，终将牛B！
1. 数组概述
数组的定义：
- 数组是相同类型数据的有序集合
- 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
- 每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问，且下标是从0开始
2. 数组声明创建
2.1 声明数组的语法：
dataType[] arrayRefVar; // 首选方法，推荐使用
dataType arrayRefVar[]; // 效果相同，但不推荐
例子：
int[] numbers;
int numbers[];
2.2 Java 语言使用new操作符（关键字）来创建数组，语法如下：
dataType[] arrayRefVar = new dataType[arraySize];
例子：
int[] numbers = new int[5];
2.3 获取数组的长度
arrayRefVar.length;
例子：
numbers.length;
2.4 数组初始化
2.4.1 静态初始化
int[] numbers = {1, 2, 3, 4, 5};
Person[] person = {new Person(), new Person(), new Person()}
2.4.2 动态初始化：包含默认初始化
int[] numbers = new int[5];
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[3] = 4;
numbers[4] = 5;
2.5 数组的四个基本特点
- 其长度是确定的，数组一旦被创建，它的大小就是不可以被改变的
- 其元素必须是相同类型，不允许出现混合类型
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型
- 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其它对象类型，数组对象本身就是在堆中
2.6 数组边界
下标的合法区间：[0, length - 1]，如果越界就会抛出异常：
public static void main(String[] args) {
int[] numbers = new int[2];
// 会抛出ArrayIndexOutOfBoundsException：数组下标越界异常
System.out.println(numbers[2]);
}
3. 数组使用
3.1 For-Each 循环
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5};
// 普通for 循环
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
System.out.println("==========华丽的分割线==========");
// 增强for 循环（For-Each 循环）
for (int number : numbers) {
System.out.println(number);
}
}
3.2 数组作为方法入参
public static void printArrays(int[] arrays) {
for (int number : arrays) {
System.out.print(number + " ");
}
}
3.3 数组作为返回值
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5};
for (int number : reverseArrays(numbers)) {
System.out.print(number + " ");
}
}
public static int[] reverseArrays(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;
}
4. 多维数组
定义：多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组
二维数组：
// 此二维数组可以看成是一个两行五列的表格
int numbers[][] = new int[2][5];
二维数组的使用：
/* 定义了一个二维数组，可以看成是一个三行两列的表格
* 第一行：1, 2
* 第二行：3, 4
* 第三行：5, 6
*/
int[][] numbers = {{1, 2}, {3, 4}, {5, 6}};
// 通过 for 循环来取值
for (int i = 0; i < numbers.length; i++) {
for (int j = 0; j < numbers[i].length; j++) {
System.out.println("第" + (i + 1) + "行" + "第" + (j + 1) + "列的值为：" + numbers[i][j] + " ");
}
}
5. Arrays 类
- 此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂
- 除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException
- Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而"不用"使用对象来调用（注意：是"不用"，而不是"不能"）
具有以下常用功能：
- 给数组赋值：通过fill 方法
- 给数组排序：通过sort 方法，升序
- 比较数组：通过equals 方法比较数组中元素值是否相等
- 查找数组元素：通过binarySearch 方法能对排序好的数组进行二分查找法操作
public static void main(String[] args) {
int[] numbers = {2, 6, 122, 63321, 1, -4, 33, 1};
int[] temps = {2, 6, 122, 63321, 1, -4, 33, 100};
// 打印数组中的每个元素的值
System.out.println(Arrays.toString(numbers)); // [2, 6, 122, 63321, 1, -4, 33, 1]
// 对数组中的元素进行升序排序
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers)); // [-4, 1, 1, 2, 6, 33, 122, 63321]
// 比较两个数组中的值是否相等
System.out.println(Arrays.equals(numbers, temps)); // false
// 对数组中元素的值进行赋值
Arrays.fill(numbers, 0);
System.out.println(Arrays.toString(numbers)); // [0, 0, 0, 0, 0, 0, 0, 0]
}
冒泡排序例子：
- 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法
- 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成
- 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”
冒泡排序的原理：
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个
- 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数
- 针对所有的元素重复以上的步骤，除了最后一个
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
public class BubbleSort {
public static void main(String[] args) {
int[] numbers = {2, 6, 122, 63321, 1, -4, 33, 1};
System.out.println(Arrays.toString(bubbleSort(numbers)));
}
/**
* 冒泡排序
* @param arrays 排序之前的int类型数组
* @return 排序之后的int类型数组
*/
public static int[] bubbleSort(int[] arrays) {
for (int i = 0; i < arrays.length - 1; i++) {
for (int j = 0; j < arrays.length - 1 - i; j++) {
if (arrays[j] > arrays[j + 1]) {
int temp = arrays[j];
arrays[j] = arrays[j + 1];
arrays[j + 1] = temp;
}
}
}
return arrays;
}
}
6. 稀疏数组
- 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
- 稀疏数组的处理方式是:记录数组一共有几行几列，有多少个不同值；把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
如下图，左边是原始数组，右边是稀疏数组
/**
* 稀疏数组
* @author Li.Xiangcheng
* @date 2021-06-09
*/
public class SparseArray {
public static void main(String[] args) {
int[][] originalArray = printOriginalArray();
int[][] sparseArray = getSparseArray(originalArray);
getOriginalArrayBySparseArray(sparseArray);
}
/**
* 创建一个二维原始数组，大小为：11*11，0 没有棋子；1 黑棋；2 白棋；
* @return 维原始数组
*/
public static int[][] printOriginalArray() {
int[][] originalArray = new int[11][11];
originalArray[1][2] = 1;
originalArray[2][3] = 2;
System.out.println("====================原始数组====================");
for (int[] row : originalArray) {
for (int column : row) {
System.out.print(column + "\t");
}
System.out.println();
}
System.out.println("====================原始数组====================");
return originalArray;
}
/**
* 获取一个关于参数二维数组的稀疏数组
* @param arrays 二维数组
* @return 稀疏数组
*/
public static int[][] getSparseArray(int[][] arrays) {
int cellCount = 0;
int rowCount = 0;
int sum = 0;
// 获取二维数组中的有效数个数
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
if (arrays[i][j] != 0) {
sum++;
}
cellCount++;
}
rowCount++;
}
System.out.println("原始数组的行数为：" + rowCount);
System.out.println("原始数组的列数为：" + (cellCount / rowCount));
System.out.println("原始数组的有效值个数为：" + sum);
/*
* 稀疏数组的格式：
* 第一行记录一共有几行几列，有多少个不同值
* 第二行往后记录在某行、某列、具体的值
*/
int[][] sparseArray = new int[sum + 1][3];
sparseArray[0][0] = rowCount;
sparseArray[0][1] = (cellCount / rowCount);
sparseArray[0][2] = sum;
// 遍历二维数组中非0的值填充到稀疏数组
int nextRowCount = 0;
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
if (arrays[i][j] != 0) {
nextRowCount++;
sparseArray[nextRowCount][0] = i;
sparseArray[nextRowCount][1] = j;
sparseArray[nextRowCount][2] = arrays[i][j];
}
}
}
System.out.println("====================稀疏数组====================");
for (int[] row : sparseArray) {
for (int column : row) {
System.out.print(column + "\t");
}
System.out.println();
}
System.out.println("====================稀疏数组====================");
return sparseArray;
}
/**
* 通过稀疏数组还原二维数组
* @param sparseArray 稀疏数组
*/
public static void getOriginalArrayBySparseArray(int[][] sparseArray) {
int[][] originalArrayBySparseArray = new int[sparseArray[0][0]][sparseArray[0][1]];
// 还原稀疏数组
for (int i = 1; i < sparseArray.length; i++) {
originalArrayBySparseArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
}
System.out.println("====================还原后的数组====================");
for (int[] row : originalArrayBySparseArray) {
for (int column : row) {
System.out.print(column + "\t");
}
System.out.println();
}
System.out.println("====================还原后的数组====================");
}
}
本文来自博客园，作者：爱Ni说不出口，转载请注明原文链接：https://www.cnblogs.com/ArtherLee/p/14867426.html
浙公网安备 33010602011771号