JAVA【数组】

最新推荐文章于 2024-08-03 21:02:21 发布

桜キャンドル淵

最新推荐文章于 2024-08-03 21:02:21 发布

阅读量155

点赞数

分类专栏： Java 文章标签： java 开发语言 jvm

本文链接：https://blog.csdn.net/weixin_62684026/article/details/125735122

版权

Java 专栏收录该内容

35 篇文章 0 订阅

订阅专栏

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

2.数组的常见概念：

数组名

下标（或索引）

元素

数组的长度。

3.数组的特点：数组是有序排列的。

数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。

创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。

数组的长度一旦确定就不能修改

数组的分类：

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

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

一维数组的使用：

①一维数组的声明和初始化

②如何调用数组的指定位置的元素

③如何获取数组的长度

④如何遍历数组

⑤数组元素的默认初始化

⑥数组的内存解析

class BreakContinueTest{
    public static void main(String[] args){
        //①一维数组的声明和初始化
        int num;//声明
        num=10;
        int id=1001;//声明+初始化
        int[] ids;//声明
        //1.1静态初始化：数组的初始化和数组元素的赋值操作同时进行
        ids=new int []{1001,1002,1003,1004};
        for(int i=0;i<4;i++)
        {
            System.out.println(ids[i]);
        }
//1.2动态初始化：数组的初始化和数组元素的赋值操作分开进行
        String[] names=new String[5];
        }
    }

//错误的写法

int[] arr1=new int[];

int[5] arr2=new int[];

int[] arr3=new int[3]{1,2,3};

//也是正确的写法

class BreakContinueTest {
    public static void main(String[] args) {
        int[] arr4 = {1, 2, 3, 4, 5};//类型推断
        for(int i=0;i<5;i++)
        {
            System.out.println(arr4[i]);
        }
    }
}

//总结：数组一旦初始化完成，其长度就确定了。

②如何调用数组的指定位置的元素：

通过索引的方式去调用

//数组的角标（或索引）从0开始，到数组的长度-1结束

class BreakContinueTest {
    public static void main(String[] args) {
        String[] names=new String[5];
        names[0]="王";
        names[1]="李";
        names[2]="赵";
        names[3]="黄";
        names[4]="哈哈";
        for(int i=0;i<5;i++)
        {
            System.out.println(names[i]);
        }
    }
}

③如何获取数组的长度

//属性：length

class BreakContinueTest {
    public static void main(String[] args) {
        String[] names=new String[5];
        names[0]="王";
        names[1]="李";
        names[2]="赵";
        names[3]="黄";
        names[4]="哈哈";
        for(int i=0;i<5;i++)
        {
            System.out.println(names[i]);
        }
        System.out.println(names.length);
    }
}

④如何遍历数组

for(int i=0;i<names.length;i++){

System.out.println(names[i]);

⑤数组元素的默认初始化

>整型数组的元素，0 (bit ；short； int； long)

>数组元素是浮点型，0.0

>数组元素是char类型，0或'\u0000'（不是'0'）

>数组元素是Boolean类型，false

>数组元素是引用数据类型，null，（不是"null"），意思就是空值。

⑥数组的内存解析

内存的结构是在JVM中体现的。

内存的简化结构：

栈：stack（局部变量：在方法中定义额变量）

堆：heap（new出来的结构，对象，数组）

方法区：method area 常量池静态域

int[]arr=new[]{1,2,3};//栈空间中的arr用一个十六进制的地址（首地址）找到堆区的数据，先全初始化为0，再赋值。

String[] arr1=new String[4];//先全部初始化为null再赋值。

arr1[1]="刘德华";

arr1=new String[3];//将arr1指向的地址重新指向，即指向一块新的空间，并将其中的所有元素初始化为null。

引用计数算法会将之前那个arr1重定向之前的地址所存储的数据的空间回收。

sysout(arr1[1]);//null

将其出栈，引用计数选法会将这块空间回收

练习

class ArrayDemo{
    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);
    }
}

class ArrayDemo1{
    public static void main(String[] Args){
//使用scanner，读取学生个数
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入学生人数：");
        int number=scanner.nextInt();
//创建数组，存储学生成绩，动态初始化
        int[] scores=new int[number];
//给数组中的元素赋值
        System.out.println("请输入"+number+"个学生成绩：");
        for(int i=0;i<scores.length;i++){
            scores[i]=scanner.nextInt();
        }
//获取数组中的元素的最大值：最高分
        int maxScore=0;
        for(int i=0;i<scores.length;i++){
            if(maxScore<scores[i]){
                maxScore=scores[i];
            }
        }
//根据每个学生成绩与最高分的差值，得到每个学生的等级，并输出等级和成绩
        char level;
        for(int i=0;i<scores.length;i++){
            if (maxScore-scores[i]<=10){
                level='A';
            }else if(maxScore-scores[i]<=20){
                level='B';
            }else if(maxScore-scores[i]<=30){
                level='C';
            }else {
                level='D';
            }
            System.out.println("Student"+i+"score is"+scores[i]+",grade is"+level);
        }
    }
}

多维数组的使用

Java语言里提供了支持多维数组的语法。

如果说可以把一维数组当成几何中的线性图形，那么二维数组就相当于是一个表格

对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。

2.二维数组的使用：

①二维数组的声明和初始化

②如何调用数组的指定位置的元素

③如何获取数组的长度

④如何遍历数组

⑤数组元素的默认初始化

⑥数组的内存解析

①二维数组的声明和初始化

class ArrayTest2 {
    public static void main(String[] args) {
//①二维数组的声明和初始化
        int[] arr = new int[]{1, 2, 3};//一维数组
//静态初始化
        int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
//动态初始化1
        String[][] arr2 = new String[3][2];
//动态初始化2
//一定要有几行，可以不指定有几列
        String[][] arr3 = new String[3][];
    }
}

//错误的情况

String[][] arr2=new String[][4];

String[][] arr2=new String[][];

int [][]arr1=new int[4][3]{{1,2,3},{4,5},{6,7,8}};

//正确的情况

int arr4[][]=new int[][]{{1,2,3},{4,5},{6,7,8}};

int []arr5[]={{1,2,3},{4,5},{6,7,8}};

②如何调用数组的指定位置的元素

class ArrayTest2 {
    public static void main(String[] args) {
//①二维数组的声明和初始化
        int[] arr = new int[]{1, 2, 3};//一维数组
//静态初始化
        int[][] arr1 = new int[][]{{1, 2, 3}, {4, 5}, {6, 7, 8}};
//动态初始化1
        String[][] arr2 = new String[3][2];
//动态初始化2
        String[][] arr3 = new String[3][];
        System.out.println(arr1[0][1]);//2
        System.out.println(arr2[1][1]);//null(没有赋值)
        arr3[1]=new String[4];
        System.out.println(arr3[1][0]);
    }
}

③如何获取数组的长度

class ArrayTest2 {
    public static void main(String[] args) {
        int arr4[][]=new int[][]{{1,2,3},{4,5},{6,7,8}};
        System.out.println(arr4.length);//3，此处的3指的是最外层的数组有三个元素
        System.out.println(arr4[0].length);//3
        System.out.println(arr4[1].length);//2
    }
}

④如何遍历二维数组

class ArrayTest2 {
    public static void main(String[] args) {
        int arr4[][]=new int[][]{{1,2,3},{4,5},{6,7,8}};
        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();
        }
    }
}

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

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

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

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

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

针对于初始化方式一：比如int[][]arr=new int [4][3];

外层元素的初始化值：地址值

内层元素的初始化值为：与一维数组初始化情况相同。

针对于初始化方式二：比如：int[][] arr=new int [4][];

外层元素的初始化值为：null

内层元素的初始化值为：不能调用，否则报错。

class ArrayTest2 {
    public static void main(String[] args) {
        int[][] arr=new int[4][3];
        System.out.println(arr[0]);//是一个地址值
        System.out.println(arr[0][0]);//0
        System.out.println(arr);//整个二维数组的地址
        }
    }

⑥数组的内存解析

由上面的测试代码来看，二维数组的数组名，也就是arr所指向的是整个二维数组的地址，然后arr[0],arr[1],arr[2]等所指向的都是每一行的地址。

class ArrayExer1{
    public static void main(String[] args){
        int [][] arr=new int [][]{{3,5,8},{12,9},{7,0,6,4}};
        int sum=0;//记录总和
        for (int i=0;i<arr.length;i++){
            for(int j=0;j<arr[i].length;j++){
                sum+=arr[i][j];
            }
        }
                System.out.println("总和为："+sum);
    }
}

声明：int[] x,y[];在给x,y变量赋值以后，以下选项允许通过编译的是：

x为int类型的一维数组

y为int类型的二维数组

（可以赋值的条件为：1.相同的类型的元素2.可以整型提升的元素）

a)x[0]=y;no

b)y[0]=x;yes(y中的一个元素就是一维的数组，所以可以赋值)

c)y[0][0]=x;no

d)x[0][0]=y;no

e)y[0][0]=x[0];yes

f)x=y;no

提示：

一维数组：int[]x或者int x[]

二维数组：int[][]y 或者int [] y[] 或者int y[][]

桜キャンドル淵

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
JAVA【数组】

目录数组的分类：一维数组的使用：②如何调用数组的指定位置的元素：③如何获取数组的长度 ④如何遍历数组⑤数组元素的默认初始化⑥数组的内存解析多维数组的使用2.二维数组的使用：①二维数组的声明和初始化②如何调用数组的指定位置的元素③如何获取数组的长度 ④如何遍历二维数组⑤数组元素的默认初始化值⑥数组的内存解析 2.数组的常见概念：3.数组的特点：数组是有序排列的。//也是正确的写法//总结：数组一旦初始化完成，其长度就确定了。练习多维数组的使用2.二维数组的使用：
复制链接

扫一扫