【Java基础】数组定义、初始化、访问、内存排列

最新推荐文章于 2024-07-15 23:22:42 发布
最新推荐文章于 2024-07-15 23:22:42 发布
阅读量420 收藏 3
点赞数
分类专栏： java基础 文章标签： java 数据结构 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43520842/article/details/126386627
版权

文章目录

0.数组概述

  • 数组是多个相同类型数据的组合，实现对这些数据的统一管理

  • 数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量

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

1.一维数组

1.1一维数组声明创建对象

1.1.1声明方式

type var[] 或 type[] var

例如

 int a[];
 int[] a1;
 double b[];
 double[] c;
  • 在java中声明数组不能指定其长度，例如 int a[5] 是违法的

1.1.2 创建一维数组（定义及初始化）

①创建但不赋初值

int a[] = new int[5];//每个元素默认值为0

//错误示范
int a[3];
int a[3] = new int[];
int a[3] = new int[3];

②静态创建并初始化

int a[] = {1,2,3,4,5};
//等价于
a[0]=1;a[1]=2;a[2]=3;a[3]=4;a[4]=5;

③使用初始化列表动态创建并初始化

int a[] = new int[]{1,2,3,4,5};//等同于静态初始化

//错误示例
int a[] = new int[5]{1,2,3,4,5};

④指向已有数组

int a[] = new int[]{1,2,3,4,5};
int e[] = a;//指向已有数组对象

//错误示例
int a[];
int e[] = a;//指向未初始化引用

1.2一维数组内存排列

在这里插入图片描述
在这里插入图片描述

1.3 一维数组元素的引用

数组元素的引用方式: arrayName[index]
index为数组元素 下标
数组元素下标从0开始;
长度为n的数组合法下标取值范围:0 ~ n-1;

每个数组都有一个属性length指明它的长度，例如：
a.length指明数组a的长度(元素个数)。

  • 访问单个元素
int a[] = new int[]{1,2,3,4,5};
a[0]=6;
a[1]=7;
a[3]=5;
  • 遍历所有元素
for(int i=0;i<a.length;i++){
    a[i] = xxx;
}

例子

1.定义一一个10个元素的数组a[10]，要求手动从控制台输入每个元素的值，然后将每个元素的值统一 打印出来。

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
//        定义一一个10个元素的数组a[10]，要求手动从控制台输入每个元素的值，然后将每个元素的值统一 打印出来。
        int[] a = new int[10];
        Scanner sc = new Scanner(System.in);
        for(int i=0;i<a.length;i++){
            System.out.println("请输入a["+i+"]的值：");
            a[i] = sc.nextInt();
        }
        System.out.println("输入完毕");
        System.out.println("数组a的元素为");
        for(int j = 0;j<a.length;j++){
            System.out.print(a[j]+" ");
        }
    }
}

2.在上题的基础上，将程序修改为:分两批对数组进行赋值，第一次只赋值下标为0、2、4、6等偶数元素，第二次只赋值下标为1、3、5、7等奇数元素。然后分别打印出来，如:
下标为偶数的数组元素值为:
下标为0的元素值为XX。
下标为2的元素值为XX。
下标为4的元素值为XX。
…
下标为奇数的数组元素值为:
下标为1的元素值为XX。
下标为3的元素值为XX。
下标为5的元素值为XX。
提示:方法一、可以用for语句直接进行赋值(考虑下标一次增加多少? )。方法二、也可以用取模运算符“%”，判断哪些是偶数下标、哪些是奇数下标。

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
//        定义一一个10个元素的数组a[10]，要求手动从控制台输入每个元素的值，然后将每个元素的值统一 打印出来。
        int[] a = new int[10];
        Scanner sc = new Scanner(System.in);
        for(int i=0;i<a.length;i+=2){
            System.out.println("请输入a["+i+"]的值：");
            a[i] = sc.nextInt();
        }
        for(int i=1;i<a.length;i+=2){
            System.out.println("请输入a["+i+"]的值：");
            a[i] = sc.nextInt();
        }
        System.out.println("输入完毕");
        System.out.println("数组a的元素为");
        for(int j = 0;j<a.length;j+=2){
            System.out.println("下标为"+j+"的元组值为"+a[j]);
        }
        for(int i=1;i<a.length;i+=2){
            System.out.println("下标为"+i+"的元组值为"+a[i]);
        }
    }
}

2.二维数组

2.1定义及初始化

2.2.1 定义

int a[][] = new int[3][];

跟一维数组类似，定义二维数组时，不能指定其第1维度(低维)的长度，但必须指定第2维( 高维)的长度:
对于java的二维数组，意为:‘“一维数组对象组成的数组，叫
做二维数组." 换句话说，就是二维数组中的每一个元素，是一个一维数组对象。
在这里插入图片描述

2.1.2 初始化

①创建但不赋值

int a[][] = new int[3][];//每个元素的值默认null;
//一下为错误示范
int a[3][] = new int[3][];//引用本身不能指定长度
int a[][] = new int[][];//必须指定第二维长度
int a[][] = new int[3][4];//低维指定长度不报错，但无意义

②静态创建并初始化

int a[][] = {{1,2,3},{4,5,6},{7,8,9}};
//等价于对高维每个元素分别赋值：
int a[][] = new int[3][];
a[0] = new int[]{1,2,3};
a[1] = new int[]{4,5,6};
a[2] = new int[]{7,8,9};

③使用初始化列表动态创建并初始化

int a[][] = new int[][]{new int[5],new int[5],new int[5]};

④指向已有数组

int a[][] = new int[3][];
int b[][] = a;//指向已有数组对象

⑤不定长二维数组

int a[][] = new int[][]{new int[3],new int[4],new int[5]};

在java中， 由于二维数组实际上是“一维数组对象组成的数组。"本质上其还是一个一维数组(只是它里面的每个元素也是一维数组)，因此它内部只要是一维数组对象即可(并不一定非得长度相等)

2.2二维数组的引用

  • 假设定义二维数组为：
int a[][] = new int[][]{new int[5],new int[5],new int[5}
//逻辑上的维度为3行5列（c语言中为int a[3][5]）
  • 访问单个元素
a[0][1]=30;a[1][2]=80;a[2][4]=62;
  • 遍历所有元素
for(int i=0;i<a.length;i++)
    for(int j=0;j<a[i].length;j++)
        a[i][j]=xxx;

2.3二维数组内存布局(与c语言中的不同)

c语言中的二维数组，
实际上是由同长度的一维数组拼接而成的：内存是连续分布的
在这里插入图片描述
java中的二维数组
而java中的二维数组，其本身本质上是一一个一维数组，内存连续;但由于其每个元素本身是一个一维数组对象的引用(长度可以不相等)。因此其内存是由一段一段的一维数组“链接”而成。逻辑上是一个整体，但物理上并不连续:

int a[][] = new int[][]{new int[2],new int[4],new int[3]};

在这里插入图片描述

例子
1.设计一个N行N列的二维数组，将每个数组元素的值从N2
到1进行赋值，如a[0][0]= N^2, a[0][1]= N^2- 1,…a[N-1][N-1]=1。 并将结果打印出来。

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
//        1.设计一个N行N列的二维数组，将每个数组元素的值从N2
//        到1进行赋值，如`a[0][0]= N^2`, `a[0][1]= N^2- 1`,...`a[N-1][N-1]=1`。 并将结果打印出来。
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你想创建的正方形二维数组的行数：");
        int n = sc.nextInt();
        int[][] a = new int[n][];
//        注意记得初始化
        for(int i=0;i<n;i++){
            a[i] = new int[n];
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                a[i][j] = i*n+j;
            }
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                System.out.print(a[i][j]+" ");
            }
            System.out.println();
        }
    }
}

2.求二维数组(3行3列)的对角线元素的和
10,12,13
14,15,16
17,18,19

public class Main{
    public static void main(String[] args){
// 2.求二维数组(3行3列)的对角线元素的和
//10,12,13
//14,15,16
//17,18,19
        int sum=0;
        int[][] a = new int[][]{{10,12,13},{14,15,16},{17,18,19}};
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a[i].length;j++){
                if(i==j){
                    sum+=a[i][j];
                }
            }
        }
        System.out.println("对角线和为:"+sum);
    }
}

3.求二维数组(3行3列)的顶部元素的和
4.求二维数组(3行3列)的左部元素的和
5.求二维数组(3行3列)的外部元素的和
在这里插入图片描述

public class Main{
    public static void main(String[] args){
// 2.求二维数组(3行3列)的对角线元素的和
//10,12,13
//14,15,16
//17,18,19
//        3.求二维数组(3行3列)的顶部元素的和
//        4.求二维数组(3行3列)的左部元素的和
//        5.求二维数组(3行3列)的外部元素的和
        int sum=0;
        int[][] a = new int[][]{{10,12,13},{14,15,16},{17,18,19}};
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a[i].length;j++){
                if(i==j){
                    sum+=a[i][j];
                }
            }
        }
        System.out.println("对角线和为:"+sum);
        System.out.println("上边和："+sumup(a));
        System.out.println("左边和："+sumdown(a));
        System.out.println("边上一圈和："+sumout(a));

    }
    // 上边和
    static int sumup(int[][] a){
        int sumup1=0;
        for(int i=0;i<a[0].length;i++){
            sumup1+=a[0][i];
        }
        return sumup1;
    }

//左边和
    static int sumdown(int[][] a){
        int sumdown1=0;
        for(int i =0;i<a.length;i++){
            sumdown1+=a[i][0];
        }
        return sumdown1;
    }

//边上一圈和
    static int sumout(int[][] a){
        int sumout1=0;
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a[0].length;j++){
                if(i==0|j==0|i==a.length-1|j==a[0].length-1){
                    sumout1+=a[i][j];
                }
            }
        }
        return sumout1;
    }
}

6.求二维数组(5行5列)中最大元素值及其行列号。
7.将二维数组(5行5列)的右上半部分置零。
在这里插入图片描述

public class Main{
    public static void main(String[] args){
// 6.求二维数组(5行5列)中最大元素值及其行列号。
// 7.将二维数组(5行5列)的右上半部分置零。
        int[][] a = new int[][]{{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15},{16,17,18,19,20},{21,22,23,24,25}};
        int temp = a[0][0];
        int line=0,row=0;
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a[0].length;j++){
                if (temp<a[i][j]){
                    temp = a[i][j];
                    line = i+1;
                    row = j+1;
                }
            }
        }
        System.out.println("最大的元素是第"+line+"行第"+row+"列元素："+temp);


        //上半部分置零
        for(int i=0;i<a.length;i++){
            for(int j=i+1;j<a[0].length;j++){
                a[i][j]=0;
            }
        }
        for(int i=0;i<a.length;i++){
            for(int j=0;j<a[0].length;j++) {
                System.out.print(a[i][j]+" ");

            }
            System.out.println();
        }
        

    }
}

总结：

Exception in thread "main" java.lang.NullPointerException

上面这个错误是未进行初始化。

繁花郁晴
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java入门 数组
Reng17的博客
08-03 283
一、数组的概述 1、什么是数组？ 数组（Array），是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行同意管理。 2、数组的概念 数组名 下标（索引） 元素 数组的长度：元素的个数 3.数组的特点 ①数组是有序排列的。 ②数组属于引用数据类型的变量，数组的元素既可以是基本数据类型，也可以是引用数据类型。 ③创建数组对象会在内存中开辟一整块连续的空间。 ④数组的长度一旦确定，就不能修改，只能重新创建一个新的数组。 4.数组的分类 ①按照位数进行分类：一维数组、二维数组
java数组的定义
qq_53518630的博客
06-25 261
就是一个容器，用于在程序中储存一批同种类类型的数据格式1——数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3,....}格式2——数据类型[] 数组名称 ={元素1,元素2,元素3,....}特点：在定义数组的同时为数据确认了数据使用场景：一旦确认了书籍的具体值，我们就用这种方式储存批量数据数据类型[] 数值名称 = new 数据类型[长度];特点：一开始只确定数组的类型和长度，不确定具体存入数据值使用场景：合适做一开始不能确定具体数据的情况，先定义数组，后赋值数据进去格式：数据的名
java数组的定义与使用
最新发布
2201_76124988的博客
07-15 1048
数组：是相同类型元素的一个集合，在内存中是一段连续空间数组中存放的元素其类型相同数组的空间是连在一起的每个空间有自己的编号，起始位置的编号为0，即数组的下标。
java数组
u013349018的专栏
01-04 480
数组是有序数据的集合，数组中的每个元素具有相同的数组名和下标来唯一地确定数组中的元素        一、一维数组的定义 type arrayName[]; 其中类型(type)可以为Java中任意的数据类型，包括简单类型组合类型，数组名arrayName为一个合法的标识符，[]指明该变量是一个数组类型变量。例如： int intArray[]; 声明了一个整型数组，数组中
06-Java基础(数组-内存图解)
04-27
声明只是定义了数组变量，初始化则实际为数组分配内存空间并默认填充零值（对于数值类型）或空引用（对于对象类型）。 在内存模型中，数组被存储在堆内存（Heap Memory）中，每个数组元素都有一个连续的地址。数组...
Java数组中的元素删除并实现向前移的代码
09-02
- Java数组是预分配内存的空间，用来存储相同类型的数据。 - 数组的长度在声明时必须指定，一旦创建，不能改变。 - 数组的索引从0开始，到长度-1结束。 2. **删除数组元素**： - 在Java中，直接删除数组元素是...
详解java一维数组及练习题实例
08-25
` 声明、创建并初始化一个包含 3 个元素的数组。 * `int[] array3 = new int[] {1, 2, 3};` 声明、创建并初始化一个包含 3 个元素的整型数组。 * `int[] array4; array4 = {1, 2, 3};` 先声明一个数组 array4，再...
java编程基础—数组练习.docx
02-27
总的来说，这些练习涵盖了Java数组的基本操作，包括定义、初始化、遍历、复制、排序以及多维数组的处理，这些都是学习Java编程的基础。熟练掌握这些概念和方法对于理解和解决更复杂的编程问题至关重要。
java旋转二维数组实例
09-04
在给定的Java代码中，`Test6` 类定义了一个方法 `specArr` 用于生成螺旋填充的二维数组，并提供了 `arraynum` 方法来初始化数组的大小。`main` 方法调用 `arraynum` 来启动程序。`arrprint` 方法则用于打印二维数组...
Java数组定义
jiahui513的博客
01-17 432
情况一，先声明，再分配空间 类型[] 数组名; 数组名 = new 类型[长度]; 情况二，声明并分配空间 类型[] 数组名 = new 类型[长度]; 情况三，声明并赋值（全） 类型 数组名 = new 类型[]{数据1，数据n} 情况四，声明并赋值（简） 类型[] 数组名 = {数据1，数据n} ...
Java之数组的定义
热门推荐
qq_53190275的博客
11-09 2万+
数组
java中数组的定义
qq_23043541的博客
10-31 123
1. 一维数组 int[] arr = new int[3];//需要一个容器，但是暂时不给具体的数值 int[] arr = new int[3]{1,2,3};//直接给定具体数值 int[] arr = {1,2,3}//不创建数组对象，直接进行赋 　 2. 二维数组 int[][] arr = new int[3][2];//第一种 int[][] arr = new ...
java中数组的定义与初始化
qq_60797036的博客
09-26 1102
数组定义的格式：数组类型[] 数组名； 例如以下代码 int[] nums; nums=new int[10]; 或者可以把两者结合 int[] nums=new int[10]; 初始化分为两种类型： 静态初始化 静态初始化，最大的特点就是在定义的同时为数组赋值。例如以下代码 int[] nums={1,2,3,4}; 在定义数组时就决定了数组中各元素的值与数组大小。 动态初始化（包含默认初始赋值） 例如以下代码： int[] nums=new int[10]; 定义完数组
JAVA数组---------数组的定义
ThisIsSunshine的博客
03-17 1253
数组 【案例引导】 现在需要统计某公司员工的工资情况，例如计算平均工资、最高工资等。假设该公司50 名员工，用前面所学的知识，程序首先需要声明50个变量来分别记录每位员工的这样做 会显得很麻烦。在Java中，可以使用一个数组来记住这50名员工的工资。 数组是指一组数据的集合，数组中的每个数据被称作元素。 数组可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。 数组可分为一维数组和多维数组。 数组的定义 在Java中，可以使用以下格式来定义一个数组 int[] x = new int[100]
14 数组
qq_53537301的博客
03-21 881
数组 数组的定义 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成 其中,每一个数据称作一个数组元素每个数组元素可以通过一个下标来访问它们 数组声明创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法: dataType[] arrayRefVar; // 首选的方法 或 dataType arrayRefVar[]; // 效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下: dataType[] array
Java数组
m0_51725837的博客
07-18 64
Java数组 数组的定义 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成 其中，每一个数据称为一个数组元素，每个数组元素可以通过一个下标来访问它们 数组的声明和创建 首先必须声明数组变量，才能在程序中使用数组。 dataType[] arrayRefVar;//首选的方法 或者 dataType arrayRefVar[];//效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下： dataType[] arrayRefVa
数组
zhenhangsky的专栏
06-14 644
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值