Java后端——数组

1数组

1.1数组介绍

数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。

1.2数组的定义格式

1.2.1第一种格式

数据类型  [ ]  数组名

实例

int [] arr;
double [] arr1;
char [] arr2;    

1.2.2第二种格式

数据类型  数组名  [ ] 

实例

int arr [];
int double [];
int char [];

1.3数组的动态初始化

1.3.1什么是数组的动态初始化

数组动态初始化就是只给定义数组的长度，并且有系统自己给出默认的初始化

1.3.2动态初始化的格式

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

int [] arr = new int [4]

1.3.3动态初始化格式详解 

等号左边：

int:数组的数据类型

[ ]:代表这是一个数组

arr:代表数组的名称

等号右边：

new:为数组开辟内存空间
int:数组的数据类型
[ ]:代表这是一个数组
5:代表数组的长度

实例

int [] arr = new int [4];
char [] arr1 = new char [5];

1.4数组元素访问 

1.4.1什么是索引

每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。

这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

1.4.2访问数组元素格式

数组名 [ 索引 ]；

实例：

int [] arr = new int [4];
System.out.println(arr[1]);

1.5.内存分配

1.5.1内存概述

内存是计算机中的重要原件，临时存储区域，作用是运行程序。

我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。

必须放进内存中才能运行，运行完毕后会清空内存。

Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

1.5.2Java中的分配内存

方法区	存储可以运行的class文件。
堆内存	存储队形或者数组、用new来创建的
方法栈	方法运行时的使用的内存，例如main方法运行就是进入方法栈中执行

1.6Java内存分配——一个数组的内存图

1.7 Java内存分配——两个数组的内存图

 1.8 多个数组指向相同内存图

1.9数组的静态初始化

1.9.1什么是静态初始化

在创建数组时，直接将元素确定

1.9.2静态初始化格式

完整版格式

数据类型 [ ]  数组名 = new 数据类型 [ ] { 元素1，元素2，元素3 .....}；

简化版格式

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

实例：
 

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

1.10数组操作的两个常见问题

1.10.1索引越界异常

出现原因：

        假如数组长度为3，索引范围是0~2，但是我们却访问了一个3的索引。

程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修改我们编写的代码。

解决方案：

        将错误的索引修改为正确的索引范围即可！

1.10.2空指针异常

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];

        //把null赋值给数组
        arr = null;
        System.out.println(arr[0]);
    }
}

出现原因：

         arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。在开发中，空指针异常是不能出现的，一旦出现了，就必须要修改我们编写的代码

解决方案

        给数组一个真正的堆内存空间引用即可！

1.11数组遍历

数组遍历：就是将数组中的每一个元素都分别提取出来。

public class Main {
    public static void main(String[] args) {
       int [] arr ={11,22,33,44,55};
       System.out.println(arr[0]);
       System.out.println(arr[1]);
       System.out.println(arr[2]);
       System.out.println(arr[3]);
       System.out.println(arr[4]);
    }
}

以上代码是可以将数组的每个元素全部遍历出来，可以发现，当数组里的元素小的时候，这种遍历确实可行，但假如说元素足够大的时候，可以考虑用循环打印

即

public class Main {
    public static void main(String[] args) {
       int [] arr ={11,22,33,44,55};
        for(int i=0;i<arr.length;i++){}
    }
}

从中可以发现，arr.length可以动态的获取到数组的长度 

1.1.2数组获取最大值

最大值获取：从数组的所有元素中找出最大值。

实现思路：

        定义变量，定义成数组第一个数

        遍历数组，获取出数组的每一个元素

        将遍历的元素和定义的数组进行比较

        如果数组元素大于你定义的，则定义的值进行更新

        遍历结束，变量保存的即为最大

public class Main {
    public static void main(String[] args) {
        int [] arr = {-12,-98,-45,-36,-187};
        int max = -187;
        for (int i = 0; i < arr.length; i++) {
            依次遍历，对比
            如果数组的元素比max大则替代
            否则不做任何操作
            if (arr[i] >= max) {
                max = arr[i];
            }
        }
        System.out.println(max);
    }
}

1.13数组的元素求和

需求：键盘录入5个整数，存储到数组中，并对数组求和

思路： 1.创建键盘录入对象，准备键盘录入 2.定义一个求和变量，准备记录累加后的结果 3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值 4.将键盘录入的数值存储到数组中 5.遍历数组，取出每一个元素，并求和 6.输出总和

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int sum =0;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入5位元素");
        int [] arr = new int[5];
        for (int i = 0; i < 5; i++) {
            arr[i]=sc.nextInt();
            sum+=arr[i];
        }
        System.out.println(sum);
    }
}

1.14数组基本查找

需求：
    已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引，并在控制台输出找到的索引值。

思路：
    1.定义一个数组，用静态初始化完成数组元素的初始化
    2.键盘录入要查找的数据，用一个变量接收
    3.定义一个索引变量，初始值为-1
    4.遍历数组，获取到数组中的每一个元素
    5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
    6.输出索引变量

import java.util.Scanner;
//已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引，并在控
//制台输出找到的索引值。
public class Main {
    public static void main(String[] args) {
        int [] arr = {19,28,37,46,50};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要搜索的元素是：");
        int n = sc.nextInt();
        int index = -1;
        for (int i =0; i<arr.length; i++) {
            if (arr[i]==n){
                index =i;
                break;
            }
        }
        if (index!=-1){
            System.out.println("找到了是索引号为"+index);
        }
        else {
            System.out.println("没有找到，请重新输入。");
        }
    }
 }

 1.15评委打分

需求：

在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。 选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。

思路：

1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6

2.键盘录入评委分数

3.由于是6个评委打分，所以，接收评委分数的操作，用循环

4.求出数组最大值

5.求出数组最小值

6.求出数组总和

7.按照计算规则进行计算得到平均分

8.输出平均分

 public static void main(String[] args) {
        // 1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6
        int[] arr = new int[6];
        // 2.键盘录入评委分数
        Scanner sc = new Scanner(System.in);
        //  3.由于是6个评委打分，所以，接收评委分数的操作，用循环
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i+1) + "个评委的打分:");
            int score = sc.nextInt();
            if(score >= 0 && score <= 100){
                // 合法的分值
                arr[i] = score;
            }else{
                // 非法的分值
                System.out.println("您的打分输入有误, 请检查是否是0-100之间的");
                i--;
            }
        }

        // 4.求出数组最大值
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max < arr[i]){
                max = arr[i];
            }
        }

        // 5.求出数组最小值
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(min > arr[i]){
                min = arr[i];
            }
        }

        // 6.求出数组总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }

        // 7.按照计算规则进行计算得到平均分
        int avg = (sum - max - min ) / 4;

        // 8.输出平均分
        System.out.println(avg);
    }
}