带你粗略了解Java数组的使用

目录

  • 数组的定义
    • 注意:
  • 数组的创建及初始化:
    • 1.数组的创建:
    • 2.数组的初始化
      • ①动态初始化:
      • ②静态初始化:
    • 注意事项:
    • 数组的使用
      • 1.数组的长度:
        • 2.数组的访问:
          • 3.数组的遍历:
            • 4.使用数组交换两个整数
              • 5.以字符串的形式输出数组:
              • 理解引用类型:
                • 1.基本类型变量与引用类型变量的区别
                  • 2.认识null
                    • 3.数组作为方法的返回值
                    • 二维数组:
                      • 1.创建二维数组及初始化:
                        • 2.二维数组长度:
                          • 3.二维数组的打印:
                            • 4.不规则的二维数组:
                            • Array类:
                              • 总结

                                数组的定义 数组:可以看作相同类型元素的一个集合,且在内存中是一块连续的内存空间

                                注意:
                                C语言中,数组的内存在栈上

                                在Java中,数组的内存在堆上

                                数组的创建及初始化:
                                1.数组的创建:
                                基本语法格式:
                                T[ ] 数组名 = new T[N];
                                .
                                ① T,即Type,表示:数组中存放元素的类
                                ② T[ ], 表示:数组的类型
                                ③ N, 表示:数组的长度
                                举例:
                                创建一个可以容纳10个int类型元素的数组int[] array1 = new int[10]; 创建一个可以容纳5个double类型元素的数组double[] array2 = new double[5];


                                2.数组的初始化
                                数组的初始化主要分为动态初始化和静态初始化

                                ①动态初始化: 基本语法格式:
                                int[ ] array = new int[10]
                                在创建数组时,直接指定数组中元素的个数

                                ②静态初始化: 基本语法格式:
                                int[ ] array1 = new int[ ] {0,1,2,3,4,5,6};
                                double[ ] array2 = new double[ ]{1.0, 2.0, 3.0, 4.0,5.0};

                                注意事项:
                                • 如果没有对数组进行初始化,数组中元素有其默认值
                                【带你粗略了解Java数组的使用】如果数组中存储元素类型为基类类型,默认值为基类类型对应的默认值
                                如果数组中存储元素类型为引用类型,默认值为null
                                • 静态初始化无需指定数组的长度,编译器在编译时会根据{ }中元素个数来确定数组的长度
                                • 静态初始化时,{ }中数据类型必须与[ ]前数据类型一致、
                                • 静态初始化可以简写,省去后面的new T[ ]
                                • 如果不确定数组当中内容时,使用动态初始化,否则建议使用静态态初始化

                                数组的使用
                                1.数组的长度:
                                数组的长度属性: 每个数组都具有长度,而且是固定的,Java中赋予了数组的一个属性,可以获取到数组的长度,语句为:数组名.length
                                int[ ] array = new int[ ]{1,2,3,4,5,6};
                                int len = array.length;
                                此处的 length 是属性

                                2.数组的访问:
                                数组在内存中是一段连续的空间,空间的编号都是从0开始的,依次递增,该编号称为数组的下标,数组可以通过下标访问其任意位置的元素
                                索引:每一个存储到数组的元素,都会自动的拥有一个编号,从0开始,这个自动编号称为数组索引 (index),可以通过数组的索引访问到数组中的元素
                                由数组的长度知,属性 length 的执行结果是数组的长度,int类型结果,则数组的最大索引值为数组名.length-1
                                格式:
                                数组名[索引]
                                数组名[索引] = 数值,为数组中的元素赋值变量 = 数组名[索引],获取出数组中的元素
                                public static void main(String[] args) { //定义存储int类型数组,赋值元素1,2,3,4,5 int[] arr = {1,2,3,4,5}; //为0索引元素赋值为6 arr[0] = 6; //获取数组0索引上的元素 int i = arr[0]; System.out.println(i); //直接输出数组0索引元素 System.out.println(arr[0]); }

                                注意事项:
                                • 数组是一段连续的内容空间,因此支持随机访问,即通过下标访问快速访问数组中任意位置的元素
                                • 下标从0开始,介于[0, N) 之间不包含N,N为元素个数,不能越界,否则会报出下标越界异常

                                3.数组的遍历:
                                “遍历”:是指将数组中的所有元素都访问一遍

                                这里用打印的方式展示遍历:
                                int[] array = new int[]{1,2,3,4,5,6}; int len = array.length; for(int i=0; i
                                延申:

                                Java中的打印方式,出了上述的,还有foreach,即:for( 遍历的数组内容 :数组本身)

                                代码如下:
                                for (int val:array) { System.out.println(val+" "); }

                                二者区别:

                                for循环遍历打印数组,需要索引,而foreach不需要,若单纯的想要遍历数组,用foreach即可

                                4.使用数组交换两个整数
                                //使用数组实现交换两个整数public static void swap(int[] array){int tmp = array[0]; array[0] = array[1]; array[1] = tmp; }public static void main(String[] args) {int[] array1 = {10,20}; System.out.println("交换前:"+array1[0]+" "+array1[1]); swap(array1); System.out.println("交换后:"+array1[0]+" "+array1[1]); }

                                输出结果:
                                交换前:10 20
                                交换后:20 10

                                交换原理:
                                带你粗略了解Java数组的使用
                                文章图片


                                5.以字符串的形式输出数组:
                                使用方法toString 需要调用包 java.util.Arrays
                                int[] arr = {1,2,3,4,5,6}; String ret = Arrays.toString(arr); System.out.println(ret);


                                理解引用类型:
                                1.基本类型变量与引用类型变量的区别
                                基本数据类型创建的变量,称为基本变量,该变量空间中直接存放的是其所对应的值;
                                引用数据类型创建的变量,一般称为对象的引用,其空间中存储的是对象所在空间的地址
                                public static void func() {int a = 10; int b = 20; int[] arr = new int[]{1,2,3}; }

                                在上述代码中:a,b,arr,都是函数内部的变量,因此其空间都在main方法对应的栈帧中分配;

                                a、b是内置类型的变量,因此其空间中保存的就是给该变量初始化的值。

                                array是数组类型的引用变量,因为都为引用其内部保存的是数组在堆空间中的首地址

                                带你粗略了解Java数组的使用
                                文章图片


                                引用变量并不直接存储对象本身,而存储的是对象在堆中空间的起始地址,通过该地址,引用变量便可以去操作对象。有点类似C语言中的指针,但是Java中引用要比指针的操作更简单

                                2.认识null
                                null 在 Java 中表示 “空引用”,也就是一个不指向对象的引用,即:空对象
                                int[ ] arr = null; //arr引用的是一个空对象
                                System.out.println(arr[0]);
                                此处不能访问0下标,因为没有所指对象
                                null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置,因此不能对这个内存进行任何读写操作,Java 中并没有约定 null 和 0 号地址的内存有任何关联

                                3.数组作为方法的返回值
                                将一个数组内容扩大二倍:
                                public static int[] fun(int[] array){ int[] tmp = new int[array.length]; for (int i = 0; i
                                二维数组: 二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组

                                即:数组的数组就是一个二维数组
                                语法格式:
                                数据类型[ ][ ] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };
                                带你粗略了解Java数组的使用
                                文章图片


                                1.创建二维数组及初始化:
                                int[][] array1 = new int[10][10]; int array2[][] = new int[10][10]; int array3[][] = { { 1, 1, 1 }, { 2, 2, 2 } }; int array4[][] = new int[][] { { 1, 1, 1 }, { 2, 2, 2 } };


                                2.二维数组长度:
                                // 获取二维数组的第一维长度(3)int len1 = array.length; // 获取二维数组的第一维的第一个数组长度(1)int len2 = array[0].length;

                                进行开发之中,出现二位数组的几率并不高

                                3.二维数组的打印:
                                • 方法① foreach
                                int[][] array = { {1,2,3}, {4,5,6} }; for (int[] tmp : array) {for (int x: tmp) {System.out.print(x+" "); }System.out.println(); }

                                • 方法② for循环
                                for (int i = 0; i < array.length; i++) { for (int j = 0; j < array[i].length; j++) {System.out.print(array[i][j]+" "); } System.out.println(); }

                                打印结果:
                                带你粗略了解Java数组的使用
                                文章图片

                                • 方法③ deeptoString
                                int[][] array = {{1, 2, 3}, {4, 5, 6}}; System.out.println(Arrays.deepToString(array));

                                打印结果:
                                带你粗略了解Java数组的使用
                                文章图片


                                4.不规则的二维数组:
                                int[ ][ ] array = new int[2][ ];

                                注意:C语言中是可以指定列,行可自行推导;Java中,行必须指定,列是不可以自动推导的
                                此时若用上述 for 循环来打印数组,便会出现异常:
                                带你粗略了解Java数组的使用
                                文章图片


                                分析如下:
                                带你粗略了解Java数组的使用
                                文章图片


                                Array类: java.util.Arrays 类提供的所有方法都是静态的,能方便地操作数组,
                                由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。

                                Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用 (注意:是"不用"而不是"不能")

                                Array具有的功能这里就不一一列举了,可以去JDK帮助文档自行了解

                                总结 本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注脚本之家的更多内容!

                                  推荐阅读