Java基础学习05：数组

一、数组定义

• 数组是指一组数据的集合，数组中的每个数据被称作元素
• 在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致
• 声明一个数组就是在内存空间中划出一串连续的空间
• 元素在数组中的排序下标从零开始

二、一维数组

1、语法格式

数组类型[] 数组名 = new 数组类型[数组长度];   
数组类型[] 数组名 = new 数组类型[]{数组元素0, 数组元素1, ...};  
数组类型[] 数组名 = {数组元素0, 数组元素1, ...}; 

第二种数组定义方式，可以再次对数组变量赋值，增删元素
第三种数组定义方式，就不能再次对数组变量赋值

2、Java中不同数据类型元素的初始值

给数组元素赋初值和修改数组元素的值，格式都一样：数组名[下标] = 元素值

• byte、short、int、long：0
• float、double：0.0
• char：一个空字符（\u0000）
• boolean：false
• 引用数据类型：null

3、数组遍历

package net.xsp.lesson04;

import java.util.Scanner;

/**
 * 功能：统计平均成绩
 *      用数组保存每个成绩
 * 作者：xsping
 * 日期：2019年4月11日
 */
public class CalculateAverage {
    public static void main(String[] args) {
        // 声明部分
        double[] score = new double[10];
        double sum = 0, average;
        Scanner sc = new Scanner(System.in);

        // 输入部分
        for (int i = 0; i < score.length; i++){
            System.out.print("score[" + i + "] = " );
            score[i] = sc.nextDouble();
        }

        // 处理部分
        for (int i = 0; i < score.length; i++) {
            sum = sum + score[i];
        }
        average = sum / score.length;

        // 输出部分
        System.out.println("average = " + average);
    }
}

运行结果

4、数组最值

package net.xsp.lesson04;

/**
 * 功能：计算一组数组的最值
 * 作者：向仕平
 * 日期：2019年4月11日
 */
public class MaximumValue {
    public static void main(String[] args) {
        int[] arr = {23,44,2,5,5,63,63,8,29,25,26,};
        int max = arr[0];
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        System.out.println("数组arr中的最大值为：" + max);
        System.out.println("数组arr中的最小值为：" + min);
    }
}

运行结果

5、案例演示

（1）选择法降序排列数组

package net.xsp.lesson04;


/**
 * 功能：演示选择法排序（降序）
 * 作者：xsping
 * 日期：2019年4月11日
 */
public class ArrayDown {
    public static void main(String[] args) {
        // 声明数组
        int[] arr = {61, 54, 18, 59, 31, 98, 2, 37, 82};

        // 1. 选择排序前，先循环打印数组元素
        System.out.print("排序前：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();

        // 2. 进行选择排序
        // 2.1 外层循环定义需要比较的轮数
        for (int i = 0; i < arr.length - 1; i++) {
            // 2.2 内层循环定义第i轮需要进行的比较
            for (int j = i + 1; j < arr.length; j++) {
                // 比较第i个元素与剩下的数组元素
                if (arr[i] < arr[j]) {
                    // 下面三行代码用于交换两个元素的值
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }

        // 3. 完成选择排序后，再次循环打印数组元素
        System.out.print("排序后：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

运行结果

（2）冒泡法降序排列数组

package net.xsp.lesson04;

/**
 * 功能：演示冒泡法排序（降序）
 * 作者：xsping
 * 日期：2020年4月11日
 */
public class ArrayEffervescence {
    public static void main(String[] args) {
        // 声明数组
        int[] arr = {61, 54, 18, 59, 31, 98, 2, 37, 82, 34};

        // 1. 选择排序前，先循环打印数组元素
        System.out.print("排序前：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();

        // 2. 进行冒泡排序
        // 2.1 外层循环定义需要比较的轮数
        for (int i = 1; i < arr.length; i++) {
            // 2.2 内层循环定义第i轮需要进行的比较
            for (int j = 0; j < arr.length - i; j++) {
                // 比较相邻两个元素
                if (arr[j] < arr[j + 1]) {
                    // 下面三行代码用于交换两个元素的值
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        // 3. 完成冒泡排序后，再次循环打印数组元素
        System.out.print("排序后：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

运行结果

三、二维数组

1、数组定义

int[][] 数组名 = new int[二维数组长度][一维数组长度];
int[][] 数组名 = new int[二维数组长度][];

例1：
定义了一个3*4的二维数组，这个二维数组的长度为3，可以将它看成3个int[]类型的一维数组，每个一维数组中的元素又是一个长度为4的一维数组

int[][] xx = new int[3][4];

例2：
和例1类似，只是数组中每个元素的长度不确定

int[][] xx = new int[3][];

2、直接赋值

直接使用嵌套大括号“{}”，对二维数组初始化赋值

int[][] xx = {{1, 2}, {3, 4, 5, 6}, {7, 8, 9}};

上面的二维数组中定义了三个元素，这三个元素都是数组，分别为{1, 2}、{3, 4, 5, 6}、{7, 8, 9}

3、案例演示

求二维数组最值及其位置

package net.xsp.lesson05;

import java.util.Scanner;

/**
 * 功能：求二维数组最值及其位置
 * 作者：xsping
 * 日期：2019年4月25日
 */
public class FindMaxAndPosition {
    public static void main(String[] args) {
        //  声明部分（declaration）
        int[][] a = new int[3][4];
        int max;
        Scanner sc = new Scanner(System.in);

        //  输入部分
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print("a[" + i + "][" + j + "] = ");
                a[i][j] = sc.nextInt();
            }
        }

        //  处理部分
        max = Integer.MIN_VALUE;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (max < a[i][j]) {
                    max = a[i][j];
                }
            }
        }

        //  输出部分
        System.out.println("max = " + max);
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (max == a[i][j]) {
                    System.out.println("a[" + i + "][" + j + "] = " + max);
                }
            }
        }
    }
}

运行结果