java基础之 数组

什么是数组

数组是用来存储固定大小的同类型元素。

数组怎么写

格式：数据类型[] 数组变量名 = new 数据类型[数组长度];

栗子1：定义一个存放4个年龄的数组
int[] ages = new int[4];

栗子2：定义一个存放6个金额的数组
double[] prices = new double[6];

数组存值

数组变量名[数据的位置] = 值;

注意：在java中，数组的位置是从0开始的

ages[0] = 15;
ages[1] = 18;
ages[2] = 45;
ages[3] = 23;
System.out.println(Arrays.toString(ages));

//输出
[15, 18, 45, 23]

根据上面存储的数据，在java数组中的位置和数据对应的位置

0  1  2  3
15 18 45 23

数组的取值

数组变量名[数据的位置]

根据上面说明的位置，如果我们需要读取45这个数据，我们应该使用 ages[2]；

System.out.println(ages[2]);
// 控制台输出 45

如果我们读取了不存在的位置，程序就会报错；

例如ages的位置只有0~3，如果我们输入ages[4]，程序就会抛出 java.lang.ArrayIndexOutOfBoundsException 异常；

 System.out.println(ages[4]);

// 程序抛出异常
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4
	at test.ArrayTest.main(ArrayTest.java:42)

数组有什么用

我们在需要存放同类型的很多数据时，我们可以定义很多个变量，把这些值存起来。这样会使我们定义大量的变量，使得程序变得异常复杂而且不便于我们使用这个数组。这时我们就可以使用数组，把这些数据存在数组中。

例如：我们存储4个年龄

不用数组：

int age1 = 15;
int age2 = 18;
int age3 = 45;
int age4 = 23;

使用数组：

int[] ages = new int[4];
ages[0] = 15;
ages[1] = 18;
ages[2] = 45;
ages[3] = 23;

使用数组后，我们只要调用 ages 就可以操作这些数据，不用像第一个一样，只能根据每一个变量的名字去操作数据。

数组的长度

如果我们得到的数组是一个变量，我们需要知道数组的长度，防止我们读取到不存在的位置，这时我们可以使用 数组变量名.length 去获取到数组的长度。

System.out.println(ages.length);
// 输出 4

数据的静态初始化

数据类型[] 数组变量名 = {变量1,变量2,...变量n};

静态初始化的数据和普通方式设置的数据的使用方法是相同的。

栗子：我们修改ages为静态初始化方式

int[] ages = {15, 18, 45, 23};

数组的特点

• 数组的长度在创建时就固定了，不可进行修改。
• 数组存储的数据类型只能是同一种类型的，不允许出现混合类型。
• 数组的类型可以是任何类型，基本类型、引用类型都可以。
• 数组的变量是引用类型，它是存放在堆中的。

数据的循环

我们可以根据数组的下标（位置）来读取数组的元素。

如果我们需要读取全部的元素，这时我们就可以使用for循环来读取；

for (int i = 0; i < ages.length; i++) {
    System.out.print(ages[i] + " ");
}
System.out.println();
// 输出：15 18 45 23

在 jdk1.5+ 可以使用增强for循环来循环数组；

for (int age : ages) {
    System.out.print(age + " ");
}
System.out.println();
// 输出：15 18 45 23

多维数组

数组中可以存储基础类型的数据和引用类型的数据，而数组本身又是一个引用类型的数据，

所有我们可以把数组当做数据存到另外一个数组中，像这样的多层的存储数据，我们称之为多维数组，

数组有几层就称之为几维数组。

例如：我们定义5年龄数组，分别存放不同的年龄数据。

int[] ages1 = {10, 11, 12, 13, 14};
int[] ages2 = {20, 21, 22, 23, 24};
int[] ages3 = {30, 31, 32, 33, 34};
int[] ages4 = {40, 41, 42, 43, 44};

然后我们把这些数据放在一个名字叫 agess 的数组中。

数据的类型[] 表示的是数组，如果 数据的类型=int[]，那就变成int[][]了

int[][] agess = {ages1, ages2, ages3, ages4};
System.out.println(Arrays.deepToString(agess));
// 输出 
[[10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44]]

上面的写法我们可以把定义变量的操作去掉，直接在使用的地方替换为具体的值就变成下列的形式。

int[][] agess2 = {
    {10, 11, 12, 13, 14},
    {20, 21, 22, 23, 24},
    {30, 31, 32, 33, 34},
    {40, 41, 42, 43, 44}
};
System.out.println(Arrays.deepToString(agess2));
// 输出 
[[10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44]]

附录：测试代码

package test;

import java.util.Arrays;

/**
 * 数组测试
 *
 * @author lixin
 */
public class ArrayTest {

    public static void main(String[] args) {
        // 一、数组的定义
        // 格式：数据类型[] 数组变量名 = new 数据类型[数组长度];

        // 栗子1：定义一个存放4个年龄的数组
        int[] ages = new int[4];

        // 栗子2：定义一个存放6个金额的数组
        double[] prices = new double[6];

        // 二、数组的赋值
        // 数组变量名[数据的位置] = 值;
        // 注意：在java中，数组的位置是从0开始的
        ages[0] = 15;
        ages[1] = 18;
        ages[2] = 45;
        ages[3] = 23;
        System.out.println(Arrays.toString(ages));

        // 数组的位置和数据对应的位置
        // 0  1  2  3
        // 15 18 45 23

        // 三、数组的取值
        // 根据上面说明的位置，如果我们需要读取45这个数据，我们应该使用 ages[2]
        // 控制台就会输出 45
        System.out.println(ages[2]);

        // 如果我们读取了不存在的位置，程序就会报错
        // 例如ages的位置只有0~3，如果我们输入ages[4]，程序就会抛出 java.lang.ArrayIndexOutOfBoundsException 异常
        //System.out.println(ages[4]);

        // 四、数组的长度
        // 如果我们得到的数组是一个变量，我们需要知道数组的长度，防止我们读取到不存在的位置，这时我们可以使用
        // 数组变量名.length 这个属性去获取到数组的长度
        // 例如下列就输出 4
        System.out.println(ages.length);

        // 五、数组的循环
        // 我们可以根据数组的下标（位置）来读取数组的元素，
        // 如果我们需要读取全部的元素，这时我们就可以使用for循环来读取
        for (int i = 0; i < ages.length; i++) {
            System.out.print(ages[i] + " ");
        }
        System.out.println();
        // 输出：15 18 45 23

        // 在jdk1.5+ 可以使用增强for循环来循环数组
        for (int age : ages) {
            System.out.print(age + " ");
        }
        System.out.println();
        // 输出：15 18 45 23

        // 实例1：计算数组的和
        System.out.println("数组的和=" + sum(ages));

        // 实例2：查找最大的元素
        System.out.println("查找最大的元素=" + max(ages));

        // 实例3：反转数组
        int[] reverse = reverse(ages);
        for (int age : reverse) {
            System.out.print(age + " ");
        }
        System.out.println();
        // 输出：23 45 18 15

        // 多维数组
        // 数组中可以存储基础类型的数据和引用类型的数据，而数组本身又是一个引用类型的数据，
        // 所有我们可以把数组当做数据存到另外一个数组中，像这样的多层的存储数据，
        // 我们称之为多维数组，数组有几层就称之为几维数组。
        // 例如：我们定义5年龄数组，分别存放不同的年龄数据
        int[] ages1 = {10, 11, 12, 13, 14};
        int[] ages2 = {20, 21, 22, 23, 24};
        int[] ages3 = {30, 31, 32, 33, 34};
        int[] ages4 = {40, 41, 42, 43, 44};

        // 然后我们把这些数据放在一个名字叫 agess 的数组中
        // 数据的类型[] 表示的是数组，如果 数据的类型=int[]，那就变成int[][]了
        int[][] agess = {ages1, ages2, ages3, ages4};
        System.out.println(Arrays.deepToString(agess));

        // 上面的写法我们可以把定义变量的操作去掉，直接在使用的地方替换为具体的值就变成下列的形式
        int[][] agess2 = {
                {10, 11, 12, 13, 14},
                {20, 21, 22, 23, 24},
                {30, 31, 32, 33, 34},
                {40, 41, 42, 43, 44}
        };
        System.out.println(Arrays.deepToString(agess2));

    }

    /**
     * 计算数组的和
     *
     * @param ages 数组
     * @return 数组的和
     */
    public static int sum(int[] ages) {
        int sum = 0;
        for (int i = 0; i < ages.length; i++) {
            sum += ages[i];
        }
        return sum;
    }

    /**
     * 查找最大的元素
     *
     * @param ages 数组
     * @return 数组中最大的元素
     */
    public static int max(int[] ages) {
        int max = ages[0];
        for (int age : ages) {
            if (age > max) {
                max = age;
            }
        }
        return max;
    }

    /**
     * 反转数组
     *
     * @param ages 需要被反转的数组
     * @return 反转都的数组
     */
    public static int[] reverse(int[] ages) {
        int[] result = new int[ages.length];
        for (int i = 0; i < result.length; i++) {
            result[i] = ages[(ages.length - 1) - i];
        }
        return result;
    }
}