第五节、数组

5.1数组的概念

数组：是一种容器，可以同时存放多个数据值。

数组的特点：

1. 数组是一种引用数据类型

2. 数组当中的多个数据，类型必须统一。

3. 数组的长度再程序运行期间不可改变

5.2数组的定义格式

两种常见的初始化方式：

1. 动态初始化（指定长度）

2. 静态初始化（指定内容）

一、动态初始化数组的格式：

数据类型[] 数组名称 = new 数据类型[数组长度]；

解析含义：

• 左侧数据类型，也就是数组当中保存的数据，全都是统一的什么类型。

• 左侧的中括号，代表我是一个数组

• 左侧的数组名称，给数组取一个名字

• 右侧的new：代表创建数组的动作

• 右侧的数据类型：必须和左边的数据类型保持一致。

• 右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个 int 数字。

public class Demo01Array{
        public static void main(String[] args){
            //创建一个数组，里面可以存放300个 int 数据
            //格式：数据类型[] 数组名称 = new 数据类型 [数组长度]；
            int [] arrayA = new int[300];
            
            //创建一个数组，能存放10个double类型的数据
            double[] arrayB = new double[10];
            //创建一个数组，能存放5个字符串
            String[] str = new String[5];
        }
    }
/*
动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的数据元素个数。
静态初始化（指定内容）：在创建数组的对象，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。
​
静态初始化基本格式：
数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，....}；
*/
​
public class Demo02Array{
    public static void main(String[] args){
        //直接创建一个数组，里面装的全都是int数字，具体为5、15、25
        int[] arrayA = new int[]{5,15,25};//静态初始化
        
        //创建一个数组，用来装字符串，“Hello”、“world”、“java”
        String[] arrayB = new String[]{"Hello","World","Java"};
    }
}

 

二、省略的静态初始化

数据类型[] 数组名称 ={元素1，元素2，。。。}；

注意事项：

1. 静态初始化没有直接指定长度，但是仍然会自动推算得到长度。

2. 静态初始化标准格式可以拆分成为两个步骤。

3. 动态初始化也可以拆分成为两个步骤。

4. 静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。

使用建议：

如果不确定数组当中的具体内容，用动态初始化，否则，已经确定了具体的内容，用静态初始化。

public class Demo03Array{
    public static void main(String[] args){
        //省略格式的静态初始化
        int[] arrayA = {10,20,30};
        
        //静态初始化的标准格式，可以拆分成为两个步骤
        int[] array8;
        array8 = new int[]{11,21,31};
        
        //动态初始化也可以拆分成为两个步骤
        int[] arrayC;
        arrayC = new int[5];
        
    }
}

 

三、动态初始化数组的默认值

规则如下：

如果是整数类型，那么默认为0；

如果是浮点类型：那么默认值为0.0；

如果是字符类型，那么默认值为‘\u0000’；

如果是布尔类型，那么默认为false；

如果是引用类型，那么默认为null；

注意事项

静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体值。

5.3获取数组的长度

/*
* 如何获取数组的长度，格式：
* 数组名称 .length
*
* 这将会得到一个 int 数字，代表数字的长度。
* 数组一旦创建，程序运行期间，长度不可改变。
* */
public class Demo03ArrayLength {
    public static void main(String[] args) {
        int[] arrayA = new int[3];//动态初始化
​
        int[] arrayB = {10,20,30};//静态初始化
        int len = arrayB.length;
        System.out.println("arrayB 的数组长度是："+len);
        System.out.println("===========");
​
        int[] arrayC = new int[3];
        System.out.println(arrayC.length);//3
        arrayC = new int[5];
        System.out.println(arrayC.length);//5
    }
}

 

5.4遍历数组

public class Demo04Array {
    public static void main(String[] args){
        int[] array = {15,25,30,40,50};
​
        //首先使用原始方式
        System.out.println(array[0]);//15
        System.out.println(array[1]);//25
        System.out.println(array[2]);//30
        System.out.println(array[3]);//40
        System.out.println(array[4]);//50
        System.out.println("===============");
​
​
        //使用循环，次数其实就是数组的长度
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
​
​
        //使用增强for循环
        System.out.println("===============");
        for(int i:array){
            System.out.println(i);
        }
    }
}

 

5.5求出数组中的最大值

public class Demo05ArrayMax {
    public static void main(String[] args){
        int[] array = {5,15,30,20,10000};
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            //如果当前元素大于max，则将该数赋值给max
            if(array[i] > max)
                max = array[i];
        }
        System.out.println("array数组中最大的数是:"+max);
    }
}

 

5.6数组元素反转练习

1. 数组元素反转，其实就是对称位置的元素交换。

2. 通常便利数组用的是一个索引；

   int i = 0；

   现在表示对称位置需要两个索引；

   int min = 0;

   int max = array.length-1;

3. 如何交换两个变量的值？

   int a = 10;

   int b = 20;

   

    

   如果是两个水杯，都是满的，如何交换？借助第三个空杯子

   int temp = a;

   a = b;

   b = temp;

   用第三个变量倒手。

   

    

    

4. 什么时候停止交换？

   1. min == max;

   2. min > max;

   3. 当max>min时交换

/*
* 数组元素的反转
* 本来的样子:[1,2,3,4]
* 之后的样子:[4,3,2,1]
*
* 要求不能使用新数组，就用原来的唯一一个数组
* */
public class Demo07ArrayReverse {
    public static void main(String[] args){
        int[] array ={10,20,30,40,50};
​
        //遍历打印数组本来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("=================");
​
        /*
        * 初始化语句：int min = 0, max = array.length-1
        * 条件判断：min < max
        * 步进条件：min++,max--
        * 循环体：用第三个变量到手*/
        for(int min=0,max=array.length-1;min<max;min++,max--){
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

 

5.7数组作为方法参数

/*
* 数组可以作为方法的参数。
* 当调用方法的时候，向方法的小括号进行出传参，传递进去的其实是数组的地址值。
* */
public class Demo01ArrayParam {
    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50};
        System.out.println(array); //地址值
​
        printArray(array);//传递进去的就是array当中保存的地址值
        System.out.println("================AAA================");
        printArray(array);
        System.out.println("================BBB================");
        printArray(array);
    }
​
    /*
    * 三要素
    * 返回值类型：只是进行打印而已，不需要进行计算，也没有结果，用void
    * 方法名称：printArray
    * 参数列表：必须给我数组，我才能打印其中的元素。int[] array*/
    public static void printArray(int[] array){
        System.out.println("printArray方法接收到的参数是："+array);
        for(int i:array){
            System.out.println(i);
        }
    }
}

 

5.8数组作为方法的返回值

import java.util.Scanner;
​
/*
一个方法可以有 0、1、多个参数，但是只能有0或1个返回值，不能有多个返回值。
如果希望一个方法当中产生了多个结果数据进行返回，怎么办？
解决方案，使用一个数组作为返回值类型即可。
​
任何数据类型都能作为方法的参数类型，或者返回值类型。
​
数组作为方法的参数，传递进去的其实是数据的地址值。
数组作为方法的返回值，返回的其实也是地址值。
 */public class Demo02ArrayReturn {
    public static void main(String[] args) {
        int a,b,c;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入三个整数:");
        a = sc.nextInt();
        b = sc.nextInt();
        c = sc.nextInt();
        int[] result = calculate(a, b, c);
​
        System.out.println("main方法收到的返回值数组是:");
        System.out.println(result); //地址值
        for(int i: result){
            System.out.println(i);
        }
    }
    public static int[] calculate(int a,int b, int c){
        int sum = a+b+c; //总和
        int avg = sum/3; //平均数
        /*int[] array = new int[2];
        array[0] = sum;
        array[1] = avg;*/
        int[] array = {sum,avg};
        System.out.println("caculate方法内部数组是:");
        System.out.println(array);//地址值
        return array;
    }
}