Java入门第一章第3节：Java数据类型-数组 实验+图解讲解

简介

继续第2节内容，我们现在开始讲Java的数组（精讲）

一、Java数据类型之数组

1、概念：

数组由同一类型的一连串对象或基本数据组成，并封装在同一数组名称下， 元素类型可以是 Java中任一类型

数组是对象

– 可动态初始化

– 可以赋值给 Object类型的变量

– 在数组中可以调用类 Object 的所有方法

                                                                                  可以简单抽象为这样的👉

2、数组的元素

数组元素

– 数组中的变量被称作数组的 元素

– 元素没有名字， 通过数组名字和非负整数下标值引用数组元素

– 每个数组都有一个由 public final 修饰的成员变量 length ，即数组含有元素的个数（ length 可以是正数或零）

3、数组的声明

• 声明（ Declaration ）

– 声明数组时无需指明数组元素的个数，也不为数组元素分配内存空间（和C/C++不一样的地方）

– 不能直接使用，必须经过初始化— 分配内存，后才能使用（请看下面的第4点）

①Type[ ] arrayName;  

例如：

int[]   intArray;//这里的“[]”就代表我们声明了一个inArray的整型数组

String[]    stringArray;//同理，声明的是一个stringArray的字符数组

②Type  arrayName[ ];  

例如：

int   intArray[]; //这里的“[]”也可以放在数组名的后面

String    stringArray[];

4、数组的创建

• 用关键字 new 构成数组的创建表达式，可以指定数组的类型和数组元素的个数。 元素个数可以是常量也可以是变量

• 基本类型 数组的每个元素都是一个基本类型的变量； 引用类型 数组的每个元素都是对象

• 基本类型

– 内存栈中保存的值就是该变量的 值

– Java 有八大基本类型：

• 整型（ 4 种）、浮点型（ 2 种）、字符型（1种）、布尔型（1种）

• 引用类型

– 内存栈中保存的值是指向变量值的 地址

– 类、数组等都是引用类型

• 基本类型和引用类型的主要区别：

– 基本类型的值 是分配在 栈 上的，而 引用类型的值 是分配在 堆 上的；

– 对于 引用类型的变量 ，栈中保存的仅仅是 变量的引用 （只使用地址）。

创建格式：arrayName=new Type[arrayLength];

– 例如：
int[] ai; //先声明

ai=new int[10];//然后创建
String[] s;//先声明

s=new String[3];//后创建

– 或者 可以将数组的声明和创建一并执行（常用）
int ai[]=new int[10];//直接声明+创建了一个长度为10的整型数组ai[10]

– 可以在一条声明语句中创建多个数组(能一条声明同类型的多个数组，不同类型的不建议这样)
String[]  s1=new String[3],  s2=new String[8];

5、数组元素的初始化

• 可以在声明数组时初始化，数组长度即固定为元素个数，例如：

int   a[ ] = { 22, 33, 44, 55 };//长度会自己识别，省事

• 也可以在数组创建之后给数组元素赋值，例如：上述语句相当于：

int   a[ ] = new   int[4];

a[0] = 22; a[1] = 33; a[2] = 44; a[3] = 55//这个和上一个是相等的操作结果

• 创建数组时，如果没有指定初始值，系统会为每一个元素赋默认值：

– 基本类型 ： 整型 （ 0 ） ；

                        浮点型（0.0）；

                        字符型（\u0000）；

                         布尔型（false）；

– 引用类型 ：默认值为 null （即元素为空值）

6、数组的引用

• 通过下面的表达式引用数组的一个元素：
arrayName [index] 即： 数组名 [ 下标 ]

例如当index=3时：arrayName[3]，引用的就是数组arrayName的第4个元素（下标从0开始）

• 下标可以是整型， 也可以是字符型 （ char ） char代表的是什么数就引用对于那个数的元素

• 下标从零开始计数

• 数组长度 ： 元素的个数 即为数组的长度，可以通过 arryName. length 引用

• 元素下标最大值为 length – 1 ， 如果 超过最大值，将会产生数组越界异常（ ArrayIndexOutOfBoundsException ）

例如：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        int myArray[];                  //声明数组
        myArray=new int[10];            //创建数组
        System.out.println("Index\t\tValue");
        for(int i=0; i<myArray.length;i++)
            System.out.println(i+"\t\t"+myArray[i]); //证明数组元素默认初始化为0
        //myArray[10]=100;      //将产生数组越界异常
    }
}

再来一个：

public class Main {
    public static void main(String[] args) {
        int[] a1 = { 1, 2, 3, 4, 5 };
        int[] a2;
        a2 = a1;
        for(int i = 0; i < a2.length; i++)
            a2[i]++;
        for(int i = 0; i < a1.length; i++)
            System.out.println( "a1[" + i + "] = " + a1[i] + "\t\t" + "a2[" + i + "] = " + a2[i]);

    }
}

运行结果为：

以上这个例子说明：数组名是一个引用——a2[ ]引用的是a1[ ]的，所以即使a2[ ]++也不会改变元素的值，这下是不是对数组的声明、创建和初始化有了更深的认识了？

如果还没有，接着往下看这两个例子👇：

7、知识补充：Arrays类

• Arrays 类包含一些实用的方法用于常见的数组操作，比如排序和查找。

• 位于 java.util 包中，使用时需要 import 引入。

• 常用方法：

– sort(a) // 对数组 a 中的所有元素排序

– sort(a, start, end) // 对数组 a 中， a[start]~a[end-1] 部分的元素排序

– parallelSort (a) // 同 sort(a) ，多处理器计算机可以提高效率

– parallelSort (a, start, end) // 同 sort(a, start, end) ，多处理器计算机可以提高效率

– binarySearch (a, key) // 从数组 a 中查找关键字 key ，返回 key 出现的位置， a 需要按升序排列

– equals(a, b) // 检测两个数组的内容是否相同，返回逻辑值

– fill(a, number) // 用 number 填充 a 数组

– fill(a, start, end, number) // 用 number 填充 a[start]~a[end-1] 部分的元素

其中sort（）默认是升序的，例如：

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] arr={1,4,3,6,7,9};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

若需要降序的，只需要在sort（）中加入Collections.reverseOrder()，同时将int类型转为Integer类型，例如

import java.util.Arrays;
import java.util.Collections;
public class Main {
    public static void main(String[] args) {
        Integer[] arr={1,4,3,6,7,9};
        Arrays.sort(arr,Collections.reverseOrder());
        System.out.println(Arrays.toString(arr));
    }
}

8、多维数组

int[ ][ ] gradeTable;

gradeTable[ 0 ][ 1 ] 为42

gradeTable[ 3 ][ 4 ] 为93

gradeTable[ 6 ][ 2 ] 为78

 ①二维数组的声明和创建

int[ ][ ] myArray ;

• myArray 可以存储一个指向 2 维整数数组的引用。其初始值为 null 。

int[ ][ ] myArray = new int[3][5] ;

• 建立一个数组对象，把引用存储到 myArray 。这个数组所有元素的初始值为零。

int[ ][ ] myArray = { {1,2,2,9}, {9,4,0,3}, {3,0,0,7} };

• 建立一个数组并为每一个元素赋值。

int[ ][ ] myArray = new int[3][ ] ;

• 建立一个数组对象，由 3 个一维数组组成， 3 个一维数组的维数（长度）可以不一样。

int[ ][ ] myArray ={ {1,9,4}, {0,2}, {0,1,2,3,4} };

• 建立一个数组并为每一个元素赋值。

②二维数组的长度

public class Main {
    public static void main(String[] args) {
        int[ ][ ] uneven = { { 1, 9, 4 }, { 0, 2}, { 0, 1, 2, 3, 4 } };
        System.out.println("Length is: " + uneven.length );
    }
}

求每行的长度：

public class Main {
    public static void main(String[] args) {
        // 声明并构造一个2维数组
        int[ ][ ] uneven = { { 1, 9, 4 },{ 0, 2},{ 0, 1, 2, 3, 4 }};
        // 数组的长度 (行数)
        System.out.println("Length of array is: " + uneven.length );
        // 数组每一行的长度（列数）
        System.out.println("Length of row[0] is: " + uneven[0].length );
        System.out.println("Length of row[1] is: " + uneven[1].length );
        System.out.println("Length of row[2] is: " + uneven[2].length );
    }
}

运行结果是：

如果代码太过抽象，那我们看看图解的：

结束语：

以上是Java入门的第3步，希望大家喜欢

下一节开始讲常用句型和表达式

喜欢的可以点赞+关注哈 ❤❤❤❤❤❤❤