Java基础编程-03数组

数组的概述

1.1 数组的理解

• 数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

1.2 数组的特点

• 数组是有序排列的
• 数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
• 创建数组对象会在内存中开辟一整块连续的空间
• 数组的长度一旦确定，就不能修改

1.3 数组的分类

• 照维数：一维数组、二维数组、。。。
• 照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

1.4 数据结构

• 数据与数据之间的逻辑关系：集合、一对一、一对多、多对多
• 数据的存储结构
  • 线性表：顺序表（比如：数组）、链表、栈、队列
  • 树形结构：二叉树
  • 图形结构：邻接矩阵

1.5 算法

• 排序算法：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、。。。
• 搜索算法：广度优先搜索和深度优先搜索

一维数组

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

        int[] ids; //声明
        // 1.静态初始化:数组的初始化和数组元素的赋值操作同时进行
        ids = new int[]{1,2,3,4};
        int[] arr = {1,2,3,4,5};
        // 2.动态初始化:数组的初始化和数组元素的赋值操作分开进行
        String[] names = new String[5];

2.2 一维数组元素的引用

        String[] names = new String[3];
        //数组的角标（或索引从0开始的，到数组的长度-1结束。
        names[0] = "张三";
        names[1] = "李四";
        names[2] = "王五";

2.3 一维数组的属性：length 数组的容量

		System.out.println(names.length); // 3

2.4 一维数组的遍历

		String[] clone = names.clone(); // clone(); 克隆当前对象
		// for 循环遍历
        for (int i = 0; i < clone.length; i++) {
            System.out.println(clone[i]);
        }
        // foreach 循环遍历
        for (String s :clone) {
            System.out.println(s);
        }

2.5 一维数组元素的默认初始化值

• 数组元素是整型：0
• 数组元素是浮点型：0.0
• 数组元素是char型：0或’\u0000’，而非’0’
• 数组元素是boolean型：false
• 数组元素是引用数据类型：null

2.6 一维数组的内存解析

int[] s = new int[10];

for ( int i=0; i<10; i++ ) {
	s[i] =2*i+1;
}

MyDate[] m = new MyDate[10];
        for ( int i=0; i<10; i++ ) {
            m[i] =new MyDate(i+1, i+1,1990+i);  //每一个元素又new对象
        }

二维数组

3.1 如何理解二维数组？

• 二维数组属于引用数据类型
• 数组的元素也可以是引用数据类型
• 一个一维数组A的元素如果还是一个一维数组类型的，则，此数组A称为二维数组

        //静态初始化1
        int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
        //静态初始化2
        int[] arr2[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
        //静态初始化3
        int[] arr3[] = {{1,2,3},{4,5},{6,7,8}};//类型推断

        //动态初始化1
        String[][] arr4 = new String[3][2];
        //动态初始化2
        String[][] arr5 = new String[3][];

3.2 调用二维数组元素

        System.out.println(arr1[0][1]);//2
        System.out.println(arr4[1][1]);//null

        arr5[1] = new String[4];
        System.out.println(arr5[1][0]); //null
        System.out.println(arr5[0]);//null

3.3 二维数组的属性

        System.out.println(arr2.length);//3
        System.out.println(arr2[0].length);//3
        System.out.println(arr2[1].length);//4

3.4 遍历二维数组元素

        for (int i = 0; i < arr2.length; i++) {
            for (int j = 0; j < arr2[i].length; j++) {
                System.out.print(arr2[i][j]+" ");
            }
        }
        //输出：1 2 3 4 5 9 10 6 7 8 

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

• 规定：二维数组分为外层数组的元素，内层数组的元素

int[][] arr = new int[4][3];

• 外层元素：arr[0],arr[1]…等

• 内层元素：arr[0][0],arr[1][2]…等

• 数组元素的默认初始化值

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

3.6 二维数组的内存结构

数组的常见算法

4.1 数组的创建与元素赋值

• 杨辉三角（二维数组）

        // 直角杨辉三角
        public static void main(String[] args) {
            //定义了一个长度为10，高度为10的二维数组，数组中的值都为0；
            int[][] arr=new int[10][10];
            for(int i=0;i<arr.length; i++) {
                //由于只是给杨辉三角内的位置赋值，所以是j<=i
                for(int j=0;j<=i;j++) {
                    //根据规律，使用if else 赋值
                    if(j==0||j==i) {
                        arr[i][j]=1;
                    }else {
                        arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
                    }
				/*由于只是输出杨辉三角范围内的值，所以在内层循环就输出，这种方法不能全部赋值完之后再输出
					"\t"的原因是10和小于10的数组的宽度不同，所以使用\t制表符能使数与数之间距离相等
				*/
                    System.out.print(arr[i][j]+"\t");
                }
                System.out.println();
            }
        }

	// 等腰杨辉三角
	public static void main(String[] args) {
        int rows = 10;

        for (int i = 0; i < rows; i++) {
            int number = 1;
            // 打印空格字符串
            System.out.format("%" + (rows - i) * 2 + "s", "");
            for (int j = 0; j <= i; j++) {
                System.out.format("%4d", number);
                number = number * (i - j) / (j + 1);
            }
            System.out.println();
        }
    }

• 回形数（二维数组）

4.2 针对于数值型的数组

• 最大值、最小值、总和、平均数等

4.3 数组的赋值与复制

• 赋值

int[] array1,array2;
array1 = new int[]{1,2,3,4};

• 赋值

array2 = new int[array1.length];
for(int i = 0;i < array2.length;i++){
	array2[i] = array1[i];
}

如何理解：我们通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。

4.4 数组元素的反转

 		//方法一：
      for(int i = 0;i < arr.length / 2;i++){
          String temp = arr[i];
          arr[i] = arr[arr.length - i -1];
          arr[arr.length - i -1] = temp;
      }
        //方法二：
      for(int i = 0,j = arr.length - 1;i < j;i++,j--){
          String temp = arr[i];
          arr[i] = arr[j];
          arr[j] = temp;
      }

4.5 数组中指定元素的查找：搜索、检索

4.5.1 线性查找

• 实现思路：通过遍历的方式，一个一个的数据进行比较、查找。
• 适用性：具有普遍适用性。

4.5.2 二分法查找

• 实现思路：每次比较中间值，折半的方式检索。
• 适用性：（前提：数组必须有序）

4.6 数组的排序算法

理解：
1）衡量排序算法的优劣：时间复杂度、空间复杂度、稳定性
2）排序的分类：内部排序 与 外部排序（需要借助于磁盘）
3）不同排序算法的时间复杂度

4) 手写冒泡排序

        int[] arr = new int[]{43, 32, 76, -98, 0, 64, 33, -21, 32, 99};
        //冒泡排序
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
         for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        // 输出：-98 -21 0 32 32 33 43 64 76 99 

Arrays工具类的使用

5.1 理解

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

5.2 使用

• 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); // false
        
		int[] arr3;
        arr3 = arr1;
        boolean isEquals1 = Arrays.equals(arr1, arr3); // true

• String toString(int[] a):输出数组信息

		System.out.println(Arrays.toString(arr1));
		// [1, 2, 3, 4]

• void fill(int[] a,int val):将指定值填充到数组之中

		Arrays.fill(arr1,10);
        System.out.println(Arrays.toString(arr1));
        // [10, 10, 10, 10]

• void sort(int[] a):对数组进行排序

		int[] arr4 = new int[]{3,1,5,9};
        Arrays.sort(arr4);
        System.out.println(Arrays.toString(arr4));
        // [1, 3, 5, 9]

• int binarySearch(int[] a,int key):查找a数组key元素下标的方法。它使用的前提是数组是有序的。

		int[] arr5 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
        int index = Arrays.binarySearch(arr5, 210); // 查找数组中201元素的下标
        if(index >= 0){
            System.out.println(index);
        }else{
            System.out.println("未找到");
        }

数组的常见异常

6.1 数组角标越界异常：ArrayIndexOutOfBoundsException

		int[] arr = new int[]{1, 2, 3, 4, 5};
		// 情况一：
        for (int i = 0; i <= arr.length; i++) {
            System.out.println(arr[i]);
        }
        // 情况二：
        System.out.println(arr[-2]);

6.2 空指针异常：NullPointerException

        //情况一：
        int[] arr1 = new int[]{1, 2, 3};
        arr1 = null;
        System.out.println(arr1[0]);

        //情况二：
        int[][] arr2 = new int[4][];
        System.out.println(arr2[0][0]);

        //情况：
        String[] arr3 = new String[]{"AA", "BB", "CC"};
        arr3[0] = null;
        System.out.println(arr3[0].toString());