day2.6_数组

作者: OmewSPG | 来源:发表于2022-01-19 14:47 被阅读0次

day2.6_数组
数组
JavaScript - 5.数组<增删改查>
PHP数组使用
》》》PHP初入---（三）
JavaScript中数组的常用操作
JavaSE之数组
Shell数组、关联数组
学习Java第五天
php基础精粹

数组概述

image.png

数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
数组的长度一旦确定，就不能修改。
我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。
数组的分类：
 按照维度：一维数组、二维数组、三维数组、…
 按照元素的数据类型分：基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

一维数组使用

一维数组声明与初始化

image.png

        // 一维数组的声明和初始化
        int[] ids; // 声明
        ids = new int[]{1001,1002,1003,1004}; // 静态初始化 
        
        String[] names = new String[5];   // 动态初始化
        // 即：数组一旦初始化完成，其长度就确定了

一维数组引用

image.png

        // 调用数组元素
        // 数组的索引是从零开始
        names[0] = "Java";
        names[1] = "Python";
        names[2] = "NodeJS";
        names[3] = "JavaScript";
        System.out.println(ids[2]);  // 1003
        System.out.println(names[2]);  // NodeJS
        System.out.println(names[4]);  // null
        
        // 获取数组长度
        System.out.println(names.length);  // 5
        
        // 遍历数组元素
        for(int i = 0 ; i < names.length; i++){
            System.out.println(names[i]);
        }

数组元素的默认初始化值

image.png

// 数组元素的默认初始化值
        // 数组元素是整型，默认初始化都为0
        int[] arr = new int[4];
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);  // 0,0,0,0
        }
        
        // 如果是浮点型，初始化为0.0
        double[] arr1 = new double[4];
        System.out.println(arr1[0]);  // 0.0
        
        // 如果是字符型，初始化为0，但实际显示为空格
        char[] arr2 = new char[4];
        System.out.println(arr2[0]);
        
        if(arr2[0] == 0){
            System.out.println("Hello!");
        }
        
        // 如果是布尔型，初始化为false
        boolean[] arr3 = new boolean[4];
        System.out.println(arr3[0]);
        
        // 如果是String，初始化为null

数组内存解析

多维数组使用

二维数组声明与初始化

image.png

        // 二维数组声明与初始化
        // 静态初始化
        int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
        
        // 动态初始化
        String[][] arr1 = new String[3][2];   // 3行2列
        String[][] arr2 = new String[3][];    // 这样也是可以的
        
        // 其它写法
        int arr3[][]= {{1,2},{3,4},{5,6,7,8}};  // 类型推断

image.png

二维数组调用

类似于一维数组

// 二维数组调用
        System.out.println(arr[2][2]);    // 9
        System.out.println(arr1[0][0]);   // null
        
        arr2[0] = new String[4];
        System.out.println(arr2[0][0]);   // null
        
        
        // 获取二维数组的长度
        System.out.println(arr3.length);   // 3
        System.out.println(arr3[0].length);  // 2
        System.out.println(arr3[2].length);  // 4
        
        // 遍历二维数组
        for(int i = 0; i < arr3.length; i++){
            for(int j = 0; j < arr3[i].length; j++){
                System.out.print(arr3[i][j] + " ");
            }
            System.out.println();
        }

二维数组默认初始化值

        // 二维数组的默认初始化值
        // 规定：二维数组分为外层数组元素和内层数组元素
        /*
         * int arr[][] = new int[4][3];
         * 外层元素： arr[0] , arr[1]  ...
         * 内层元素： arr[0][0] , arr[0][1]  ...
         */
        
        int[][] arrTest = new int[3][4];
        System.out.println(arrTest[0]);   // [I@15db9742    这其实是地址值
        System.out.println(arrTest[0][0]);  // 0
        
        int[][] arrTest2 = new int[3][];
        System.out.println(arrTest2[0]);   // null
        // System.out.println(arrTest2[0][0]);  // 报错：空指针异常

二维数组内存解析

image.png

注意：
一维数组：int[] x 或者int x[]
二维数组：int[][] y 或者 int[] y[] 或者 int y[][]

例题：杨辉三角

package com.atguigu.java;
/*
 * 使用二维数组打印一个 10 行杨辉三角。
 * 1. 第一行有 1 个元素, 第 n 行有 n 个元素
   2. 每一行的第一个元素和最后一个元素都是 1
   3. 从第三行开始, 对于非第一个元素和最后一个元
                  素的元素。即：
      yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
 */
public class practice4 {
    public static void main(String[] args) {
        int[][] arr = new int[10][];    // 循环开始前，先初始化10行数组
        for(int i = 0; i < 10; i++){
            arr[i] = new int[i + 1];    // 在第一层循环里，为每一行添加i + 1个数组元素
            for(int j = 0; j <= i; j++){
                if(j == 0 || i == j){
                    arr[i][j] = 1;
                }else{
                    arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
                }
                System.out.print(arr[i][j] + "  ");

            }
            System.out.println("");
        }
    }
}

打印结果：

image.png

数组中涉及到的常见算法

例题

定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
要求：所有随机数都是两位数。

public class practice6 {
    public static void main(String[] args) {
        int[] arr = new int[10];
        int max, min, sum, avr;
        
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 90 + 10);
            System.out.print(arr[i] + "  ");
        }
        
        max = arr[0];
        min = arr[0];

        for (int i = 1; i < arr.length; i++) {
            max = (max > arr[i]) ? max : arr[i];
        }
        
        for (int i = 1; i < arr.length; i++) {
            min = (min < arr[i]) ? min : arr[i];
        }
        
        sum = 0;
        for (int i = 1; i < arr.length; i++) {
            sum += arr[i];
        }
        
        avr = sum / arr.length;
        
        System.out.println("");
        System.out.println(max);
        System.out.println(min);
        System.out.println(sum);
        System.out.println(avr);

    }
}

赋值与复制

使用简单数组：

创建一个名为ArrayTest的类，在main()方法中声明array1和array2两个变量，
他们是int[]类型的数组。
使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
显示array1的内容。
赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。

package com.atguigu.java;

public class ArrayTest3 {
    public static void main(String[] args) {
        int[] arr = new int[]{2,3,5,7,11,13,17,19};
        int[] arr1 = new int[8];
        
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + " ");
        }
        // 2 3 5 7 11 13 17 19 
        
        System.out.println("");
        arr1 = arr;   // 将arr的地址给arr1
        for(int i = 0; i < arr.length; i++){
            if(i % 2 == 0){
                arr1[i] = i;
            }
            System.out.print(arr1[i] + " ");
        }
        // 0 3 2 7 4 13 6 19 
        
        System.out.println("");
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + " ");
        }
        // 0 3 2 7 4 13 6 19 
    }
}

可以看到，更改arr1数组内容的同时，arr的内容也跟着一起改变了，这是为何？
请看下面的内存解析：

image.png

对数组进行赋值，实际上赋值的是其指向的内存地址，两个数组变量通过赋值操作后实际指向的是同一个数组内容

但是，如果需要复制数组内容的数据呢？
数组的复制：

        // -----------------数组的复制---------------------
        int[] arr1 = new int[]{2,3,5,7,11,13,17,19};
        int[] arr2 = new int[arr1.length];
        
        for(int i = 0; i < arr2.length; i++){
            arr2[i] = arr1[i];
            System.out.print(arr2[i] + " ");
        }
        // 2 3 5 7 11 13 17 19  
        
        System.out.println(" ");
        
        for(int i = 0; i < arr2.length; i++){
            if(i % 2 == 0){
                arr2[i] = i;
            }
            System.out.print(arr2[i] +  " ");
        }
        // 0 3 2 7 4 13 6 19  
        
        System.out.println(" ");
        
        for(int i = 0; i < arr2.length; i++){
            System.out.print(arr1[i] +  " ");
        }
        // 2 3 5 7 11 13 17 19
        
        System.out.println(" ");

内存解析图：

image.png

翻转

        String[] str = new String[]{"AA","BB","CC","DD","EE","FF"};
        String temp;
        for(int i = 0; i < str.length / 2; i++){
            temp = str[i];
            str[i] = str[str.length - 1 - i];
            str[str.length - 1 - i] = temp;
        }
        
        for(int i = 0; i < str.length; i++){
            System.out.print(str[i] + " ");
        }
        // FF EE DD CC BB AA  
        
        System.out.println(" ");

查找

线性查找

        // 线性查找
        Scanner scan = new Scanner(System.in);
        String index = scan.next();
        boolean flag = true;
        
        for(int i = 0; i < str.length; i++){
            if(index.equals(str[i])){
                System.out.println("已查找到元素，位置： " + i);
                flag = false;
                break;
            }
        }
        
        if(flag){
            System.out.println("未查找到元素...");
        }

二分查找

        // 二分查找
        // 前提，数组必须是有序的
        int[] list = new int[]{-99,-54,-2,0,2,33,43,256,999};
        
        int head = 0;
        int last = list.length - 1;
        int sear = -2;
        
        while(head < last){
            int middle = (head + last) / 2;
            if(sear == list[middle]){
                System.out.println("已查找到元素，位置： " + middle);
                break;
            }
            else if(sear > list[middle]){
                head = middle;
            }else{
                last = middle;
            }
        }

排序

冒泡排序

        // 冒泡排序
        int[] arr = new int[]{-12,-90,5,2,88,60,-17,-44,46,80,32,11,7};
        
        for (int i = 0; i < arr.length; i++) { 
            for (int j = 0; j < arr.length - i - 1; 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] + " ");
        }

常见排序算法的比较：

image.png

Arrays工具类使用

image.png

package com.atguigu.java;

/*
 * Array工具类
 * 
 */
import java.util.Arrays;

public class ArrayTest6 {
    public static void main(String[] args) {

        // 判断两个数组是否相等
        int[] arr1 = new int[] { 1, 2, 3, 4, 5 };
        int[] arr2 = new int[] { 1, 2, 3, 4, 5 };

        boolean isEquals = Arrays.equals(arr1, arr2);
        System.out.println(isEquals);   // true

        // 输出数组信息
        System.out.println(Arrays.toString(arr1));   // [1, 2, 3, 4, 5]

        // 替换数组元素
        Arrays.fill(arr1, 10);
        System.out.println(Arrays.toString(arr1));   // [10, 10, 10, 10, 10] 

        // 对数组进行排序
        int[] arr3 = new int[] { 9, 2, 1, 5, 6, 3, 4, 8, 7 };
        Arrays.sort(arr3);
        System.out.println(Arrays.toString(arr3));   // [1, 2, 3, 4, 5, 6, 7, 8, 9]

        // 二分法检索
        String[] arr4 = new String[] { "AA", "BB", "CC", "DD", "EE", "FF" };
        int index = Arrays.binarySearch(arr4, "CC");
        if (index >= 0) {
            System.out.println(index);
        } else {
            System.out.println("未找到此元素..." + index);
        }
        // 结果为 2
        // 如果没有找到则返回一个负数值
    }
}

常见异常

image.png

day2.6_数组
数组概述数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。创建数组对象...
数组
数组数组数组数组数组数组数组数组数组
JavaScript - 5.数组<增删改查>
数组 Array 数组 - 增数组 - 删 / 改数组 - 查数组 - 自动 toString（）数组 -...
PHP数组使用
数组定义数组增、删、改数组查询数组排序数组合并、分割数组比较、去重复数组长度数组遍历数组转换其他...
》》》PHP初入---（三）
数组定义 1.索引数组：数组下标是整型的声明数组：访问数组： count（数组）--获取数组长度查看数组所有...
JavaScript中数组的常用操作
数组的遍历数组的映射数组的简化数组的连接获取数组的片段数组的拷贝查找数组数组去重
JavaSE之数组
六、数组目录：数组概述、数组声明创建、数组使用、多维数组、Array类、稀疏数组 1.什么是数组数组的定义：数...
Shell数组、关联数组
数组定义数组获取数组关联数组定义关联数组获取关联数组
学习Java第五天
数组是多个数据的集合数组的语法数组元素类型【】数组名；多维数组：数组元素类型【】【】数组名；多维数组...
php基础精粹
PHP php数组 php数组之索引数组初始化 PHP数组之索引数组赋值 PHP数组之访问索引数组内容 PHP数组...