04-数组

概述

数组概述 

为什么要使用数组？

假如我们有三十个学生，我们现在需要给这三十个学生的成绩进行排序，如果按照之前的方法，我们需要创建30个变量去存储数据，然后再一个一个进行比较，过程会非常麻烦！！！ 

 

数组的概念 

数组是相同类型的数据按顺序组成的一种引用数据类型。 

语法格式：

①        数据类型 [ ] 数组名;        int [ ] intArray;                //声明一个整型数组

②        数据类型 数组名 [ ];        float floatArray[ ];          //声明一个浮点型数组 

注意：数组的命名规则遵循标识符的命名规则。 

数组的创建 

①先声明后创建

方式一：先声明后创建
数据类型 [] 数组名;
数组名 = new 数据类型[数组长度];

int [] intArray;//先声明一个int类型的数组
intArray = new int [10];//创建一个长度为10的整型数组 

②声明的同时创建

方式二：声明的同时创建数组
数组类型 [] 数组名 = new 数组类型[数组长度];

float [] floatArray = new float[10];//声明并创建一个长度为10的浮点型数组 

数组在内存中的存储 

 

局部变量和数组默认值问题 

（1）局部变量

我们在方法中定义的局部变量必须进行初始化，否则引用该变量时会报错。

（2）数组

数组声明并创建后不需要进行初始化，数组会因不同的数据类型而有相应数据类型的默认值，例如：整型数组默认值为0；浮点型数组默认值为0.0

数组的初始化 

声明数组的同时给数组赋值，该方式叫做数组的初始化。

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

注意：数组中各元素用 “  ,  ” 分隔；数组中元素的个数为数组的长度。 

数组元素的引用 

数组通过下标来访问数组中的元素。

语法格式：

 数组名[下标];

注意：数组下标从0开始

举例：int [ ] a = {1,2,3,4,5}; 下标对应的元素如表格所示：

a[0]	a[1]	a[2]	a[3]	a[4]
1	2	3	4	5

数组的长度

数组中的属性length表示数组的长度。 

举例：int [ ] a = {1,2,3,4,5,6,7,8,9,10};

获取数组的长度：数组名.length        即 a.length        数组a的长度为10

一维数组的应用 

回顾数组的基本概念和引用 

package array_practice;
public class ArrayDemo02 {
    public static void main(String [] args){
        //创建数组方式一：先声明后创建
        int [] intArray;//声明了一个整型数组
        String [] stringArray;//声明了一个字符串数组

        //创建数组
        intArray = new int[5];//创建一个长度为5的整型数组
        stringArray = new String[4];//创建一个长度为4的字符串数组

        //创建数组方式二：声明的同时创建数组
        double [] doubleArray = new double[5];//创建一个长度为5的double类型的数组

        //初始化数组
        char [] charArray = {'a','b','c','d'};//元素有四个，因此数组的长度为4

        System.out.println("charArray数组长度为："+charArray.length);
        System.out.println("intArray数组中第一个元素为："+intArray[0]);
        System.out.println("strArray数组中第三个元素为："+stringArray[2]);
        System.out.println("doubleArray数组中最后一个元素为："+doubleArray[doubleArray.length-1]);
    }
}

我们发现给数组初始化或者给数组元素赋值，需要自己一个一个进行赋值，如果后期数组的长度很大，这样的赋值方式会很麻烦。

因此给数组元素赋值通常会结合循环结构来给数组元素进行赋值。

使用循环给数组元素赋值

package array_practice;

public class ArrayDemo03 {
    public static void main(String [] args){
        //使用循环给数组元素赋值
        //第一步：声明并创建一个整型数组
        int [] intArray = new int[10];
        //第二步：使用循环给数组元素赋值
        for(int i=0;i<intArray.length;i++){
            intArray[i] = i+1;//给数组元素进行赋值
        }

        System.out.println("数组元素的值为：");

        //第三步：使用循环将数组中的元素进行输出
        for(int j=0;j<intArray.length;j++){
            System.out.print(intArray[j]+" ");
        }
    }
}

如果数组下标取值超出界限会发生什么？我们声明的数组长度为10，那么数组下标为0——9，如果下标取10会发生什么？

 

错误信息：Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException:Index 10 out of bounds for length 10  

当数组下标取值范围超出界限时会出现运行时异常，即数组下标超出了数组的边界，该异常称为数组下标越界异常。 

一维数组案例：求数组元素的累加和 

package array_practice;
import java.util.Scanner;

public class ArrayDemo05{
    public static void main(String [] args){

        Scanner sc = new Scanner(System.in);

        //定义一个整型数组
        int [] array = new int [5];

        //使用循环给数组赋值
        for(int i=0;i<array.length;i++){
            System.out.println("请给数组的第"+(i+1)+"个元素赋值：");
            array[i] = sc.nextInt();
        }

        //使用循环结构输出数组中的元素
        System.out.println("数组中的元素为：");
        for(int j=0;j<array.length;j++){
            System.out.print(array[j]+" ");
        }

        int sum = 0;//定义变量存储数组元素的累加和
        for(int z=0;z<array.length;z++){
            sum = sum+array[z];
        }
        System.out.println("\n数组元素的累加和："+sum);
    }
}

一维数组案例：求数组元素中的最大值

import java.util.Scanner;
public class ArrayTest {
    public static void main(String [] args){
        int [] data = new int [5];
        Scanner sc = new Scanner(System.in);

        //给整型数组赋值
        for(int i=0;i<data.length;i++){
            System.out.println("请给第"+(i+1)+"个元素赋值：");
            data[i] = sc.nextInt();
        }

        //遍历数组，查看数组中的元素
        for(int n=0;n<data.length;n++){
            System.out.print(data[n]+"\t");
        }

        //假设第一个元素是最大值
        int max = data[0];

        //将第一个元素和后面的元素进行比较
        for(int j=1;j<data.length;j++){
            if(max<data[j]){
                max = data[j];
            }
        }
        System.out.println("数组中的最大值为："+max);
    }
}

增强型for循环

增强型for循环又叫foreach循环。

语法格式：

for(变量类型 变量名 : 数组名或集合名){

        语句;

} 

举例：使用增强型for循环输出数组中的元素

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

for(int i:arr){

        System.out.println(i);

}

使用增强型for循环遍历数组元素

import java.util.Scanner;
public class ArrayTest {
    public static void main(String [] args){
        int [] data = new int [5];
        Scanner sc = new Scanner(System.in);

        //给整型数组赋值
        for(int i=0;i<data.length;i++){
            System.out.println("请给第"+(i+1)+"个元素赋值：");
            data[i] = sc.nextInt();
        }

       //使用增强型for循环遍历整型数组
       for(int n:data){
           System.out.print(n+"\t");
       }
    }
}

冒泡排序

思考：如何对变量a、b的值进行交换？

举例：a的值为3，b的值为5

int a = 3;

int b = 5;

①我们先声明一个中间变量来存储b的值，则中间变量的值为5

int temp = b;                //        temp = 5

②将a的值赋值给b，则b的值由5更改为3

b = a;                        //           b = 3

③将中间值赋值给a，则a的值由3更改为5

a = temp;                //            a = 5

图文展示：

冒泡排序的实现原理 

目标：对一组整数按照由小到大的顺序进行排序。

排序原理：相邻的两个数进行比较，当前一个数比后一个数大时，二者交换位置，之后继续向下比较，直到和最后一个数完成比较，并根据情况交换位置，依次类推，当所有的数都比较完成并且位置确认后，排序结束。

 

使用冒泡排序将一组数据从大到小排序 

//冒泡排序，将数据从大到小排序
public class ArraySort{
    public static void main(String [] args){
        
        int [ ] array = {32,4,56,14,22,45,2};//初始化一个整型数组
        
        System.out.println("数组排序前");
        for(int i:array){
            System.out.print(i+" ");
        }
        //外层循环控制循环次数
        for(int i=0;i<array.length-1;i++){
            //内层循环控制元素间的比较
            for(int j=0;j<array.length-i-1;j++){
                if(array[j]<array[j+1]){
                    int temp = array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        System.out.println("数组排序后");
        for(int j:array){
            System.out.print(j+" ");
        }
    }
}

二维数组

二维数组的创建和引用 

我们直接通过代码来学习二维数组的创建和引用

public class ArrayTest{
    public static void main(String [] args){
        /*数组的声明，三种方式 */
        //第一种——声明int类型的二维数组
        int [][] intArray;
        //第二种——声明float类型的二维数组
        float floatArray[][];
        //第三种——声明double类型的二维数组
        double [] doubleArray[];

        //我们可以将二维数组看做几行几列的表格
        /*二维数组的创建 */
        intArray = new int[3][3];//创建一个三行三列的整型数组
        /*
            intArray[0][0]  intArray[0][1]  intArray[0][2]
            intArray[1][0]  intArray[1][1]  intArray[1][2]
            intArray[2][0]  intArray[2][1]  intArray[2][2]
        */
        System.out.println("整型数组中第三行第二列的元素为："+intArray[2][1]);

        /*数组的引用 */
        //给整型数组的第二行第三列的元素赋值为9
        intArray[1][2] = 9;

        /*声明数组的同时创建数组 */
        char [][] charArray = new char[3][4];//创建3行四列的字符数组

        /*创建float类型的数组，只指明行数，不指明列数 */
        floatArray = new float[4][];
        /*
            注意：
                floatArray = new float[][4];
                floatArray = new float[][];
                这两种是错误写法，列数可以省略，但是行数不能省略
            
            上面我们只指明了行数，如果我们去输出该数组中第一行第二列的元素会发生什么呢？
            System.out.println("float数组的第一行第二列元素为："+floatArray[0][1]);
            会报空指针异常
            Exception in thread "main" java.lang.NullPointerException
            at ArrayTest.main(ArrayTest.java:30)

            原因：我们只指定了行，而没有指定列
        */

        //当我们只指定了行，如何去创建列呢？    每一行其实就是一个一维数组
        floatArray[0] = new float[4];//第一行有4列
        floatArray[1] = new float[5];//第二行有5列
        floatArray[2] = new float[6];//第三行有6列
        floatArray[3] = new float[7];//第四行有7列
        
        System.out.println("float数组中第三行第四个元素为："+floatArray[2][3]);
    }
}

二维数组的初始化问题

public class ArrayInit{
    public static void main(String [] args){
        //二维数组的初始化
        int [][] intArray = {{1,2,3},{4,5,6,7},{8,9,10,11,12}};
        System.out.println("数组的行数："+intArray.length);
        System.out.println("数组第一行的列数："+intArray[0].length);
        System.out.println("数组第二行的列数："+intArray[1].length);
        System.out.println("数组第三行的列数："+intArray[2].length);

        //遍历数组
        //外层循环遍历行数
        for(int i=0;i<intArray.length;i++){
            //内层循环列数
            for(int j=0;j<intArray[i].length;j++){
                System.out.print(intArray[i][j]+"\t");
            }
            System.out.println();
        }
    }
}