7.Java数组
2021/7/18 22:34:51
本文主要是介绍7.Java数组，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
一、数组概念（最简单的数据结构）
- 数组是相同类型数据的有序集合。
- 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
- 其中每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。
二、数组声明创建
-
首先必须声明数组变量，才能在程序中使用数组。语法：
变量类型[] 变量名; //首选的方法 变量类型 变量名[]; //效果相同，但不是首选
-
Java 使用 new 操作符来创建数组。语法：
数据类型[] 变量名 = new 数据类型[数组大小];
- 数组的元素是通过索引访问的，数组索引从 0 开始。
- 获取数组长度：
arrays.length
public class Array {
public static void main(String[] args) {
//变量类型（数组类型） 变量名 = 值;
//1.定义数组
int[] arra1; // Java 风格
int arra2[]; // C / C++ 语言风格
//2.创建数组（这里面可以存放 10 个 int 类型的数字）
//假如没有数组要定义 10 个变量，有了数组通过 1 个变量就可以村 10 个数字了
arra1 = new int[10];
// int[] arra1 = new int[10];
//3.给数组元素中赋值
arra1[0] = 1;
arra1[1] = 1;
arra1[2] = 1;
arra1[3] = 1;
System.out.println(arra1[0]);
System.out.println(arra1[4]); //0，默认值
//计算所有元素的和
int sum = 0;
for (int i = 0; i < arra1.length; i++) {
sum += arra1[i];
}
System.out.println("所有元素的和：" + sum);
}
}
三、内存分析
1.Java 内存分析：
-
写代码画图分析内存：
public class MemoryAnalysis_ArrayIndexOutOfBoundsException { public static void main(String[] args) { //1.定义数组 int[] array = null; // 2.创建数组 array = new int[10]; // 3.给数组元素中赋值 array[0] = 1; array[1] = 1; array[2] = 1; array[3] = 1; System.out.println(array[10]); //ArrayIndexOutOfBoundsException } }
- 声明的时候数组并不存在，通过 new 关键字创建的时候，数组才产生，给里面赋值的时候才有值，没有赋值的话就是默认元素
方法在栈，实例在堆
2.三种初始化
-
静态初始化
int[] array = {1, 2, 3}; Man[] mans = {new Man(1, 1), new Man(2, 2)}; -
动态初始化
int[] array = new int[2]; array[0] = 1; array[1] = 2;
-
数组的默认初始化
- 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
public class ThreeKindsOfInitialization {
public static void main(String[] args) {
//1.静态初始化：创建 + 赋值
int[] array = {1, 2, 3};
System.out.println(array[0]); //1
//引用类型数组
Man[] mans = {new Man(), new Man()};
//2.动态初始化：包含默认初始化
int[] array2 = new int[3];
array2[0] = 1;
array2[1] = 2;
System.out.println(array2[1]); //2
//3.数组的默认初始化
System.out.println(array2[2]); //0
}
}
class Man{}
3.数组的四个基本特点
- 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
- 其元素必须是相同类型，不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象， Java 中对象是在堆中的，因此数组无论保存原始类型还是其它对象类型，数组对象本身是在堆中的。
4.数组边界
-
下标的合法区间： [0, length - 1] ，如果越界就会报错：
public static void main(String[] args) { int[] array = new int[2]; System.out.println(array[2]); } -
ArrayIndexOutOfBoundsException ：数组下标越界异常！
5.小结
- 数组是相同数据类型（数据类型可以为任意类型）的有序集合
- 数组也是对象。数组元素相当于对象的成员变量
- 数组长度是确定的，不可变的。如果越界，则报： ArrayIndexOutOfBoundsException
四、数组使用
1.普通的for循环（使用最多）
- 要从数组中取出一些数据或下标进行操作
public class Fori_Exer {
public static void main(String[] args) {
int[] arrays = {1, 2, 3};
//打印全部的数组元素
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
System.out.println();
//计算所有元素的和
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
sum += arrays[i];
}
System.out.println(sum);
System.out.println();
//查找最大元素
int max = arrays[0];
for (int i = 1; i < arrays.length; i++) {
if (arrays[i] > max){
max = arrays[i];
}
}
System.out.println(max);
}
}
2.foreach循环
- 用来打印结果
public class ForEach_Exer {
public static void main(String[] args) {
int[] arrays = {1, 2, 3};
//增强型for循环，JDK1.5，没有下标，适合打印输出
for (int array : arrays) {
System.out.println(array);
}
}
}
3.数组作方法入参
- 可以对数组进行一些操作
public class ArrayAsMethodInputParameter_Exer {
public static void main(String[] args) {
int[] arrays = {1, 2, 3};
printArray(arrays);
}
//打印全部的数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
}
}
4.数组作返回值
- 把数组进行修改，然后返回新的数组
public class ArrayAsTheReturnValue_Exer {
public static void main(String[] args) {
int[] arrays = {1, 2, 3};
int[] array = reverseArray(arrays);
for (int i : array) {
System.out.println(i);
}
}
//反转数组
public static int[] reverseArray(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 arrays[][] = new int[2][5];
- 解析：二维数组 arrays 可以看成一个两行五列的数组
-
思考：多维数组的使用？
- Java 并不会使用多维数组进行操作，面向对象编程，会把一个东西变成一个对象
public class TwoDimensionalArray_Exer {
public static void main(String[] args) {
/*
[2][3]
1, 2, 3 arrays[0]
4, 5 arrays[1]
*/
int[][] arrays = {{1, 2, 3}, {4, 5}};
System.out.println(arrays[0]); //[I@1540e19d 对象，数组
for (int i : arrays[0]) {
System.out.print(i); //123
}
System.out.println();
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
System.out.print(arrays[i][j]); //12345
}
}
}
}
六、Arrays 类（专门操作数组的类）
- 数组的工具类
java.util.Arrays - 由于数组对象本身并没有什么方法可以供我们调用，但 API 中提供了一个工具类 Arrays 供我们使用，从而可以对数据对象进行一些基本的操作。
- 查看 JDK 帮助文档
- Arrays 类中的方法都是 static 修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用（注意：是“不用”，而不是“不能”）
- 具有以下常用功能：
- 给数组赋值：通过 fill() 方法，数组填充。
- 对数组排序：通过 sort() 方法，按升序。
- 比较数组：通过 equals() 方法，比较数组中元素值是否相等。
- 查找数组元素：通过 binarySearch() 方法，能对排序好的数组进行二分查找法操作。
public class Arrays_Exer {
public static void main(String[] args) {
int[] a = {7, 2, 4, 1, 0, 6};
//打印数组元素
System.out.println(Arrays.toString(a)); //[7, 2, 4, 1, 0, 6]
//自定义 打印数组元素
printArray(a); //[7, 2, 4, 1, 0, 6]
//对数组排序
Arrays.sort(a);
System.out.println(Arrays.toString(a)); //[0, 1, 2, 4, 6, 7]
//给数组赋值：数组填充
Arrays.fill(a, 0);
System.out.println(Arrays.toString(a)); //[0, 0, 0, 0, 0, 0]
Arrays.fill(a, 2, 4, 6); // 2~4 之间被 6 填充
System.out.println(Arrays.toString(a)); //[0, 0, 6, 6, 0, 0]
}
//打印数组元素
//重复造轮子：别人做好的事，不建议重新做，但是要了解原理
public static void printArray(int[] arrays){
System.out.print("[");
for (int i = 0; i < arrays.length; i++) {
if (i != arrays.length - 1) {
System.out.print(arrays[i] + ", ");
} else {
System.out.print(arrays[i]);
}
}
System.out.println("]");
}
}
七、冒泡排序
-
冒泡排序无疑是最为出名的排序算法之一，总共有八大排序
-
冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较，人尽皆知
public class BubbleSort { public static void main(String[] args) { /* 冒泡排序 1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置 2.每一次比较，都会产生出一个最大或最小的数字 3.下一轮则可以少一次排序 4.依次循环，直到结束 */ int[] a = {7, 2, 4, 1, 0, 6}; System.out.println(Arrays.toString(bubbleSort(a))); } public static int[] bubbleSort(int[] arrays){ //临时变量 int temp = 0; //外层循环，判断要走多少次 for (int i = 0; i < arrays.length - 1; i++) { //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置 for (int j = 0; j < arrays.length - 1 - i; j++) { if (arrays[j + 1] < arrays[j]) { temp = arrays[j]; arrays[j] = arrays[j + 1]; arrays[j + 1] = temp; } } } return arrays; } } -
我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n2)
-
思考：如何优化？
public class BubbleSort_Optimization { public static void main(String[] args) { /* 冒泡排序 1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置 2.每一次比较，都会产生出一个最大或最小的数字 3.下一轮则可以少一次排序 4.依次循环，直到结束 */ int[] a = {7, 2, 4, 1, 0, 6}; System.out.println(Arrays.toString(bubbleSort(a))); } public static int[] bubbleSort(int[] arrays){ //临时变量 int temp = 0; //外层循环，判断要走多少次 for (int i = 0; i < arrays.length - 1; i++) { //通过 flag 标识位减少没有意义的比较，省略最后一轮的比较 boolean flag = false; //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置 for (int j = 0; j < arrays.length - 1 - i; j++) { if (arrays[j + 1] < arrays[j]) { temp = arrays[j]; arrays[j] = arrays[j + 1]; arrays[j + 1] = temp; flag = true; } } //没有进行比较，说明已经结束，跳出循环，最后一轮就不用走了，少走一轮 if (flag == false) { break; } } return arrays; } }
八、稀疏数组
1.稀疏数组
-
简单的数据结构，用来压缩数组，便于保存，大大减少空间储存量
-
需求：编写五子棋游戏中，有存盘和续上盘的功能。
-
分析问题：因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据。
-
解决：稀疏数组（压缩算法）
-
2.稀疏数组介绍
-
当一个数组中大部分元素为 0 ，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
-
稀疏数组的处理方式是：
- 记录数组一共有几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模（压缩：在最初的时候可以节省空间）
-
如下图：左边是原始数组，右边是稀疏数组
public class SparseArray {
public static void main(String[] args) {
/*
0 0 0 0 0 0 0 0 0 0 0 ==> 行 列 值
0 0 1 0 0 0 0 0 0 0 0 11 11 2
0 0 0 2 0 0 0 0 0 0 0 1 2 1
0 0 0 0 0 0 0 0 0 0 0 2 3 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
*/
//1.创建一个二维数组 11 * 11， 0：没有棋子，1：黑棋， 2：白棋
int[][] arrays = new int[11][11];
// Arrays.fill(arrays, 0);
arrays[1][2] = 1;
arrays[2][3] = 2;
//输出原始的数组
for (int[] array : arrays) {
for (int i : array) {
System.out.print(i + " ");
}
System.out.println();
}
System.out.println();
//转换为稀疏数组
//1.获取有效值个数
int sum = 0;
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[0].length; j++) {
if (arrays[i][j] != 0) {
sum ++;
}
}
}
System.out.println("行\t" + "列\t" + "值");
//2.创建一个稀疏数组的数组
int[][] arrays2 = new int[sum + 1][3]; //固定的 3 列：行、列、值
arrays2[0][0] = arrays.length;
arrays2[0][1] = arrays[0].length;
arrays2[0][2] = sum;
//3.遍历二维数组，将非 0 的值，存放到稀疏数组中
int count = 0; //计数
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
if (arrays[i][j] != 0) {
count ++;
arrays2[count][0] = i;
arrays2[count][1] = j;
arrays2[count][2] = arrays[i][j];
}
}
}
//输出稀疏数组
for (int[] array2 : arrays2) {
for (int i2 : array2) {
System.out.print(i2 + "\t");
}
System.out.println();
}
System.out.println();
//还原稀疏数组：根据稀疏数组重新构建一个数组
//1.读取稀疏数组的值
int[][] arrays3 = new int[arrays2[0][0]][arrays2[0][1]];
//2.给其中的元素还原它的值
for (int i = 1; i < arrays2.length; i++) {
arrays3[arrays2[i][0]][arrays2[i][1]] = arrays2[i][2];
}
//3.打印还原
for (int[] array3 : arrays3) {
for (int i3 : array3) {
System.out.print(i3 + " ");
}
System.out.println();
}
}
}
- 总结：稀疏数组，记录有效的坐标，记录原始坐标的大小以及它的有效值，记录每一个值的坐标，变成一个新的数组
这篇关于7.Java数组的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-12-26大厂数据结构与算法教程：入门级详解
- 2024-12-26大厂算法与数据结构教程：新手入门指南
- 2024-12-26Python编程入门指南
- 2024-12-26数据结构高级教程：新手入门及初级提升指南
- 2024-12-26并查集入门教程：从零开始学会并查集
- 2024-12-26大厂数据结构与算法入门指南
- 2024-12-26大厂算法与数据结构入门教程
- 2024-12-26二叉树入门教程：轻松掌握基础概念与操作
- 2024-12-26初学者指南：轻松掌握链表
- 2024-12-26平衡树入门教程：轻松理解与应用
