【JavaSE基础】5、数组

8.数组

8.1 数组的定义与声明

8.1.1 一维数组的定义与声明

基本理论：

1、数组中存放相同的数据类型的数据。

2、数组要指定长度，才能为其分配空间。

3、数组的读写（访问）方式，可以使用数组的下标访问，下标的访问为[0, 长度-1]

代码示例：

@Test
public void test01() {
    // 第一种方案：先声明再赋值
    // 第一步：先声明数组
    int[] a = new int[5];       // 5：代表只能存放5个整数，并且开辟了5个整数的内存空间，5x4 = 20字节,数组下标从0开始，下标范围只能是[0,数组长度-1]
    // 第二步：为数组赋值
    a[0] = 'b';
    a[1] = 1;
    a[2] = 5;
    a[3] = 100;
    a[4] = 9;
    // a[5] = 18;               // ArrayIndexOutOfBoundsException: 超过了数组下标范围，出现：数组下标越界异常
    System.out.println(a[0]);

    // 第二种方案：声明的同时为其赋值：
    int[] b = new int[]{1, 2, 3};       // 正确的声明并赋值方式，这种方式不要自己指定长度，让系统自己计算，此时数组的个数是3个
    int[] c = {1, 2, 3, 4, 5};          // 正确的声明并赋值方式，简化版的，开发中经常使用,此时数组个数为5个
    // c[5] = 10;               // 不能赋值,下标越界 ArrayIndexOutOfBoundsException
}

8.1.2 二维数组的定义与声明

代码示例：

@Test
public void test02(){
    // 1、声明一个二维数组
    int[][] a = new int[3][];           // 第一个中括号里面的数字代表行数，第二个中括号里面的数字代表列数
    // 2、为二维数组分配空间
    a[0] = new int[5];
    a[1] = new int[4];
    a[2] = new int[3];
    // a[3] = new int[2];               // ArrayIndexOutOfBoundsException 下标越界异常

    // 3、修改元素的内容
    a[1][0] = 11;
    a[1][1] = 12;
    a[1][2] = 13;
    a[1][3] = 14;
    // a[1][5] = 15;                    // ArrayIndexOutOfBoundsException 下标越界

    // 4、打印每一行每一列的数据
    for (int i = 0; i < a.length; i++) {        // a.length:代表数组的长度
        // 4.1 循环每一行的每一列的数据
        for (int j = 0; j < a[i].length; j++) {     // a[i]:代表一个数组
            System.out.print(a[i][j] + "\t");
        }
        // 4.2 打印完每一行后进行换行
        System.out.println();
    }
}

8.2 数组的应用

8.2.1 在数组中查找最大值与最小值

代码示例：

    /**
     * 案例一: 在数组中查找最大值与最小值
     * <p>
     * 分析：
     * 1、把数组中的第一个元素赋值给最大值max和最小值min
     * 2、使用for循环遍历数组，将数组中的每一个数与max或者min进行比较
     * ① 如果这个数比max大，就将这个数赋值给max
     * ② 如果这个数比min小，就将这个数赋值给min
     */
    @Test
    public void test01() {
//        定义一个数组
        int[] a = {1, 4, 3, -6, 4, 8, 31, -4, 6, 13, 15};
//        将数组的第一个元素赋值给最大值max和最小值min
        int max = a[0];
        int min = a[0];

//        for循环遍历数组，找最大值和最小值
        for (int i = 0; i < a.length; i++) {
            // 找最大值
            if (a[i] > max) {
                max = a[i];
            }
            // 找最小值
            if (a[i] < min) {
                min = a[i];
            }
        }
        // 打印出最大值和最小值
        System.out.println("max = " + max + ", min = " + min);
    }

8.2.2 在数组中查找元素（只出现一次），并打印下标

【方法一】

代码示例：

    /**
     * 案例二：在数组中查找元素（只出现一次），并打印元素在数组中的下标
     * 方法一：
     * 1、遍历数组，将数组中的每个元素与需要查找的元素比较，
     * 如果相等就找到，并打印数组的下标
     */
    @Test
    public void test01() {
        // 定义一个数组
        int[] a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        // 定义需要查找的元素
        int x = 5;
        // 定义需要查找的元素在数组中的下标
        int index = -1;
        // 遍历数组
        for (int i = 0; i < a.length; i++) {
            // 如果找到了，就将其下标赋值给index
            if (a[i] == x) {
                index = i;
                break;
            }
        }
        // 判断是否找到元素
        if (index >= 0) {
            System.out.println("在位置" + index + "处找到了元素" + x);
        } else {
            System.out.println("没有找到元素" + x);
        }

    }

【方法二】

代码示例：

    /**
     * 案例二：在数组中查找元素（只出现一次），并打印元素在数组中的下标
     * 方法二：
     * 1、如果在遍历数组时找到某个元素，则当退出循环时，i的值一定会小于数组的长度a.length
     * 2、所以，我们可以根据循环完成后这个i的值是否小于a.length来判断是否找到元素，从而打印其下标
     * 如果找到元素，则其下标就是i
     */
    @Test
    public void test02() {
        // 定义一个数组
        int[] a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        // 定义要查找的元素
        int x = 5;
        // 遍历查找元素
        int i = 0;
        for (; i < a.length; i++) {
            if (a[i] == x) {
                break;
            }
        }
        // 根据i与a.length的关系确定找到了元素的下标的值
        if (i == a.length) {
            System.out.println("没有找到元素" + x);
        } else {
            System.out.println("在位置" + i + "找到元素" + x);
        }
    }

【方法三】

代码示例：

    /**
     * 案例二：在数组中查找元素（只出现一次），并打印元素在数组中的下标
     * 方法三：
     * 1、 使用流程控制语句return，如果找到了就返回方法，没有找到就在循环外面打印”没有找到！“
     */
    @Test
    public void test03() {
        // 1. 定义一个数组
        int[] a = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        // 2. 定义要查找的元素
        int x = 190;
        // 3. 开始循环找到元素
        for (int i = 0; i < a.length; i++) {
            if (a[i] == x) {
                System.out.println("在位置" + i + "找到元素" + x);
                return;
            }
        }
        System.out.println("没有找到元素" + x);
    }

8.2.3 在数组中查找元素（有重复元素），并打印下标

【方法一】

代码示例：

    /**
     * 案例三：在数组中查找有重复元素的下标，并打印下标
     * 方法一：
     * 1、将找到的元素的下标放到一个新的数组中
     * 2、所以要确定新数组的下标及长度。
     * 新数组的长度：与原数组长度相同，a.length
     * 下标：定义一个计数器，同时充当下标
     */
    @Test
    public void test01() {
        // 声明一个数组
        int[] a = {3, 1, 9, 10, 3, 1, 3, 1, 9, 8, 7, 10, 1, 4, 2, 1};
        // 定义一个新数组，用于存放查找的重复元素的下标
        int[] b = new int[a.length];
        // 定义一个计数器，同时充当b数组的下标
        int count = 0;
        // 定义要查找的元素
        int e = 1;
        // 循环遍历数组a进行查找
        for (int i = 0; i < a.length; i++) {
            if (a[i] == e) {
                b[count++] = i;
            }
        }
        // 打印下标
        if (count > 0) {
            System.out.println("在如下位置找到了元素" + e + ":");
            for (int i = 0; i < count; i++) {
                System.out.print(b[i] + " ");
            }
        } else {
            System.out.println("没有找到元素" + e);
        }

    }

【方法二】

代码示例：

    /**
     * 案例三：在数组中查找有重复元素的下标，并打印下标
     * 方法二：
     *   可以将找到的元素的下标放到一个字符串中，将字符串连接起来即可。
     */
    @Test
    public void test02(){
        // 声明一个数组
        int[] a = {3, 1, 9, 10, 3, 1, 3, 1, 9, 8, 7, 10, 1, 4, 2, 1};
        // 定义一个字符串，用于存放元素下标
        String str = "";
        // 定义要查找的元素
        int e = 1;
        // 循环遍历数组a进行查找
        for (int i = 0; i < a.length; i++) {
            if (a[i] == e){
                str += i + " ";
            }
        }
        // 打印下标
        if (str.length() > 0){
            System.out.println("在如下位置找到了元素" + e + ":" + str);
        }else {
            System.out.println("没有找到元素" + e);
        }

    }