05--Java 数组

最新推荐文章于 2024-07-29 14:22:26 发布

决战数据开发

最新推荐文章于 2024-07-29 14:22:26 发布

阅读量657

点赞数 34

分类专栏： JavaSE 文章标签： java 排序算法开发语言

本文链接：https://blog.csdn.net/m0_74018236/article/details/136734889

版权

JavaSE 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

系列文章专栏

JavaSE自学全路线

前言

本笔记记录了一维数组、多维数组的声明及使用过程，补充了数组运算中的一些常见算法，包括赋值、查找及排序算法，其中重点掌握冒泡排序的方法，最后拓展了Arrays类工具的部分代码。

一、数组的基本介绍

概念：多个相同类型数据按一定顺序排列的集合，包括数组名、元素、索引；

特点：数组属于引用类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型；数组的长度一旦确定不能修改；有序排列

二、一维数组

2.1 声明和初始化

声明：类型[] 数组名 int[] arr1; (或者是int arr1[];)
初始化
静态初始化：初始化和元素的赋值同时进行 arr1 = new int[] {1,2,3,4};
动态初始化：初始化和元素的赋值分开进行 arr1 = new int[5];
声明+初始化：int[] arr1 = new int[] {1,2,3}; 推荐
可简写：int[] arr1 = {1,2,3,5,4};

2.2 引用

引用方式：通过角标的方式调用 arr1[0]
注意：数组的角标(或索引)从0开始的，到数组的长度-1结束；如果数组超过角标会通过编译，运行失败
补充：获取数组的长度 arr1.length

2.3 遍历

for 循环访问数组索引

public class Main {
    public static void main(String[] args) {
        int[] arr1 = { 1, 4, 9, 16, 25 };
        for (int i=0; i<arr1.length; i++) {
            int n = arr1[i];
            System.out.println(n);
        }
    }
}

for each 循环迭代数组元素

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int n : ns) {
            System.out.println(n);
        }
    }
}

2.4 元素的默认初始化值

整形：0
浮点型：0.0
字符型：0或’\u0000’，而非’0’
Boolean型：false
引用数据类型：null

三、多维数组

3.1 声明和初始化

声明：类型[] 数组名 int[][] arr1; (或者是int[] arr1[];、int arr1[][];)
初始化
静态初始化：初始化和元素的赋值同时进行 arr1 = new int[][] {{1,2,3},{4,5,6},{7,8,9}};
动态初始化1：初始化和元素的赋值分开进行 arr1 = new int[3][3];
动态初始化2： arr1 = new int[3][];
声明+初始化：int[][] arr1 = new int[][] {{1,2,3},{4,5,6},{7,8,9}}; 推荐
可简写：int[][] arr1 = {{1,2,3},{4,5,6},{7,8,9}};

3.2 引用

引用方式：角标调用 arr1[1][0]
注意：如果初始化方式为 int[][] arr1 = new int[3][];，需要进一步定义数组arr1[1] = new int[2];，否则arr1[1][0]调用会报错
补充：获取数组的长度 arr1.length、arr1[1].length

3.3 遍历

public class HelloWorld {
    public static void main(String []args) {
  	int[][] arr1 = {{1,2,3},{4,5,6,7},{8,9}};
  	for(int i = 0;i < arr1.length;i++){
   		for(int j = 0;j < arr1[i].length;j++){
   		System.out.print(arr1[i][j] + " ");
   		}
   		System.out.println();
  	}
    }
}

3.4 元素的默认初始化值

前提：二维数组元素区分：外层数组的元素、内层数组的元素，例如 int arr1 = new int[4][3];
- 外层元素：arr1[0];、arr1[1]等
- 内层元素：arr1[0][0];、arr1[1][2]等
对于初始化方式 int arr1 = new int[4][3];
- 外层元素初始化值：地址值
- 内层元素初始化值：同一维数组初始化情况
对于初始化方式 int arr1 = new int[4][];
- 外层元素初始化值：null
- 内层元素初始化值：不能调用，否则报错 (要先定义内层元素再调用)

四、常见算法

4.1 数组赋值(杨辉三角、回形数)和复制

杨辉三角

public class HelloWorld {
    public static void main(String []args) {
  	int[][] arr = new int[10][];
  	// 赋值
  	for(int i = 0;i < arr.length;i++){
   		arr[i] = new int[i+1];
   		arr[i][0] = arr[i][i] = 1;   //首末元素
   		if(i > 1){
    			for(int j = 1;j < arr[i].length-1;j++){
     				arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
    			}
   		}
  	}
  	// 遍历
  	for(int a = 0; a < arr.length;a++){
   		for(int b = 0;b < arr[a].length;b++){
    			System.out.print(arr[a][b]+" ");
   		}
   		System.out.println();
  	}
    }
}

回形数方阵

/* 
 * 回形数方阵：
 * 输入整数，则以该数字为矩阵的大小，把 1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中
 * 输入数字2，则程序输出：
 * 1 2 
 * 4 3 
 * 输入数字 3，则程序输出：
 * 1 2 3 
 * 8 9 4 
 * 7 6 5 
 * 输入数字 4，则程序输出： 
 * 1   2   3   4
 * 12  13  14  5 
 * 11  16  15  6 
 * 10  9   8   7
 */
public class ArrayTest {
   public static void main(String[] args) {
  	int len = 5;
  	int[][] arr = new int[len][len];
  	int s = len * len;
  	//k = 1:向右 k = 2:向下 k = 3:向左 k = 4:向上
  	int k = 1;
  	int i = 0, j = 0;
  	for (int m = 1; m <= s; m++) {
   		if (k == 1) {
    			if (j < len && arr[i][j] == 0) {
     				arr[i][j++] = m;
    			} else {
     				k = 2;
     				i++;
     				j--;
     				m--;
    			}
   		} else if (k == 2) {
    			if (i < len && arr[i][j] == 0) {
     				arr[i++][j] = m;
    			} else {
     				k = 3;
     				i--;
     				j--;
     				m--;
    			}
   		} else if (k == 3) {
    			if (j >= 0 && arr[i][j] == 0) {
     				arr[i][j--] = m;
    			} else {
     				k = 4;
     				i--;
     				j++;
     				m--;
    			}
   		} else if (k == 4) {
   			if (i >= 0 && arr[i][j] == 0) {
     				arr[i--][j] = m;
    			} else {
     				k = 1;
    				i++;
     				j++;
     				m--;
    			}
   		}
  	}
 	// 遍历
  	for (int m = 0; m < arr.length; m++) {
   		for (int n = 0; n < arr[m].length; n++) {
    			System.out.print(arr[m][n] + "\t");
   		}
   		System.out.println();
  	}
 }
}

赋值和复制的区别
- 赋值：地址值相同，都指向了堆空间的唯一的一个数组实体，修改任意一个的元素，另一个相应发生改变
- 复制：堆空间新生成了一个数组实体，两者元素改变互不影响

public class ArrayTest {
    public static void main(String []args) {
  	int[] array1,array2,array3;
  	array1 = new int[] {2,3,5,7,11,13,17,19};
  	for(int i = 0;i < array1.length;i++){
   		System.out.print(array1[i] + " ");
  	}
  	System.out.println();   //显示array1的原始数据，输出2,3,5,7,11,13,17,19
  
  	// 数组复制，改变复制后数组的某些元素，原数组无变化
  	array3 = new int[array1.length];
  	for(int i = 0;i < array3.length;i++){
   		array3[i] = array1[i];
   		System.out.print(array3[i] + " ");
  	}
  	System.out.println(); 
  	array3[3] = 100;
  	for(int i = 0;i < array3.length;i++){
   		System.out.print(array3[i] + " ");
  	}
  	System.out.println(); 
  	for(int i = 0;i < array1.length;i++){
   		System.out.print(array1[i] + " ");
  	}
  	System.out.println(); 
  
  	// 数组直接赋值，指向同一个数组，改变赋值后数组元素，原数组发生对应变化
  	array2 = array1; 
  	for(int i = 0;i < array2.length;i++){
   		if(i % 2 == 0){
    			array2[i] = i;
   		}
   		System.out.print(array2[i] + " ");
  	}
  	System.out.println();
  	for(int i = 0;i < array1.length;i++){
   		System.out.print(array1[i] + " ");
  	}
  	System.out.println();
    }
}

4.2 数组查找(线性、二分法)

线性查找

public class ArrayTest {
    public static void main(String []args) {
  	int[] array1 = new int[] {2,3,5,7,11,13,17,19};
  	int num = 11;
  	boolean isOk = true;
  	for(int i = 0;i < array1.length;i++){
   		if(array1[i] == num){
    			System.out.print(i);
    			isOk = false;
    			break;
   		}
  	}
  	if(isOk){
   		System.out.print("数组中没有该元素");
  	}
    }
}

二分法查找：前提是所要查找的数组必须有序

public class ArrayTest {
    public static void main(String []args) {
  	int[] array1 = new int[] {2,3,5,7,11,13,17,19};
  	int num = 11;
  	boolean isOk = true;
  	int head = 0;
  	int end = array1.length - 1;
  	while(head <= end){
   		int middle = (head + end) / 2;
   		if(num == array1[middle]){
    			System.out.print(middle);
    			isOk = false;
    			break;
   		}else if(num > array1[middle]){
    			head = middle + 1;
   		}else{
    			end = middle - 1;
   		}
  	}
  	if(isOk){
   		System.out.print("数组中没有该元素");
  	}
    }
}

4.3 数组排序

4.3.1 冒泡排序(重点掌握)

原理：从前向后，依次比较相邻元素，若发现逆序则交换，使排序码较大的元素逐渐从前部移向后部；每一轮循环后，最大的一个数被交换到末尾，因此，下一轮循环就可以“刨除”最后的数，每一轮循环都比上一轮循环的结束位置靠前一位。
实现方法：两层 for循环，交换两个变量的值时注意借助临时变量
代码示例

public class ArrayTest {
    public static void main(String []args) {
  	int[] arr = new int[]{43,32,76,92,-65,85,71,-42};
  	for(int i = 0;i < arr.length;i++){
   		for(int j = 0;j < arr.length - 1 - i;j++){
    			if(arr[j] > arr[j + 1]){
     				int temp = arr[j + 1];
     				arr[j + 1] = arr[j];
     				arr[j] = temp;
    			}
   		}
  	}
  	for(int i = 0;i < arr.length;i++){
   		System.out.print(arr[i] + " ");
  	}
    }
}

4.3.2 快速排序

介绍：所有内排序算法中速度最快的一种，时间复杂度为O(nlog(n))
原理：选择基准元素，将比基准值小的元素放在基准前面，比基准值大的元素放在基准后面，分别对这两部分继续进行排序，直到整个序列有序

五、Arrays 工具类的使用

Java 标准库内置了 java.util.Arrays类，其为操作数组的工具类，包含了操作数组的各种方法

用法	代码
输出数组信息	`Arrays.toString(arr1)`
判断两个数组是否相等	`Arrays.equals(arr1, arr2)`
将指定值填充到数组之中	`Arrays.fill(arr1, 10)`
对数组排序	`Arrays.sort(arr2);`
排序后使用二分法检索	`Arrays.binarySearch(arr3, 210);`(非有序数组可能找不到指定元素)