一文让你学会Java中的一维数组和二维数组

简介: 本文比较偏向基础,适合初学者观看学习。本文主要介绍了一维数组的动态初始化、静态初始化、访问数组元素进行获取、访问数组元素进行赋值、数组索引越界异常、空指针错误、数组的遍历输出、数组的优点和缺点以及 二维数组的静态初始化和动态初始化和二维数组的遍历,并且文中会通过小练习让你对数组的理解更加深刻。本文较长,还请耐心观看,希望能帮到您。

数组

数组的概念:是一种容器,可以同时存放多个数据值。

数组的特点:
1.数组是一种引用数据类型
2.数组当中的多个数据,类型必须统一
3.数组的长度在程序运行期间不可改变
数组初始化:在内存当中创建一个数组,并且向其中赋予一些默认值。

动态初始化

动态初始化(指定长度):在创建数组的时候,直接指定数组当中的数据元素数。

动态初始化基本格式:
数据类型 [] 数组名称 = new 数据类型[数组长度];

解析含义:
左侧数据类型:也就是数组当中保存的数据,全部都是统一的类型
左侧的中括号:代表我是一个数组。
左侧数组名称:给数组取个名字。
右侧new:代表创作数组的动作。
右侧的数据类型:必须和左边的数据类型保持一致。
右侧中括号的长度:也就是数组当中,到底可以保存多少个数据,是一个int数字。

例如:


public class 动态初始化 {
    public static void main(String[] args) {
        // 格式:数据类型[] 数组名称 = new 数据类型[数组长度];
        //创建一个数组,里面可以存放300个int数据
        int [] arrayA = new int[300];

         //创建一个数组,能存放10个double类型的数据
        double [] arrayB = new double[10];

        //创建一个数组,能存放5个字符串
        System[] arrayC = new System[5];

    }
}

静态初始化

静态初始化(指定内容):在创建数组的时候,不直接指定数据个数多少,而是直接将具体的数据内容进行指定。

静态初始化基本格式:
数据类型 [] 数组名称 = new 数据类型 [] { 元素1,元素2, …. };

注意事项:
虽然静态初始化没有直接告诉长度,但是根据大括号里面的元素具体内容,也可以自动推算出来。

例如:

public class 静态初始化 {
    public static void main(String[] args) {
        //直接创建一个数组,里面装的全部都是int数字,具体为: 5、15、25
        int[] arrayA =new int[] { 5,15,25 };

        //创建一个数组,用来装字符串:"hello"、"world"、"java"
        String[] arrayB = new String[] {"hello","world","java"};
    }
}

静态初始化省略格式:

标准格式:数据类型 [] 数组名称 = new 数据类型 [] { 元素1,元素2, …. };

省略格式:数据类型 [] 数组名称 = { 元素1,元素2, …. };

注意事项:

  1. 静态初始化没有直接指定长度,但仍然会自动推算得到长度。
  2. 静态初始化标准格式可以才分为两个步骤。
  3. 动态初始化也可以拆分成为两个步骤。
  4. 静态初始化一旦使用省略格式,就不能拆分为两个步骤了。

使用建议:如果不确定数组当中的具体内容,用动态初始化;否则,已经确定了具体内容,用静态初始化。

例如:

public class 静态初始化 {
    public static void main(String[] args) {
        //省略格式的静态初始化
        int[] arrayC = {10,20,30};

        //静态初始化的标准格式,可拆分成为两个步骤
        int[] arrayD;
        arrayD = new int[]{1,2,3};

        //动态初始化也可以拆分为两个步骤
        int[] arrayE;
        arrayE = new int[5];
        
    }
}

访问数组元素进行获取

直接打印数组名称,得到的是数组对应的内存地址哈希值。

访问数组元素的格式: 数组名称[索引值];

索引值:就是一个int数字,代表数组当中元素的编号。

注意:索引值从0开始,一直到数组的长度-1为止。

例如:

public class 访问数组元素进行获取 {
    public static void main(String[] args) {
        //静态初始化的省略格式
        int[] array = {10,20,30};
        
        //直接打印数组当中的元素
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);

        //也可以将数组当中的某一个单个元素,赋值交给变量
        int num = array[0];
        System.out.println(num);
    }
}
执行结果: 10  
          20  
          30 
          10

访问数组元素进行赋值

使用动态初始化数组的时候,其中的元素将会自动拥有一个默认值。

规则如下:
如果是整数类型,那么默认为0;
如果是浮点类型,那么默认为0.0;
如果是字符类型,那么默认为’\u00000’;
如果是布尔类型,那么默认为false;
如果是引用类型,那么默认为null;

注意事项:
静态初始化其实也有默认值的过程,只不过系统自动马上将默认值替换成为了大括号当中的具体数值。

例如:

public class 访问数组元素进行赋值 {
    public static void main(String[] args) {

        //动态初始化一个数组
        int [] arrayA = new int[3];
        System.out.println(arrayA);//内存地址哈希值
        System.out.println(arrayA[0]);//0
        System.out.println(arrayA[1]);//0
        System.out.println(arrayA[2]);//0

        //将数据123赋值交给数组arratA当中的1号元素
        arrayA[1]=123;
        System.out.println(arrayA[0]);//0
        System.out.println(arrayA[1]);//123
        System.out.println(arrayA[2]);//0
    }
}

执行结果:
[I@7c30a502]
0
0
0
0
123
0

数组索引越界异常

如果访问数组元素的时候,索引编号并不存在,那么将会发生数组索引越界异常
ArrayIndexOutOfBoundsException

原因:索引编号写错了。
解决:修改成为存在的正确索引编号。

例如:

   public static void main(String[] args) {
        int[] aa = {1,2,3,4};
        System.out.println(aa[4]);
    }
    
执行结果:
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4

报错原因分析:因为索引是从0开始的,aa数组中,第四个元素不存在,所以aa[4]时会报错。

空指针错误

    /*
所有的引用类型变量,都可以赋值为一个null值。但是代表其中什么都没有。
数组必须进行new初始化才能使用其中的元素。如果只是赋值了一个null,没有进行new创建那么将会发生:
空指针异常NullPointerException
原因:忘了new
解决:补上new
*/
    public static void main(String[] args) {

        int[] array = null;
        // array=new int[3];
        System.out.println(array[0]);
    }
    输出结果:Exception in thread "main" java.lang.NullPointerException

情况2:
1、没有对你new出来的对象进行实例化,或者你去数据库里查询一个空的对象,就是空指针
2、空指针的异常NullPointer 无非是因为对象为null的情况下去调用该对象所拥有的方法或者成员变量造成的
解决办法:在调用有可能为空的变量的时候,最好做一下非空的判断。

获取数组长度

格式:数组名称.length;
这将会得到一个int数字,代表数组的长度

例如:

    public static void main(String[] args) {
        int[] arrayA = new int[3];

        int[] arrayB = {1,2,3,4,5,32,2,3,2,45,5,2,5,2,4,2,2,4,2,66};
        int len = arrayB.length;
        System.out.println("arrayB数组的长度是"+len);
    }

注意:数组一旦创建,程序运行期间,长度不可以改变。
例如下列代码:它的长度只要你new了,就永远是3,只要你new了,就永远是5,除非你创建一个新的,否则老数组是几,永远是几,长度不能发生改变。

    public static void main(String[] args) {
        int[] arrayC = new int[3];
        System.out.println(arrayC.length);//3
        arrayC = new int[5];
        System.out.println(arrayC.length);//5

    }

数组的遍历输出

遍历数组,说的就是对数组当中的每个元素进行逐个、挨个处理。默认的处理方式就是打印输出。

例如:

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};

        //首次使用原始的方式
        System.out.println(array[0]); //1
        System.out.println(array[1]); //2
        System.out.println(array[2]); //3
        System.out.println(array[3]); //4
        System.out.println(array[4]); //5

        //使用循环,次数其实也就是数组的长度。
        for (int i = 0; i < 5; i++) {
            System.out.println(array[i]);
        }

        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

小练习

求数组最值

最大值获取:从数组的所有元素中找出最大值。
实现思路:
1 定义变量,保存数组0索引上的元素
2 遍历数组,获取出数组中的每个元素
3 将遍历到的元素和保存数组0索引上值的变量进行比较
4 如果数组元素的值大于了变量的值,变量记录住新的值
5 数组循环遍历结束,变量保存的就是数组中的最大值

最大值例:

    public static void main(String[] args) {
        int[] array = {5,15,30,20,100000};

        int max =array[0];  
        for (int i = 1; i < array.length; i++) {
            // 如果当前元素,比max更大,则换
            if (array[i] > max){
                max=array[i];
            }

        }
        System.out.println("最大值是:"+max);
        
    }

最小值例:

    public static void main(String[] args) {
        int[] array2 = {5,15,30,20,100000,4,1};

        int min =array2[0];  
        for (int i = 1; i < array2.length; i++) {
            // 如果当前元素,比min更小,则换
            if (array2[i] <min){
                min=array2[i];
            }
        }
        System.out.println("最小值是:"+min);


    }

数组的优点和缺点

1.1、数组的优点和缺点,并且要理解为什么。
第一:空间存储上,内存地址是连续的。
第二:每个元素占用的空间大小相同。
第三:知道首元素的内存地址。
第四:通过下标可以计算出偏移量。
通过一个数学表达式,就可以快速计算出某个下标位置上元素的内存地址,直接通过内存地址定位,效率非常高。
优点:检索效率高。
缺点:随机增删效率较低,数组无法存储大数据量。
注意:数组最后一个元素的增删效率不受影响。

二维数组

二维数组的静态初始化和动态初始化

静态初始化:
int[][] arr = {
    {1,2,34},
    {54,4,34,3},
    {2,34,4,5}
};
Object[][] arr={
    {new Object(),new object()},
    {new Object(),new object(()},
    {new object(),new object(),new object()}
};
动态初始化:
int [][] arr= new int[3][4];
Objeat [][] arr=new object[4][4]; 
Animal [][] arr=new Animal[3][4];
//Person类型数组,里面可以存储Person类型对象,以及Person类型的子类型都可以。 
Person [][] arr = new Person[2][2];
....

二维数组的遍历

for(int i=0;i<arrlength;i++){//外层for循环负责遍历外面的一维数组
    //里面这个for循环负责遍历二维数组里面的一维数组。 
    for(int j=o;j<arr[i].length;j++){
        System.out.print(arr[i][j]);
    }
    // 换行。
    system.out.println();
}
相关文章
|
27天前
|
Java
环形数组链表(java)
环形数组链表(java)
11 0
|
21天前
|
存储 算法 搜索推荐
Java中的数组函数库及其使用技巧
Java中的数组函数库及其使用技巧
|
21天前
|
存储 Java 容器
Java数组的初始化方法
Java数组的初始化方法
|
20天前
|
存储 Java 索引
Java数组操作:基础与进阶指南
Java数组操作:基础与进阶指南
|
13天前
|
Java Apache Maven
Java:commons-codec实现byte数组和16进制字符串转换
在上述代码中,`Hex.encodeHexString(bytes)`用于将byte数组转换为16进制字符串,`Hex.decodeHex(hexString)`用于将16进制字符串转换为byte数组。
13 0
|
14天前
|
Java Apache Maven
Java:commons-codec实现byte数组和16进制字符串转换
在上述代码中,`Hex.encodeHexString(bytes)`用于将byte数组转换为16进制字符串,`Hex.decodeHex(hexString)`用于将16进制字符串转换为byte数组。
17 0
|
21天前
|
Java 索引
解决Java中的数组越界异常的技术
解决Java中的数组越界异常的技术
|
21天前
|
Java
【Java】程序练习1(数组)
【Java】程序练习1(数组)
|
22天前
|
存储 算法 Java
Java中常用的数组函数及其应用场景
Java中常用的数组函数及其应用场景
|
27天前
|
机器学习/深度学习 算法 搜索推荐
Java数组(3)
Java数组(3)
36 0