Java数组详解 学习笔记（2021.05.24、05.29）
数组详解
目录
一、数组概述
- 数组是相同类型数据的数据集合。
- 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
- 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标访问他们。
二、数组的声明和创建
-
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
dataType[] arrayRefVar;//首选的方法 dataType arrayRefVar[];//效果一样，但是不是首选，为了让c程序员快速上手Java -
Java语言使用new操作符来创建数组，语法如下：
dataType[] arrayRefVar = new dataType[arraySize]; -
数组的元素是通过索引访问的，数组索引从0开始。
-
获取数组长度：
arrays.length -
demo:
public class DemoCreateAndUse { public static void main(String[] args) { int i ;//声明 整型变量i int[] a;//声明 整形数组变量a，其中是没有空间的 int n = 1;//定义 整型变量(与声明不一样的是有了值) int[] ns = new int[5];//定义 整型数组变量(与声明不一样的是有了值，但这里面的值是空的)(下标 0-4) //(定义完后赋值只能有0~45个空间了) //数组赋值 ns[0] = 1; ns[1] = 2; ns[2] = 3; ns[3] = 4; ns[4] = 5; //ns[5] = 6; 产生数组越界 ns = new int[]{2,2,2,2,2,2};//指向了一个新的空间，前面的就不作数了 //获取数组的值总和 int sum = 0; for (int i1 = 0; i1 < ns.length; i1++) { sum+=ns[i1]; } System.out.println(sum); } }
1. 内存分析：
-
声明array1数组时：堆中没有东西，在栈中就有了一个数组变量array1。
-
在定义或者说创建时（new int[10]时），在堆中开辟了大的空间，空间分成10块，栈中的变量指向了堆，堆中的东西时真正的对象
-
在我们访问array[10]，也就是第11个元素时，由于我们在堆中没有第11块空间，所以会有数组越界
2. 三种初始化
-
静态初始化
int[] a = {1,2,3}; Man[] mans = {new Man(1,1),new Man(2,2)} -
动态初始化
int[] a = new int[2]; a[0] = 1; a[1] = 2; -
默认初始化
数组时引用类型，它的元素相当于类的实例变量，新词数组已经分配空间，其中每个元素也被按照实例变量相同的方式自动初始化。
3. 数组越界及小结
- 数组特点
其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。其元素必须是相同类型,不允许出现混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
三、数组使用
有数组如下：
int[] arrays = {1,2,3,4,5};
1. For-Each循环
for (int array : arrays) {
System.out.print(array);
}
2. 普通循环
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]);
}
3. 数组作方法入参
public static int[] reverse(int[] arrays){//括号内的arrays形参即为在方法中数组入参
int temp = 0;
for (int i = 0; i < arrays.length / 2; i++) {
temp = arrays[i];
arrays[i] = arrays[arrays.length-i-1];
arrays[arrays.length-i-1] = temp;
}
return arrays;
}
4. 数组作返回值
public static int[] reverse(int[] arrays){//在单词reverse前的int[]即使作为返回值的方法
int temp = 0;
for (int i = 0; i < arrays.length / 2; i++) {
temp = arrays[i];
arrays[i] = arrays[arrays.length-i-1];
arrays[arrays.length-i-1] = temp;
}
return arrays;//这里返回数组
}
5. 完整demo
public class DemoArraysUse {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
//用循环打印数组所有元素
for (int array : arrays) {
System.out.print(array);
}
System.out.println("\n================");
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]);
}
System.out.println("\n================");
//算数组元素总和
int sum = 0;
for (int array : arrays) {
sum += array;
}
System.out.print(sum);
System.out.println("\n================");
//求数组中最大值;
int max = arrays[0];
for (int array : arrays) {
if(array > max){
max = array;
}
}
System.out.print(max);
System.out.println("\n================");
//反转数组
int[] ra = reverse(arrays);
for (int i : ra) {
System.out.print(i);
}
System.out.println("\n================");
}
//反转数组
public static int[] reverse(int[] arrays){
int temp = 0;
for (int i = 0; i < arrays.length / 2; i++) {
temp = arrays[i];
arrays[i] = arrays[arrays.length-i-1];
arrays[arrays.length-i-1] = temp;
}
return arrays;
}
}
四、多维数组
多维数组就是数组的数组，比如二维数组就是一个特殊的一维数组，其中每一个元素都是一维数组，三维数组每一个元素都是二维数组，以此类推...
1. 二维数组
int[][] array = {{1,2},{3,4},{4,5}}
/* 3行2列 new int[3][2]
1 2
3 4
4 5
*/
如何使用：
System.out.println(array[0][1]);//输出2
System.out.println(array[2][0]);//输出5
2. demo
public class DemoArrayDimension {
public static void main(String[] args) {
int[][] array = {{1,2},{3,4},{5,6}};
System.out.println(array[0][1]);//输出2
System.out.println(array[2][0]);//输出5
int[][] arrays = new int[3][4];//生成3行四列:0~2行共三行，0~3列共四列
arrays[2][3] = 3;//对第三行第四列赋值
System.out.println(arrays[2][3]);
}
}
五、Arrays类详解
数组的工具类java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。
查看JDK帮助文档可以帮助你更好的学习工具类
Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而"不用"使用对象来调用(注意:是"不用”而不是“不能")
- 具有以下常用功能:
- 给数组赋值:通过fill方法。
- 对数组排序:通过sort方法,按升序。
- 比较数组:通过equals 方法比较数组中元素值是否相等。
- 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。
demo:
import java.util.Arrays;
public class DemoArrayClassUse {
public static void main(String[] args) {
int[] a = {1,95,5,83,3,21,5,94,621,6,9,1,2,5,6,3};
int[] a1 = {1,95,5,83,3,21,5,94,621,6,9,1,2,5,6,3};//最后一个元素变成了31
//直接输出数组看看会怎样
System.out.println(a);
System.out.println("============");
//看看用用Arrays类中的toString会怎样
System.out.println(Arrays.toString(a));
System.out.println("============");
//对数组排个序
Arrays.sort(a);
Arrays.sort(a1);
System.out.println(Arrays.toString(a));
System.out.println("============");
//对比下数组（要顺序和值都一样才是true）
System.out.println(Arrays.equals(a,a1));
System.out.println("============");
//用二分查找数组
int n = Arrays.binarySearch(a,9);
System.out.println(n);//返回值所在位置
System.out.println("============");
}
}
冒泡排序
import java.util.Arrays;
public class DemoBubbleSort {
public static void main(String[] args) {
int[] a = {1,95,5,83,3,21,5,94,621,6,9,1,2,5,6,3};
bubbleSort(a);
System.out.println(Arrays.toString(a));
}
/*
1. 第一层循环，一次循环筛选出一个最大（最小）值所以要筛选n次(n为数组长度)
2. 第二层循环，把数组剩余位置遍历，当前遍历元素比下一个大就交换元素
3. 每次选出一个最大值或最小值下一次大循环就可以不用遍历那个位置
*/
public static void bubbleSort(int[] arrays){
int temp = 0;
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays.length-i-1; j++) {//在第j位时就和第j+1比较，将所有元素比较后就能筛选出本轮最大（最小）值
if (arrays[j]>arrays[j+1]){//如果是大于就是升序，小于就是降序
temp = arrays[j];
arrays[j] = arrays[j+1];//交换元素
arrays[j+1] = temp;
}
}
}
}
}
六、稀疏数组
当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。稀疏数组的处理方式是:
记录数组一共有几行几列，有多少个不同值
把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
demo:
public class DemoXiShuArray {
public static void main(String[] args) {
int[][] a = new int[11][11];//普通数组
a[2][3] = 1;
a[3][4] = 2;
for (int[] ints : a) {//打印普通数组
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
for (int[] ints : xiShuArrays(a)) {//打印稀疏数组
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}
//转换成稀疏矩阵
public static int[][] xiShuArrays(int[][] arrays){
//计算有效值个数
int sum = 0;
for (int[] array : arrays) {
for (int i : array) {
if(i!=0){
sum++;
}
}
}
//创建稀疏数组
int[][] xishu = new int[sum][3];
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){//察觉有效值
xishu[count][0] = i;//第一个值：行
xishu[count][1] = j;//第二个值：列
xishu[count][2] = arrays[i][j];//第二个值：值
count++;
}
}
}
return xishu;
}
}
慢慢来慢慢来
浙公网安备 33010602011771号