首页 > 编程学习 > 数组的定义与使用

数组的定义与使用

发布时间:2022/11/13 0:52:00

文章目录

  • 数组的基本概念
    • 为什么要使用数组
    • 什么是数组
    • 数组的创建及初始化
      • 数组的创建
      • 数组的初始化
    • 数组的使用
      • 数组中元素的访问
      • 遍历数组
  • 数组是引用类型
    • 基本数据类型与引用类型变量的区别
    • 认识null
  • 数组的应用场景
    • 保存数据
    • 作为函数的参数
      • 参数传基本数据类型
      • 参数传数组类型
    • 作为函数的返回值
  • 数组练习
    • 数组转字符串
    • 数组拷贝
  • 二维数组

数组的基本概念

为什么要使用数组

假设我们要储存五名同学的数学成绩,并对其进行输出,

public class Test {


    //为什么要使用数组
    public static void main(String[] args) {
        int student1 = 89;
        int student2 = 82;
        int student3 = 68;
        int student4 = 90;
        int student5 = 73;
        System.out.println(student1);
        System.out.println(student2);
        System.out.println(student3);
        System.out.println(student4);
        System.out.println(student5);
    }
}

在这种情况下,我们发现我们需要重复的创建变量,这大大降低了我们写代码的效率。我们发现这些数据的类型是相同的,这时我们就可以使用变量。

什么是数组

数组:相同类型元素大的一个集合。 在内存中是一段连续的空间。
【数组的特点】

  • 数组中存放的元素类型相同;
  • 数组的空间的是连在一起的;
  • 每个空间都有自己单独的编号,其初始位置是0,即数组的下标。

那么我们如何创建数组呢?

数组的创建及初始化

数组的创建

T[] 数组名 = new T[N];

T:表示数组存放元素的类型
T[]:数组的数据类型;
N:表示数组的长度。

【数组创建的示例】

//数组创建的示例
    public static void main(String[] args) {
        int[] array2 = new int[5];
        double[] array3 = new double[3];
    }

数组的初始化

数组的初始化主要分为两种类型:动态初始化和静态初始化

  1. 动态初始化:在创建数组的时候,直接指定数组中元素的个数

int[] array = new int[10];

  1. 静态初始化:在创建数组时不直接指定数据元素个数,而直接将具体的数据内容进行指定

int[] array = new int{1,2,3,4,5,6};
int[] array = {1,2,3,4,5,6};

【注意事项】

  • 静态初始化虽然没指定数组的长度,编译器在编译时会根据{}中的元素个数来确定数组的长度;
  • 静态初始化时,{}中数据类型必须与[]前数据类型一致;
  • 静态初始化可以简写,省略后面的new T[]. (但是在编译器编译代码时还是会还原,自动加上省略的部分);
  • 数组也可以按照C语言一样创建数组,但是我们不会去使用这种方法,但是语法是支持的。

int[] array = new int[5];
int array[] = new int[5]; //语法支持,但不推荐;
int array[5] = new int[5];//语法不支持

  • 静态和动态初始化可以分为两步,但是不可以省略格式;

int[] array1;
array1 = new int[10];
int[] array2;
array2 = new int[]{10,20,30};
//array2 = {1,2,3} 这种格式是错误的。

  • 如果没有对数组进行初始化,数组中元素有其默认值,1. 如果数组中储存元素类型为基类类型,默认为基类类型对应的默认值:比如:byte\short\int\long 类型默认值为 0float 默认值为 0.0f double 默认值为 0.0char 类型默认值为 /u0000, ***boolean 默认值为 false ***. 2.如果数组中储存元素类型为引用类型,其默认值为 null

数组的使用

数组中元素的访问

//数组元素的访问
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

【注意事项】

  1. 数组是一段连续的内存空间,因此支持随机访问,即通过下标可快速访问任意元素
  2. 下标从0开始,介于[0,N)

遍历数组

遍历:是指将数组中的所有元素都访问一遍。
【三种遍历数组的方法】

//数组元素的访问
    public static void main(String[] args) {
        int[] array = new int[]{1,2,3,4,5};
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        for (int x: array) {
            System.out.println(x);
        }
        System.out.println(Arrays.toString(array));
    }

第一种遍历的方式,我们能够轻松理解;
第二种我们可以使用 for-each 遍历数组;
第三种我们可以使用 java 提供的包内的方法来遍历数组。
在这里插入图片描述

数组是引用类型

基本数据类型与引用类型变量的区别

基本变量:基本数据类型所创立的变量,空间存放的是所对应的值;
引用变量:引用数据类型说创建的变量,其空间中储存的是对象所在空间的地址。

//基本数据类型和引用数据类型所存放的位置
    public static void main(String[] args) {
        int a = 29;
        int b = 99;
        double[] array = new double[]{3.14, 1.56, 4.99};
    }

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

  • a\b都是内置类型的变量,其空间中储存的都是该变量的值。
  • array是数组类型的引用变量,其内部保存的内容可以简单理解成是数组在堆空间中的首地址。
    在这里插入图片描述
    引用变量不直接储存数据的值,而是在堆区开辟新的空间,在堆区存放数据,而在栈中存放对应堆区的地址。

认识null

***null 在Java中表示“空引用”,也就是一个不指向对象的引用。

//null
    public static void main(String[] args) {
        int[] array = null;
        System.out.println(array[0]);
    }

在这里插入图片描述
null 的作用类似于C语言的空指针,都是表示一个无效的内存地址,如果我们对它进行操作会导致空指针异常问题(NullPointerException)

Java中没有约定 null 与 0 号地址有任何关系。

数组的应用场景

保存数据

//数组的应用场景 保存数据
    public static void main(String[] args) {
        int[] students = {99, 100, 66};
        for (int x: students) {
            System.out.print(x + " ");
        }
    }

作为函数的参数

参数传基本数据类型

  //参数传基本数据类型
    public static int func(int num) {
        num = 0;
        return num;
    }

    public static void main(String[] args) {
        int num = 20;
        func(num);
        System.out.println(num);
    }

在这种情况下,形参只是实参的临时拷贝,我们修改形参的值,并不会影响实参。

参数传数组类型

    //参数传数组类型
   public static int[] func (int[] array) {
       for (int i = 0; i < array.length; i++) {
           array[i] = i;
       }
       return array;
   }

   public static void main(String[] args) {
       int[] array = {10, 20, 30};
       func(array);
       for (int x: array) {
           System.out.print(x + " ");
       }
   }

我们发现,如果对引用类型进行数值上的修改,数组的内容会真的改变。
总结:所谓的引用本质上只是存了一个地址。Java中将数组设定成引用类型,这样的话后续进行数组参数传参,***其实只是将数组的地址传到函数的形参当中,但是使用的仍让是堆上相同的空间。
在这里插入图片描述

作为函数的返回值

示例:获取斐波那契数列的前N项

 //作为方法的返回值 获取斐波那契数列的前N项
    public static int[] fibonacci (int num) {
        int[] array = new int[num];
        array[0] = 1;
        array[1] = 1;
        for (int i = 2; i < num; i++) {
            array[i] = array[i-1] + array[i-2];
        }
        return array;
    }

    public static void main(String[] args) {
        int n = 9;
        System.out.println(Arrays.toString(fibonacci(n)));
    }

数组练习

数组转字符串

 //数组转字符串
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50};
        String str = Arrays.toString(array);
        System.out.println(str);

    }

Java中提供了 Java.util.Arrays 包,其中包含了一些操作数组的常用方法。

数组拷贝

//数组拷贝
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50, 60};
        //copyOf 方法进行拷贝,并会建立一个新的数组
        int[] newArr1 = Arrays.copyOf(array, array.length);
        System.out.println(Arrays.toString(newArr1));
        //拷贝某个范围
        int[] newArr2 = Arrays.copyOfRange(array, 2, 5);
        System.out.println(Arrays.toString(newArr2));
    }

二维数组

二维数组本质上就是一维数组,只不过每个元素又是一个一维数组。
【基本语法】

数据类型[][] 数组名称 = new 数据类型[行数][列数]{初始化数据类型};

【代码示例】

 //二维数组
    public static void main(String[] args) {
        int[][] array1 = {{1,2}, {3,4}};
        int[][] array2 = new int[][]{{1,2}, {3,4}};
        int[][] array3 = new int[2][2];
        int[][] array4 = new int[2][];
    }

二维数组创建的方式有四种,第一种和第二种直接初始化,第三种和第四种指定元素的个数,但不能初始化,这里与C语言有点不一样,Java中不要指定列数,指定相应的行数即可
二维数组我们在此处只做简单的了解。

Copyright © 2010-2022 dgrt.cn 版权所有 |关于我们| 联系方式