数组与方法

一、数组的定义及使用

数组是一组相关数据的集合，一个数组实际上就是一连串的变量，数组按照使用可以分为一维数组（为数组）、二维数组、多维数组等概念。

1.1一维数组

数组可以存放上千万个数据，并且这些数据的类型是完全相同的。

使用Java的数组，必须经过声明数组和分配内存给该数组两个步骤。

格式如下：

数据类型 数组名称[] = null; // 声明数组
数组名称 = new 数据类型[长度]; // 分配内存给数组

1.2数组中元素的表示方法

想要访问数组里的元素，可以利用索引来完成。Java的数组索引编号由0开始，以score[10]整形数组为例，score[0]代表第一个元素，score[1]代表第2个元素。

例：数组的声明及输出

package charjava;

public class java54 {
    public static void main(String[] args) {
    int[] score = null; // 声明数组，但未开辟堆内存空间
    score = new int[3]; // 为数组开辟堆内存空间
        System.out.println("score[0]=" + score[0]); // 分别输出每个元素
        System.out.println("score[1]=" + score[1]); // 分别输出每个元素
        System.out.println("score[2]=" + score[2]); // 分别输出每个元素
        for (int x = 0; x < 3; x++) { // 使用循环依次输出数组中的全部内存
            System.out.println("score["+x+"]=" + score[x]);
        }
   }
}

例：为数组中的元素赋值并进行输出

package charjava;

public class java55 {
    public static void main(String[] args) {
        int[] score = new int[3]; // 声明数组，并为数组开辟堆内存空间，大小为3
        for (int x = 0; x < 3; x++) { // 为数组中的每个元素赋值
            score[x] = x * 2 + 1; // 为每一个元素赋值
        }
        for (int x = 0; x < 3; x++) { // 使用循环依次输出数组中的全部内容
            System.out.println("score["+x+"]=" + score[x]);
        }
    }
}

1.21在Java中取得数组的长度（也就是数组元素的长度）可以利用“数组名称.length”的形式

格式如下：

数组名称.length --> 返回一个int整数

例：取得一个数组的长度

package charjava;

public class java56 {
    public static void main(String[] args) {
        int[] score = new int[3]; // 声明并实例化数组
        System.out.println("数组长度为：" + score.length); // 求出数组长度
    }
}

1.22数组的静态初始化

数组的内容分为动态初始化和静态初始化两种，之前的所讲解的全部代码是采用先声明数组，之后为数组中的每个内容赋值的方式完成的，所以属于数组的动态初始化。也可以通过静态初始化，在数组声明时就指定其具体内容。

格式如下：

数据类型[] 数组名 = {初值0, 初值1, 初值2, ..., 初值n};

例:数组的静态初始化

package charjava;

public class java57 {
    public static void main(String[] args) {
        int[] score = {12, 11, 14, 16, 18, 20}; // 使用静态初始化声明数组
        for (int x = 0; x < score.length; x++) { // 循环输出
            System.out.println("score["+x+"]= " + score[x]);
        }
    }
}

1.3数组应用范例

例1：求出数组中的最大和最小值

package charjava;

public class java58 {
    public static void main(String[] args) {
        int[] score = {11, 13, 15, 18, 20, 22}; // 静态初始化数组
        int max = 0; // 定义变量保存最大值
        int min = 0; // 定义变量保存最小值
        max = min = score[0]; // 把第一个元素的内容赋值给max和min
        for (int i : score) { // 循环求出最大和最小
            if (i > max) { // 依次判断后续元素是否比max大
                max = i; // 如果大，则修改max内容
            } else {
                min = i; // 如果小，则修改min内容
            }
        }
            System.out.println("最大值：" + max); // 输出最大值
            System.out.println("最小值：" + min); // 输出最小值

    }
}

例2：对整型数组按照由小到大的顺序进行排列

package charjava;

public class java59 {
    public static void main(String[] args) {
        int[] score = {1, 2, 11, 22, 0, 8, 44, 3, 10}; // 声明数组
        for (int i  = 1; i < score.length; i++) { // 循环判断
            for (int j = 0; j < score.length; j++) {
                if (score[i] < score[j]) { // 交换位置
                    int temp = score[i];
                    score[i] = score[j];
                    score[j] = temp;
                }
            }
        }
        for (int i = 0; i < score.length; i++) { // 数组输出
            System.out.print(score[i] + "\t");
        }
    }
}

2.1二维数组

二维数组声明的方式和一维数组类似，内存的分配也一样是用new这个关键字。其声明与分配内存的格式如下：

例：2.11二维数组的声明格式

数据类型 数组名[][]；
数组名 = new； 数据类型[行的个数][列的个数];

例：2.12二维数组简洁的声明格式

int score[] = new int[4][3]; // 声明整型数组score，同时为其开辟一块内存空间

例：2.13二维数组的定义及使用

package charjava;

public class java60 {
    public static void main(String[] args) {
        int[][] score = new int[4][3]; // 声明并实例化二维数组
        score[0][1] = 30; // 为数组中的部分内容赋值
        score[1][0] = 31; // 为数组中的部分内容赋值
        score[2][2] = 32; // 为数组中的部分内容赋值
        score[3][1] = 33; // 为数组中的部分内容赋值
        score[1][1] = 31; // 为数组中的部分内容赋值
        for (int i = 0; i <= score.length; i++) {  // 外层循环行
            for (int j = 0; j<score[i].length; j++) { // 内层循环列
                System.out.print(score[i][j] + "\t");
            }
            System.out.println(""); // 换行
        }
    }
}

例：2.14二维数组静态初始化格式

数据类型 数组名[][] = {
{第0行初值},
{第1行初值},
...
{第n行初值},
}

例：2.15使用静态初始化声明一个二维数组

package charjava;

public class java61 {
    public static void main(String[] args) {
        // 静态初始化一个二维数组，每行的数组元素个数不一样
        int[][] score = {{61, 67}, {78, 89, 83}, {99, 100, 98, 66, 95}};
        for (int i = 0; i < score.length; i++) { // 外层循环输出行
            for (int j = 0; j < score[i].length; j++) { // 内存循环输出列
                System.out.print(score[i][j] + "\t"); // 输出每一个元素
            }
            System.out.println(""); // 换行
        }
    }
}

3.1多维数组

使用多维数组时，输入，输出的方式和一、二维相同，但是每多一维，嵌套循环的层数就多一层，所以为数越高的数组其复杂度也就越高。

例：3.11定义和使用三位数组

package charjava;

public class java62 {
    public static void main(String[] args) {
        // 定义一个三维数组，使用静态初始化的方式
        int[][][] score = {{{5, 1}, {6, 7}}, {{9, 4}, {8, 3}}};
        for (int i = 0; i < score.length; i++) { // 第一层循环
            for (int j = 0; j < score[i].length; j++) { // 第二层循环
                for (int k = 0; k < score[i][j].length; k++) { // 第三层循环
                    System.out.println("score[" + i + "][" + j + "][" + k + "]=" + score[i][j][k]); // 输出每一个元素
                }
            }
        }
    }
}

4.1方法的声明及使用

方法（函数）是程序的重要组成部分，利用方法可以更好地实现代码的重用操作。

例：4.11方法的定义格式

public static 返回值类型 方法名称(类型 参数1， 参数2，...) {
程序语句；
[return 表达式];
}

注：高亮部分是方法的主体。

例：定义一个方法，在主方法中进行调用

package charjava;

public class java63 {
    public static void main(String[] args) {
        print(); // 调用print()方法
        print(); // 调用print()方法
        print(); // 调用print()方法
        System.out.println("Hello World!");
    }
    // 此处由于此方法是由main方法直接调用所以一定要加上public static
    public static void print() {
        char[] c = {'H', 'e', 'l', 'l', 'o', ',', 'H', 'd'}; // 定义一个字符数组
        for (int x = 0; x < c.length; x++) { // 循环输出
            System.out.print(c[x]);
        }
        System.out.println(""); // 换行
    }
}

注：print()方法本身不需要任何的返回值声明，所以使用了关键字进行声明，表示此方法不需要任何的返回值，所以不需要编写return语句。

package charjava;

public class java64 {
    public static void main(String[] args) {
        int one = addOne(10, 20); // 调用整数的加法操作
        float two = addTwo(10.3f, 20.3f); // 调用浮点数的加法操作
        System.out.println("addOne的计算结果：" + one);
        System.out.println("addTweo的计算结果：" + two);
    }
    // 定义方法，完成两个整数的加法操作，方法返回一个int型数据
    public static int addOne(int x, int y) {
        int temp = 0; // temp为局部变量，只在此方法中有效
        temp = x + y; // 执行加法计算
        return temp; // 返回计算结果
    }
    // 定义方法，完成两个浮点数的加法操作，方法返回一个float型数据
    public static float addTwo(float x, float y) {
        float temp = 0; // temp为局部变量，只在此方法中有效
        temp = x + y; // 执行加法计算
        return temp; // 返回计算结果
    }
}