03-java基础-数组-数组定义格式、数组动(静)态初始化、内存分配、(最大最小平均值,求和,排序,查找)

文章目录

• ​​1.数组​​

• ​​1.1 数组介绍​​
• ​​1.2 数组的定义格式​​

• ​​1.2.1 第一种格式​​
• ​​1.2.2 第二种格式​​
• ​​eg: 示例代码​​

• ​​1.3 数组的动态初始化​​

• ​​1.3.1 什么是动态初始化​​
• ​​1.3.2 动态初始化格式​​

• ​​1.4 数组元素访问​​

• ​​1.4.1 什么是索引​​
• ​​1.4.2 示例代码​​
• ​​1.4.3 java类型默认值​​

• ​​1.5 内存分配​​

• ​​1.5.1 内存概述​​
• ​​1.5.2 java中的内存分配​​
• ​​1.5.3 Java内存分配-一个数组内存图​​
• ​​1.5.4 两个数组内存图​​
• ​​1.5.5 多个数组指向相同内存图​​

• ​​1.6 数组的静态初始化​​

• ​​1.6.1 什么是静态初始化​​
• ​​1.6.2 静态初始化格式​​
• ​​1.6.3示例代码​​

• ​​1.7 数组操作的两个常见问题​​

• ​​1.7.1 索引越界异常​​
• ​​1.7.2 空指针异常​​

• ​​1.8 数组遍历​​
• ​​1.9 数组练习​​

• ​​>>> 数组获取最大值​​
• ​​>>> 数组元素求和​​
• ​​>>> 数组基本查找【应用】​​
• ​​>>> 评委打分【应用】​​
• ​​★ 直接用API实现数组操作(最大最小平均值,求和,排序,查找)​​

1.数组

1.1 数组介绍

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

1.2 数组的定义格式

1.2.1 第一种格式

数据类型[] 数组名

示例：

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

1.2.2 第二种格式

数据类型 数组名[]

示例：

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

eg: 示例代码

public class ArrayDemo {
    public static void main(String[] args) {
        int a=1,b=2;
        int[] arr = {a,b};
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.println("\n-------完全和c语言一致了----------");
        int arr2[] = {a,b};
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

1.3 数组的动态初始化

1.3.1 什么是动态初始化

数组动态初始化就是只给定数组的长度，由系统给出默认初始化值

1.3.2 动态初始化格式

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

int[] arr = new int[5];

• 等号左边：

• int:数组的数据类型
• []:代表这是一个数组
• arr:代表数组的名称

• 等号右边：

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

代码 :

public class ArrayDemo {
    public static void main(String[] args) {
        // 数据类型[] 数组名 = new 数据类型[数组的长度];
        // 通过new关键字创建了一个int类型的数组容器, 该容器可以存储5个int类型的整数, 该容器被arr数组变量所记录
        int[] arr = new int[5];
        System.out.println(arr);//[I@15db9742

        byte[] be = new byte[5];
        System.out.println(be);//[B@6d06d69c
    }
}

数组的动态初始化:
               在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值.
动态初始化格式:
               数据类型[] 数组名 = new 数据类型[数组的长度];
注意:
               打印数组变量的时候, 会打印出数组的内存地址
[I@15db9742 :
               @ : 分隔符
               [ : 当前的空间是一个数组类型
               I : 当前数组容器中所存储的数据类型
               15db9742 :

1.4 数组元素访问

1.4.1 什么是索引

每一个存储到数组的元素，都会自动的拥有一个编号，从0开始。
这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

1.4.2 示例代码

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr);//[I@1b6d3586

        for (int i = 0; i < arr.length; i++) {
            System.out.println(i+": "+arr[i]);//未初始化时 int数组默认置为0 ★
        }

        System.out.println("--------------");
        arr[0]=11;arr[1]=22;arr[2]=33;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

1.4.3 java类型默认值

1.5 内存分配

1.5.1 内存概述

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

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

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

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

1.5.2 java中的内存分配

• 目前我们只需要记住两个内存，分别是：栈内存和堆内存

1.5.3 Java内存分配-一个数组内存图

数组名作为main函数的局部变量，存放在栈区域(仅仅存放一个首地址)

而数据元素，其内存是new出来的，存放在在堆区

按照1~5的次序读一遍即可

1.5.4 两个数组内存图

第二个数组002应该也不对，一般内存单元都是按字节编址，所以至少也是009 。执行结果上两个地址则是差了十万八千里

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

int[] arr2 = arr1;//两个引用类型 可以直接赋值 数组名直接赋值给新数组

1.6 数组的静态初始化

1.6.1 什么是静态初始化

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

1.6.2 静态初始化格式

• 完整版格式

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};

• 简化版格式

数据类型[] 数组名 = {元素1,元素2,...};

1.6.3示例代码

数组静态初始化 : 初始化时指定每个数组元素的初始值，由系统决定数组长度

    完整格式:
                数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
    简化格式:
                数据类型[] 数组名 = {数据1,数据2,数据3...};

public class Array1Demo {
    public static void main(String[] args) {
        //完整格式
        int[] arr1 = new int[]{11, 22, 33, 44};
        for (int i : arr1) {
            System.out.println(i);
        }
        System.out.println("--------------");

        //简化格式
        int[] arr2 = {11,22,33,44};
        for (int i : arr2) {
            System.out.println(i);
        }
    }
}

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

1.7.1 索引越界异常

• 出现原因

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr[3]);
    }
}

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

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

• 解决方案
  将错误的索引修改为正确的索引范围即可！

1.7.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.8 数组遍历

• 数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。

public class Array2Demo {
    public static void main(String[] args) {
        int[] arr={1,2,3};
        System.out.println("-------------遍历1--------------");
        for (int i : arr) {
            System.out.println(i);
        }
        System.out.println("-------------遍历2--------------");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("-------------遍历3--------------");
        for (int i = arr.length - 1; i >= 0; i--) {
            System.out.println(arr[i]);
        }
        System.out.println("-------------遍历4--------------");
        int i=0;
        while(i<arr.length){
            System.out.println(arr[i]);
            i++;
        }
    }
}

1.9 数组练习

>>> 数组获取最大值

• 最大值获取：从数组的所有元素中找出最大值。
• 实现思路：

• 定义变量，保存数组0索引上的元素
• 遍历数组，获取出数组中的每个元素
• 将遍历到的元素和保存数组0索引上值的变量进行比较
• 如果数组元素的值大于了变量的值，变量记录住新的值
• 数组循环遍历结束，变量保存的就是数组中的最大值

• 代码实现：

public class ArrayLX1 {
    public static void main(String[] args) {
        int[] arr = {12,45,98,73,60};
        int max=arr[0];
        for (int i : arr) {
            if(max<i) max=i;
        }
        System.out.println("max="+max);
    }
}

>>> 数组元素求和

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

import java.util.Scanner;

public class ArrayLX2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr=new int[5];
        for (int i = 0; i < arr.length; i++) {
            arr[i]=sc.nextInt();
        }
        int sum=0;
        for (int i : arr) {
            sum+=i;
        }
        System.out.println("sum = " + sum);
    }
}

>>> 数组基本查找【应用】

• 需求：
  已知一个数组 arr = {19, 28, 37, 46, 50}; 键盘录入一个数据，查找该数据在数组中的索引，并在控
  制台输出找到的索引值。
• 思路：
  1.定义一个数组，用静态初始化完成数组元素的初始化
  2.键盘录入要查找的数据，用一个变量接收
  3.定义一个索引变量，初始值为-1
  4.遍历数组，获取到数组中的每一个元素
  5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
  6.输出索引变量
• 代码实现：

import java.util.Scanner;

public class ArrayLX3 {
    public static void main(String[] args) {
        int[] arr = {19, 28, 37, 46, 50};
        Scanner sc= new Scanner(System.in);
        int x=sc.nextInt();
        int n=-1;
        for (int i = 0; i < arr.length; i++) {
            if(x == arr[i]) {
                n=i;
                break;
            }
        }
        System.out.println(n);
    }
}

>>> 评委打分【应用】

• 需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
  选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
• 思路：
  1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6
  2.键盘录入评委分数
  3.由于是6个评委打分，所以，接收评委分数的操作，用循环
  4.求出数组最大值
  5.求出数组最小值
  6.求出数组总和
  7.按照计算规则进行计算得到平均分
  8.输出平均分
• 代码实现：

import java.util.Scanner;

public class ArrayLX4 {
    public static void main(String[] args) {
        int[] arr = new int[6];
        Scanner sc=new Scanner(System.in);// 90 65 80 70 85 90
        int max=-1,min=101,sum=0;//分数 [0,100]
        for (int i = 0; i < arr.length; i++) {
            arr[i]=sc.nextInt();
            if(arr[i]>max) max=arr[i];
            if(arr[i]<min) min=arr[i];
            sum+=arr[i];
        }
        System.out.println((sum-max-min)/4.0);//325/4=81.25
    }
}

★ 直接用API实现数组操作(最大最小平均值,求和,排序,查找)

import java.util.Arrays;

public class ArrayLXAPI {
    public static void main(String[] args) {
        int[] arr = {1,5,3,6,7};

        System.out.println("最大值:"+ Arrays.stream(arr).max().getAsInt());
        System.out.println("最小值:"+ Arrays.stream(arr).min().getAsInt());
        System.out.println("平均值:"+ Arrays.stream(arr).average().getAsDouble());
        System.out.println("求和:"+ Arrays.stream(arr).sum());
        
        Arrays.sort(arr);
        System.out.print("排序后:");
        for (int i : arr) {
            System.out.print(i+" ");
        }
        //Arrays里就一个 二分查找 所以使用前得先排序
        System.out.println("\n二分查找5："+Arrays.binarySearch(arr,5));

        String[] str={"a","b","c","d"};
        System.out.println("数组str查找字符d下标:"+Arrays.binarySearch(str,"d"));
        System.out.println("转list查找'd':"+Arrays.asList(str).contains("d"));//这个API对int类型不好使
    }
}