JavaSE总结基础语法之 - 数组

1. 数组的理解

数组的理解: 数组是多个相同类型的数据按一定顺序存储的集合,并使用一个名字命名

1.1数组相关的概念

• 数组名
• 元素: element
• 角标: index、俗称(下标、索引)
• 数组的长度: 元素的个数

1.2 数组的特点

1. 数组是按顺序存储的
2. 数组是引用数据类型,所以元素可以是基本数据类型,也可以是引用数据类型
3. 创建数组会在内存中开辟一块连续的空间
4. 数组的长度一但确定就不可修改
5. 数组的类型一确定就不可存储其他类型的元素

1.3 数组的分类

• 按维度分类: 一维数组、二维数组、三维数组……
• 按类型分类: 类型又分为基本数据类型与引用数据类型

1.4 数组结构

• 数据与数据之间的逻辑关系: 集合、一对一、一对多、多对多
• 数据的存储结构: 顺序表(便于遍历)、链表(便于增删改)、栈(先进后出)、队列(先进先出)
• 树形结构: 二叉树、红黑树

2. 一维数组

2.1 一维数组的声明与初始化

    //以基本数据类型int为例
    public void test(){
        int[] array;//声明
        array = new int[]{45,66,88};//初始化
        //1. 静态初始化
        int[] array1 = new int[] {1, 2, 3};//声明与初始化
        int[] array2 = {5,7,9,10};//类型推断,不需要写new int[]

        //2. 动态初始化
        int[] array3 = new int[10];//[ ]中填写数组长度,一旦定义就不可修改
    }

2.2 一维数组的元素引用

    public void test1(){
        //使用动态初始化对数组元素引用与赋值
        int[] arr = new int[10];//数组长度为10,但给查找与赋值数组元素是从角标0开始到9,一共10个元素
        //给数组元素的第一位进行赋值
        arr[0] = 65;
        arr[1] = 66;
        arr[2] = 56;
    }

2.3 数组的长度

    public void test1(){
        //使用动态初始化对数组元素引用与赋值
        int[] arr = new int[10];//数组长度为10,但给查找与赋值数组元素是从角标0开始到9,一共10个元素
        //给数组元素的第一位进行赋值
        arr[0] = 65;
        arr[1] = 66;
        arr[2] = 56;
        int length = arr.length;//获取数组长度,给for循环进行遍历
        for (int i = 0; i < length; i++) {
            System.out.println(arr[i]);//i是从0开始对应数组元素下标0,输出到控制台元素
        }
    }

2.4 一维数组的默认初始化值

在数组中声明了各个类型的动态数组

1. short、int、long整数型在数组中默认初始化值为 0
2. float、double浮点型在数组中默认初始化值为 0.0
3. char字符型在数组中默认初始化值为 0或’\u0000’，而非’0’
4. boolean布尔型在数组中默认初始化值为 false
5. 引用数据类型在数组中默认初始化值为 null

2.5 一维数组的内存解析图

3. 二维数组

3.1 如何理解二维数组？

• 数组属于引用数据类型
• 数组的元素也可以是引用数据类型
• 一个一维的数组里的元素在放入一个一维数组,那么这个数组就是二维数组

3.2 二维数组的元素声明与初始化

    public void test(){
        int[][] arr;//声明
        arr = new int[4][3];//初始化
        int[][] arr1 = new int[][]{{2,3,4,5,6},{67,78,88,23},{56,89}};//静态初始化
        int[][]arr2 = new int[6][5];//动态初始化
		
		//类型推导,根据String[][]判断出
        String[][] arr3 = {{"aa","bb","cc","dd"},{"tt","f","as"},{"yu","pp","yy"}};
    }

3.3 如何调用二维数组的元素

    public void test1(){
        String[][] arr3 = {{"aa","bb","cc","dd"},{"tt","f","as"},{"yu","pp","yy"}};
        //第一个[0]为一维数组的长度下标为0,第二个[0]为二维数组里的第0个元素的第0个元素,也就是"aa"
        System.out.println(arr3[0][0]);//aa
        System.out.println(arr3[1][2]);//as
    }

3.4 二维数组的遍历

    public void test2(){
        //遍历二维数组需要使用到嵌套循环for
        String[][] arr3 = {{"aa","bb","cc","dd"},{"tt","f","as"},{"yu","pp","yy"}};
        //先获取到二维数组的长度为3
        for (int i = 0; i < arr3.length; i++) {
            //获取二维数组里面的元素,每个元素都是一个一维数组
            for (int j = 0; j <arr3[i].length; j++){
                //输出元素
                System.out.println(arr3[i][j]);
            }
        }
    }

3.5 二维数组的默认初始化值

规定

• 二维数组分为外层数组与内层数组
• int[ ][ ] arr = new int[4][3];
• 外层数组: arr[0]、arr[1]
• 内存数组: arr[0][0]、arr[2][2]
• ⑤ 数组元素的默认初始化值
• 针对于初始化方式一：比如：int[ ][ ] arr = new int[4][3];
• 外层元素的初始化值为：地址值
• 内层元素的初始化值为：与一维数组初始化情况相同
• 针对于初始化方式二：比如：int[ ][ ] arr = new int[4][ ];
• 外层元素的初始化值为：null
• 内层元素的初始化值为：不能调用，否则报错。

3.6 二维数组在内存中的解析

4. 数组常见算法

1. 数组的创建与元素赋值：杨辉三角（二维数组）、回形数（二维数组）、6个数，1-30之间随机生成且不重复。
2. 针对于数值型的数组：最大值、最小值、总和、平均数等
3. 数组的赋值与复制
4. 数组元素的反转
5. 数组中指定元素的查找：搜索、检索
   5.1 线性查找： 实现思路：通过遍历的方式，一个一个的数据进行比较、查找。适用性：具有普遍适用性。
   5.2 二分法查找：实现思路：每次比较中间值，折半的方式检索。
   适用性：（前提：数组必须有序）

5. 数组的工具类

理解

1. 定义在java.util包下。
2. Arrays:提供了很多操作数组的方法。

		//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
		int[] arr1 = new int[]{1,2,3,4};
		int[] arr2 = new int[]{1,3,2,4};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a):输出数组信息。
		System.out.println(Arrays.toString(arr1));
		
			
		//3.void fill(int[] a,int val):将指定值填充到数组之中。
		Arrays.fill(arr1,10);
		System.out.println(Arrays.toString(arr1));
		

		//4.void sort(int[] a):对数组进行排序。
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5.int binarySearch(int[] a,int key)
		int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		int index = Arrays.binarySearch(arr3, 210);
		if(index >= 0){
			System.out.println(index);
		}else{
			System.out.println("未找到");
		}