第3章_数组

琪毅

已于 2024-05-19 19:19:45 修改

阅读量17

点赞数

分类专栏： java学习文章标签： java

于 2022-03-24 19:31:14 首次发布

本文链接：https://blog.csdn.net/weixin_45683698/article/details/123719325

版权

java学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

数组的概述

1. 基本概念

数组（Array），是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
数组的常见概念:
1. 数组名
2. 下标（或索引）
3. 元素
4. 数组的长度：元素的个数
数组的特点：

数组是有序排列的
数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
数组的长度一旦确定，就不能修改
我们可以直接通过索引的方式调用指定位置的元素
数组：

按照维度：一维数组、二维数组、三维数组…

按照元素的数据类型：基本数据类型元素的数组、引用数据类型元素的数组（即对象数组）

2. 一维数组的使用

2.1 注意事项

一维数组的声明和初始化
如何调用数组的指定位置的元素
如何获取数组的长度
如何遍历数组
数组元素的默认初始化值
数组的内存解析（内存中是如何分配数组结构的）

2.2 代码：一维数组初始化

public class ArrayTest{
    public static void main(String[] args){
        //1. 一维数组的声明和初始化
        int num;//声明
        num = 10;//初始化
        int id = 1001;//声明+初始化
        
        //数组
        int[] ids;//声明
        //1.1 初始化方式一：静态初始化：数组的初始化和数组元素的赋值操作同时进行
        ids = new int[]{1001,1002,1003,1004};
        //1.2 初始化方式二：动态初始化：数组的初始化和数组元素的赋值操作分开进行
        String[] names = new String[5];
        
        //2. 如何调用数组的指定位置的元素：通过索引的方式调用
        //数组的角标（或索引）从0开始的，到数组的长度-1结束
        names[0] = "red";
        names[1] = "yellow";
        names[2] = "green";
        
        //3. 如何获取数组的长度
        //属性：length
        System.out.println(names.length);//5
        
        //4. 如何遍历数组元素
        for(int i = 0; i < names.length; i++){
            System.out.println(names[i]);
        }
        
        //5. 数组元素的默认初始化值
        int[] array = new int[4];
        for(int i = 0; i < array.length; i++){
            System.out.println(array[i]);//默认初始化值为0
        }
        
        System.out.println("**********************");
        char[] arr3 = new char[4];
        for(int i = 0; i < arr3.length; i++){
            System.out.println("----" + arr3[i] + "****");
        }
        
        if(arr3[0] == 0){
            System.out.println("你好！");//你好
        }
        
        System.out.println("**********************");
        String[] arr5 = new String[5];
        System.out.println(arr5[0]);//null
        
        //6. 数组的内存解析
        
    }
}

2.2.1 数组初始化总结：

初始化方式一：静态初始化：数组的初始化和数组元素的赋值操作同时进行
初始化方式二：动态初始化：数组的初始化和数组元素的赋值操作分开进行
数组一旦初始化完成，其长度就确定了
中括号放到类型后面和变量名后面都可以，但一般还是放在类型后面。

初始化稍微不标准的写法：

int[] arr4 = {1,2,3,4,5};//类型推断

//不能省略：
int[] ids;
ids = new int[]{1,2,3,4,5};//不能将new int[]省略

2.2.2 数组元素的默认初始化值总结：

数组元素是整形：默认初始化值是0
数组元素是浮点型：0.0
数组元素是char型：0（ASCII值为0）或可以说’\u0000’，而非’0’
数组元素是boolean型：false（false对应的是0）
数组元素是引用数据类型时：

例如：String型：null（空值）

2.2.3 数组的内存解析：

内存的简化结构：
在这里插入图片描述

栈里面存的都是局部变量
堆里面存的是new出来的结构（对象、数组）

2.2.4 一维数组的内存解析

放在方法中的变量都叫做局部变量，局部变量放在栈当中。

在这里插入图片描述

2.3 练习

升景坊单间短期出租4个月，550/月。空调、卫生间、厨房齐全。屋内均是IT行业人士，喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人。

public class ArrayTest{
    public static void main(String[] args){
        int[] arr = new int[8,2,1,0,3];
        int[] index = new int[2,0,3,2,4,0,1,3,2,3,3];
        String tel = "";
        for(int i = 0; i < index.length; i++){
            tel += arr[index[i]];
        }
        System.out.println("联系方式：" + tel);//18013820100
    }
}

public class ArrayDemo{
    public static void main(String[] args){
        //1. 使用Scanner，读取学生个数
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生人数：" );
        int number = scanner.nextInt();
        //2. 创建数组，存储学生成绩，动态初始化
        int scores[] = new int[number];
        //3. 给数组中的元素赋值
        System.out.println("请输入" + number + "个学生成绩：");
        int maxScore = 0;
        for(int i = 0; i < scores.length; i++){
            scores[i] = scanner.nextInt();
            if(maxScore < scores[i]){
                maxScore = scores[i];
            }
        }
        //4. 找出最大值
        /**
        int maxScore = 0;
        for(int i = 0; i < scores.length; i++){
            if(maxScore < scores[i]){
                maxScore = scores[i];
            }
        }
        */
        //5. 输出学生的成绩，并根据公式判定学生成绩等级并输出
        char level;
        for(int i = 0; i < score.length; i++){
            if(maxScore - scores[i] <= 10){
                level = 'A';
            }else if(maxScore - scores[i] <= 20){
                level = 'B';
            }else if(maxScore - scores[i] <= 30){
                lever = 'C';
            }else{
                level = 'D';
            }
            System.out.println("student" + i + "score is" + scores[i] + ",grade is " + level);
        }
    }
}

3. 多维数组的使用

3.1 基本概念

Java语言里提供了支持多维数组的语法
如果说可以把一维数组当成几何中的线性图形，那么二维数组就相当于是一个表格，像是Excel表格一样
对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，并没有多维数组。

3.2 二维数组

3.2.1 二维数组初始化

即一个数组的元素又是一个数组，这个数组就是二维数组

public class ArrayTest{
    public static void main(String[] args){
        int[] arr = new int[]{1,2,3,4};//一维数组
        int[][] arr1 = new int[][]{{1,2,3,4},{4,5},{5,7,8}};//二维数组静态初始化
        String[][] arr2 = new String[2][4];//二维数组动态初始化
    }
}

二维数组动态初始化两种方式：

//第一种：
String[][] arr3 = new String[3][2];
//第二种：
String[][] arr3 = new String[3][];

只有这两种是正确的，其它写法都是错误的

稍微不标准的写法：

//中括号写后边
int arr4[][] = new int[][]{{1,2,3,4},{4,5},{5,7,8}};
//中括号前面放一个，后面放一个
int[] arr4[] = new int[][]{{1,2,3,4},{4,5},{5,7,8}};

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

System.out.println(arr1[0][1]);

3.2.3 获取数组长度

int[][] arr4[] = new int[][]{{1,2,3},{4,5},{6,7,8}};
System.out.println(arr4.length);//3
System.out.println(arr4[0].length);//3
System.out.println(arr4[1].length);//2

3.2.4 如何遍历二维数组

for(int i = 0; i < arr4.length; i++){
    for(int j = 0; j < arr4[i].length; j++){
        System.out.print(arr4[i][j] + " ");
    }
    System.out.println()
}

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

二维数组的使用：

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

int[] arr = new int[4][3];
//外层元素：
arr[0],arr[1]等
//内层元素
arr[0][0],arr[1][2]等

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

针对于初始化方式一：比如，
```
int[][] arr = new int[4][3];
```
（1）外层元素的初始化值为：地址值

（2）内层元素的初始化值为：与一维数组初始化情况相同，取决于内层数组元素的数据类型。
针对于初始化方式二：比如：
```
int[][] arr = new int[4][];
```
（1）外层元素的初始化值为：null

（2）内层元素的初始化值为：不能调用，外层元素指向空，所以报空指针异常。

public class ArrayTest3{
    public static void main(String[] args){
        int[][] arr = new int[4][3];//二维数组静态初始化
        System.out.println(arr[0]);//地址值  [I@15db9742-->[一维数组；I-->int型；
        System.out.println(arr[0][0]);//int型，0
    }
}

特殊情况下初始值：

public class ArrayTest4{
    public static void main(String[] args){
        String[][] arr3 = new String[4][];
        System.out.println(arr3[1]);//null
        
        double[][] arr4 = new double[4][];
        System.out.println(arr4[1]);//null
        System.out.println(arr4[1][0]);//报错，空指针异常
    }
}

是null的原因：外层每一个都是一维数组，数组属于引用数据类型，引用数据类型默认值都是null

3.2.6 二维数组的内存解析

如图所示：

在这里插入图片描述

练习：
在这里插入图片描述

在这里插入图片描述

对于引用数据类型的变量：

它的存在，要么是null，要么是一个地址值。

4.数据结构

数据与数据之间的逻辑关系：集合、一对一、一对多、多对多
数据的存储结构：
1. 线性表：刻画一对一的关系
  
  （1）顺序表（比如：数组）、链表、栈（先进后出）、队列
2. 树形结构：刻画一对多的关系
  
  二叉树
3. 图形结构：刻画多对多的关系
  
  图形结构
算法：

最基本的算法：
1. 排序算法
2. 搜索算法

5.二维数组练习

/*杨辉三角*/
public class YangHuiTest {
    public static void main(String[] args){
        //对二维数组的初始化
        int[][] yangHui = new int[10][];
        for(int i = 0; i < yangHui.length; i++){
            yangHui[i] = new int[i + 1];
            //对每一行的第一个元素和最后一个元素赋值
            yangHui[i][0] = yangHui[i][i] = 1;
            //从第三行开始，对于非第一个和最后一个元素，即 yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
            for(int j = 1; j < yangHui[i].length-1;j++){
                yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
            }
        }
        for(int i = 0; i < yangHui.length; i++){
            for(int j = 0; j < yangHui[i].length; j++){
                System.out.print(yangHui[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

6.Arrays工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法

/*
java.util.Arrays:操作数组的工具类，里面定义了很多操作数组的方法
*/
public class ArraysTest{
    public static void main(String[] args){
        //1. boolean equals(int[] a, int[] b)：判断两个数组是否相等，返回一个boolean型
        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
        
        //2. String toString(int[] a):输出数组信息
        System.out.println(Arrays.toString(arr1));//即遍历数组
        
        //3. void fill(int[] a, int val):将指定值填充到数组中
        Arrays.fill(arr1, 10);//把原来数组中的每个元素都替换为val
        
        //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("未找到");
        }
    }
}

7. 数组中的常见异常

数组索引越界异常：ArrayIndexOutOfBoundsException
空指针异常：NullPointerException

public class ArrayExceptionTest{
    public static void main(){
        //1. 数组索引越界异常：ArrayIndexOutOfBoundsException
        int[] arr = new int[]{1,2,3,4,5};
        for(int i = 0; i <= arr.length; i++){
            //ArrayIndexOutOfBoundsException
            System.out.println(arr[i]);//此为右边越界
            
            System.out.println(arr[-2]);//此为左边越界
            System.out.println("hello");//一旦出现异常，则后面代码不会执行
            
            //2. 空指针异常  NullPointerException
            //情况一：
            int[] arr1 = new int[]{1,2,3};
            arr1 = null;//将arr1赋空值，即相当于删除了arr1的地址值，因此arr1[0]为空。
            //NullPointerException
            System.out.println(arr1[0]);
            
            //情况二：
            int[][] arr2 = new int[4][];
            System.out.println(arr2[0]);//null
            //NullPointerException
            System.out.println(arr2[0][0]);
            
            //情况三：
            String[] arr3 = new String[]{"AA","BB","CC"};
            arr3[0] = null;
            System.out.println(arr3[0].toString());
        }
    }
}

8. 闲话–关于维度

四维即是三维加上时间

五维通常叫做平行宇宙，是四维加上诸多的可能性（即预见未来）

六维即五维的折叠，五维需要一步一步去实现的，六维可以一步达成（实现时空的瞬移）、六维空间的人需要遵守自然规律

琪毅

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第3章_数组

文章目录数组的概述1. 基本概念2. 一维数组的使用2.1 注意事项2.2 代码：一维数组初始化2.2.1 数组初始化总结：2.2.2 数组元素的默认初始化值总结：2.2.3 数组的内存解析：2.2.4 一维数组的内存解析2.3 练习3. 多维数组的使用3.1 基本概念3.2 二维数组3.2.1 二维数组初始化3.2.2 如何调用二维数组的元素3.2.3 获取数组长度3.2.4 如何遍历二维数组3.2.5 二维数组元素默认初始化值3.2.6 二维数组的内存解析数组的概述1. 基本概念数组（Arr
复制链接

扫一扫