本文详细介绍了Java中的数组，包括数组的声明、创建、内存分析和初始化状态。讨论了静态初始化、动态初始化和默认初始化，并阐述了数组的四个基本特点。此外，还讲解了数组边界、多维数组的使用、`Arrays`类的工具方法，以及冒泡排序和稀疏数组的概念。
记录自己在狂神说java中的学习情况，文章里有自己学习的理解和扩展，新手难免有理解偏差或者错误，恳请大佬指正。
Java数组
数组概述
- 数组是相同类型数据的有序集合（比如都是
int{1,2,3,4,5}，或者都是String{“张三”,“李四”}） - 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
- 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们（下标从0开始）
数组声明创建
首先必须声明数组变量，才能在程序中使用数组，下面是声明数组变量的语法：
dataType[] arrayRefVar; //首选的方法
或
dataType[] arrayRefvar[]; //效果相同，但不是首选的方法
Java语言使用new操作符来创建数组，语法如下：
dataType[] arrayRefVar = new dataType[arraySize];
数组的元素是通过索引访问的，数组索引从0开始。
获取数组长度：
arrays.length
package com.hbq.arrays;
public class defineArray {
// 变量类型 变量的名字 = 变量的值
// 数组类型
public static void main(String[] args) {
int[] nums; //定义数组
int nums2[]; //定义数组2
nums = new int[10]; //这里面可以存放10个int类型的数据
nums2 = new int[5]; //这里面可以存放5个int类型的数据
//给数组元素中赋值
for (int i = 0; i < nums.length; i++) {
nums[i] = i;
}
int sum=0;
//计算数组的和
for (int num : nums) {
sum += num;
}
System.out.println(sum);
}
}
内存分析
Java内存分析
定义一个数组和创建一个数组的内存分配过程如下图所示：
数组的三种初始化状态
-
静态初始化
int[] a = {1,2,3}; Man[] men={new Man(1,1),new Man(2,2)}; -
动态初始化
int[] a = new int[2]; a[0]=1; a[1]=2; -
数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中每个元素也按照实例变量同意的方式被隐式初始化。
package com.hbq.arrays;
public class ArrayInit {
public static void main(String[] args) {
//静态初始化
int[] a = {1, 2, 3, 4, 5, 6, 7}; //初始化后数组长度就固定了，不可改变长度
System.out.println(a[0]);
a[0] = 10;
System.out.println(a[0]);
//动态初始化
int[] b = new int[a[0]];
b[0] = 10;
b[1] = 1;
// b[2]~b[9]都是默认值0
for (int i : b) {
System.out.println(i);
}
}
}
数组的四个基本特点
-
其长度是固定的。数组一旦被创建，它的大小就是不可以改变的。
-
其元素必须是相同类型，不允许出现混合类型。
-
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
-
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
-
相当于： class Array{ public int a0; public int a1; public int a2; ... public int an-1; } 只不过取成员变量的时候使用的是a[0],a[1]这种方式。 -
数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型他是其他对象类型，数组本身还是在堆中的。
数组边界
下标的合法区间：[0,数组.length-1]，如果越界就会报错
public static void main(String[] args){
int[] a=new int[2];
System.out.println(a[2]);//报错ArrayIndexOutOfBoundsException：数组下标越界异常
}
小结：
- 数组是相同数据类型（数据类型可以为任意类型）的有序集合
- 数组也是对象，数组元素相当于对象的成员变量
- 数组长度是确定的，不可变的，如果越界则会出现
ArrayIndexOutOfBoundsException错误
数组使用
package com.hbq.arrays;
public class ArrayUse {
public static void main(String[] args) {
int[] a = new int[10];
// 赋值数组里的所有元素
// idea里a.length.for回车会自动出这个for循环
for (int i = 0; i < a.length; i++) {
a[i] = i;
}
// 输出数组的值
// idea里a.for回车会自动出这个增强for循环
for (int i : a) {
System.out.print(i+" ");
}
printArraySum(a);
int [] tmp=reverseArray(a);
for (int value : tmp) {
System.out.print(value+" ");
}
}
// 作参数传入
public static void printArraySum(int[] array) {
int sum = 0;
for (int value : array) {
sum += value;
}
System.out.println(sum);
}
// 作返回值
public static int[] reverseArray(int[] array) {
int[] tmp = new int[array.length];
for (int i = array.length - 1,j=0; i >= 0; i--,j++) {
tmp[j] = array[i];
}
return tmp;
}
}
多维数组
套娃！！数组的数组。就是数组里每一个元素都是数组。比如二维数组就是一个特殊的一维数组，这个一维数组里每一个元素都是一个一维数组。
//二维数组
int[][] a=new int[2][5] //2行5列的数组
图里展示的是两行两列的数组，其中array[0]和array[1]存储的是两个数组。
多维数组的定义和使用：
package com.hbq.arrays;
public class TwoDArray {
public static void main(String[] args) {
int[][] array = {{1,2,3}, {1,5,3,7}};//每维长度可以不一样
System.out.println(array[0][0]+" "+array[0][1]+" "+array[0][2]);
System.out.println(array[1][0]+" "+array[1][1]+" "+array[1][2]+" "+array[1][3]);
System.out.println("----------------------------------------------------------");
int [][] array2={{1,3,8},{96,8,4,2},{5,7,8,2,7,1,30}};
for(int i=0;i<array2.length;i++){
for (int j=0;j<array2[i].length;j++){
System.out.print(array2[i][j]+" ");
}
System.out.println();
}
}
}
Arrays类
数组的工具类java.util.Arrays
由于数组对象本身并没有什么方法可以提供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
查看JDK帮助文档
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用。（注意是不用而不是不能）
具有以下的常用功能：
- 给数组赋值：通过
fill方法 - 对数组排序：通过
sort方法，按升序 - 比较数组：通过
equals方法比较数组中元素值是否相等 - 查找数组元素：通过
binarySearch方法能对排序数组进行二分查找操作
冒泡排序
冒泡排序是出名的排序算法之一
冒泡代码比较简单，两层循环，外层冒泡轮数，里层依次比较。
时间复杂度为O(n2)
思考：如何优化？
在一次循环没有交换以后，直接结束。
package com.hbq.arrays;
import java.util.Arrays;
public class BubbleSort {
public static void main(String[] args) {
int[] a = {1, 85, 8, 64, 2, 231, -56, 4651, 6};
int[] b = bubble(a);
System.out.println(Arrays.toString(a));//[4651, 231, 85, 64, 8, 6, 2, 1, -56]
System.out.println(Arrays.toString(b));//[4651, 231, 85, 64, 8, 6, 2, 1, -56]
}
public static int[] bubble(int[] a) {
//冒泡排序
//1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
//2.每一次比较，都会产生一个最大或者最小的数字
//3.下一轮则可以少一次排序
//4.依次循环，直到结束
//外层循环，判断走多少次,这里是a.length-1，因为最后一个数没得和数比较了
int temp;
boolean flag;//判断是否一轮下来都没有发生交换
for (int i = 0; i < a.length - 1; i++) {
flag=false;
//内层循环,判断两个数，如果第一个比第二个大，则交换位置
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;
flag=true;
}
}
if (!flag) break;
}
return a;
}
稀疏数组
需求：编写五子棋游戏中，有存盘退出和续上盘的功能
分析问题：因为该二维数组中的很多值默认为0，因此记录了很多没有意义的数据
解决：稀疏数组
当一个数组中大部分元素为0，或者为同一个值时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方式是：
- 记录数组一共几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
如图所示：左边是原始数组，右边是稀疏数组
三元组的信息。第一行6，7，8表示这个矩阵是6X7的，有8个有效值。
第二行开始，就是存储的有效值的行列值。
package com.hbq.arrays;
public class SparseArrays {
public static void main(String[] args) {
// 创建一个6*7数组
int[][] a = {{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}};
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j] + " ");
}
System.out.println();
}
//转化为稀疏数组
int row = a.length, col = a[0].length, var = 0;
//获取有效值的个数
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
if (a[i][j] != 0) var += 1;
}
}
int[][] sparse = new int[var + 1][3];
sparse[0][0] = row;
sparse[0][1] = col;
sparse[0][2] = var;
int count = 1;//计数
// 遍历原数组，将不等于0的数存入稀疏数组
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
if (a[i][j] != 0) {
sparse[count][0] = i;
sparse[count][1] = j;
sparse[count][2] = a[i][j];
count++;
}
}
}
//打印稀疏数组
for (int i = 0; i < sparse.length; i++) {
for (int j = 0; j < 3; j++) {
System.out.print(sparse[i][j] + " ");
}
System.out.println();
}
//根据稀疏数组还原二维数组
int[][] newarray = new int[sparse[0][0]][sparse[0][1]];
for (int i = 1; i <= sparse[0][2]; i++) {
newarray[sparse[i][0]][sparse[i][1]] = sparse[i][2];
}
//打印还原后的数组
for (int i = 0; i < newarray.length; i++) {
for (int j = 0; j < newarray[i].length; j++) {
System.out.print(newarray[i][j] + " ");
}
System.out.println();
}
}
}
扫一扫
2140
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
