Java中数组的定义和使用

数组的基本用法

1、什么是数组

数组的本质上，就是让我们能“批量”创建相同类型的变量。即：相同类型的集合。

注意:在Java中，数组中包含的变量必须是相同类型。

2、数组的定义

2.1创建数组：

//动态初始化
数据类型[ ] 数组名称 = new 数据类型 [ ] { 初始化数据 }；

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

//静态初始化
数据类型[ ] 数组名称 = { 初始化数据 }；

int [] arr ={1,2,3,4,5};

还有一种：
数据类型[ ] 数组名称 = new 数据类型 [ 数组长度 ];
这种数组，里面都是类型所对应的==“0”值==

int [] arr = new int [5] ;

2.2类型所对应的“0”值

在没有规定的情况下：

类型	“0”值
byte/short/int	0
long	0L
float	0.0F
double	0.0
boolean	false
char	0x0000对应的字符
引用类型	null

3、数组的使用

3.1获取长度，访问元素

我们通常使用 数组名 . length 获取数组的长度
使用 [ ] 下标访问符，获取数组中的元素。
Java中，数组下标，从0开始。

public class Demo1 {

    public static void main(String[] args) {

        int[] arr = {1, 2, 3, 4, 5};

        int a = arr.length;
        System.out.println(a);//数组的长度
        System.out.println(arr[0]);//打印0号下标数据
    }
}

3.2 下标越界问题

下标的访问操作的范围是 [0 , length-1],如果超过这个范围，就会出现下标越界异常。

public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        System.out.println(arr[5]);//访问5号下标，可是5号下标并没有
    }

这里，访问下标越界。
抛出了：Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException异常。当我们使用数组的时候，一定要谨防下标越界。

3.3 遍历数组

遍历数组指的是，将数组中的每个元素都访问一遍，不重不漏，通常需要使用循环。

for循环遍历

public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

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

for-each遍历数组

for-each是for循环的另一种使用方式，能够快捷方便的完成对数组的遍历，避免循环条件的写错。
for-each的语法格式
for（数组类型对应的类型 ： 数组名）{…};

public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};     
        for (int x : arr) {
            System.out.print(x + " ");
        }
    }

两种遍历的比较

如果访问全部数组，for-each更加方便快捷，避免了循环条件的写错等…
但是如果只访问部分区间，那么for循环更加适合。
两种遍历各有优势，在不同情况下使用。

4、二维数组

二维数组的本质就是一维数组，只不过每个元素又是一个一维数组。

基本语法：
数据类型[][] 数组名称 = new 数据类型 [行数] [列数] {初始化数据}；
数据类型[][] 数组名称 = {初始化数据}；

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

二维数组的用法与一维数组基本类似，在这里就不过多的赘述了。同理还存在三维数组，四维数组…

不同角度理解：

一维数组就像是定义了一个引用，将引用指向这个对象（数组）。

而在二维数组中，就像是先定义一个arr的引用，指向一个int[]的数组，数组里面存放的是引用，里面的引用指向一个一维数组：

不规则使用：

注意：

Java的数组中，还存在着不规则结构，
在C语言中，数组的行是可以自动推导的，列必须指定。
但是在Java中，列可以自动推导，但行必须指定。
例如：

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

二维数组的遍历：

对于二维数组的遍历：
1、通过调用Arrays.toString(),对一维数组的打印，打印二维数组：

import java.util.Arrays;
public class Demo1 {
    public static void main(String[] args) {
        int[][] a = {{1, 2, 3,4}, {4, 5, 6}, {7, 8, 9}};
        print(a);
    }

    private static void print(int[][] a) {
        for (int[] ints : a) {
            System.out.println(Arrays.toString(ints));
        }
    }
}

2、调用deepToString（）：
调用Arrays.deepToString(),可以理解为深度打印，可以打印二维数组：

public class Demo1 {
    public static void main(String[] args) {
        int[][] a = {{1, 2, 3,4}, {4, 5, 6}, {7, 8, 9}};
       // print(a);
        System.out.println(Arrays.deepToString(a));
    }
}

5、数组的练习：

以前写过了，可以通过下面的链接，进去看看数组的练习题：

冒泡排序

二分查找

Arrays的3中常见用法