Java学习笔记===》3.数组

数组

1.数组的介绍

<1>概念：

​ 数组（array）是一种 容器 ，用来存储同种数据类型的多个值

​ 总结：数据容器在存储数据的时候，需要结合数据类型考虑，

​ 例如：int类型的数组容器（Boolean、byte、short、double）===》Boolean、double不可以存储

​ 建议：容器的类型，和存储的数据类型保持一致

<2>使用场景：

​ 如果要操作的数据是同一种数据，就可以使用数组容器进行存储

2.数组的定义格式

<1>格式1：

​ 数据类型 [ ] 变量名；

​ 举例：int [ ] array

<2>格式2：

​ 数据类型 变量名 [ ]

​ 举例： int array [ ]

package com.test01;
//数组的定义格式
// <1>格式1：
//    数据类型 [ ]  变量名；
//    举例：int [ ]  array
//
//<2>格式2：
//    数据类型   变量名   [ ]
//    举例： int    array [ ]

/*
      这里虽然定义了一个数组，但也仅仅只是一个数组类型的[变量]
      变量没有初始化，就直接使用会报错
 */
public class Demo01 {
    public static void main(String[] args) {
//      <1>格式1：数据类型 [ ]  变量名；
        int [] arr ;   //定义了一个int类型的数组，数组名叫 arr,但是没有初始化，会报错
        System.out.println(arr);

//      <2>格式2：数据类型   变量名   [ ]
        char carr [] ;       //定义了一个char类型的数组，数组名叫 carr，但是没有初始化，会报错
        System.out.println(carr);
    }
}

3.数组初始化

初始化：

​ 就是在内存中，为容器开辟一个空间，并将数据存入容器的过程

​ ★Java中的数组必须先初始化才能使用

<1>数组动态初始化.

​ 初始化时，只指定数组长度，由系统为数组分配初始值

​ 格式： 数据类型 [ ] 变量名 = new 数据类型 [数组长度];

​ 举例： int [ ] arr = new int [ 3];

//通过new关键字，创建了一个int类型的数组容器 , new会在内存中给容器开辟空间

package com.test01;


//数组的动态初始化
//   格式： 数据类型 [ ] 变量名  =   new  数据类型  [数组长度];
//   举例：  int   [ ]  arr   =   new    int      [ 3];
public class Demo02 {
    public static void main(String[] args) {
//格式： 数据类型 [ ] 变量名  =   new  数据类型  [数组长度]
         int   [ ] arr    =   new    int      [5];  
        //通过new关键字，创建了一个int类型的数组容器
                                   //该容器可以存储5个int类型的数据，该容器被arr数组变量所记录
        System.out.println(arr);      // 内存地址为：[I@1b6d3586


        byte [] barr = new byte[8];//通过new关键字，创建了一个byte类型的数组容器
                                  //该容器可以存储8个byte类型的数据，该容器被barr数组变量所记录
        System.out.println(barr);   //内存地址为; [B@4554617c


        //注意:打印数组变量的时候会打印出数组的内存地址
       // [B@4554617c
        // [ :表示当前的空间是一个数组类型
        // @ ：分隔符
        // B ：表示当前数组容器中存储的数据类型
        // 4554617c ：十六进制的内存地址
    }
}

//注意:打印数组变量的时候会打印出数组的内存地址

<2>.数组静态初始化

​ 初始化时，就可以指定数组要存储的元素，系统会自动算出该数组的长度。

​ 格式：数据类型 [ ] 变量名 = new 数据类型 [ ]{数据1，数据2，数据3，…}

​ 示例： int [ ] arr = new int [ ] {1,2,3…}

​ 简化格式： 数据类型 [ ] 变量名 = {数据1，数据2，数据3，…} ​

package com.test01;
//静态初始化
public class Demo06 {

/*
格式：数据类型 [ ]   变量名  =  new  数据类型 [ ]{数据1，数据2，数据3，......}

示例：     int      [ ]      arr     =   new       int       [ ]         {1,2,3...}

简化格式： 数据类型 [ ]  变量名  =   {数据1，数据2，数据3，......}
*/
    public static void main(String[] args) {
        //数据类型 [ ]   变量名  =  new  数据类型 [ ]{数据1，数据2，数据3，......}
        int [] arr = new int[]{11,22,33};
        System.out.println(arr);
        System.out.println(arr[0]);     //11
        System.out.println(arr[1]);     //22
        System.out.println(arr[2]);     //33

        //简化格式： 数据类型 [ ]  变量名  =   {数据1，数据2，数据3，......}
        int [] arr2 = {44,55,66};    //没有new也会产生内存地址，简化了new int[]的书写
        System.out.println(arr2);
        System.out.println(arr2[0]);     //11
        System.out.println(arr2[1]);     //22
        System.out.println(arr2[2]);     //33

    }
}

<3>两种数组初始化的区别

**①动态初始化：**手动指定数组长度，由系统给出默认初始化值

​ 应用场景：只明确元素个数，不明确具体数值，推荐使用动态初始化

​ 例如：使用数组容器来存储键盘录入的五个整数：int [ ] arr = new int[5];

**②静态初始化：**手动指定数组元素，系统会根据元素个数，计算出数组的长度

​ 使用场景：需求中已经明确了要操作的具体数据，直接静态初始化即可

​ 例如：将学生的成绩（11，22，33）放入数组容器中： int [] arr = {11,22,33};

4.数组元素访问

<1>数组内存地址的访问方式

​ 格式：数组名；

<2>数组内部保存的数据的访问方式

​ 格式：数组名[索引]

​ 索引：是数组容器中空间的编号

​ **作用：**访问数组容器中的空间位置

​ 特征：

​ ①索引从0开始

​ ②索引是连续的

​ ③索引逐一增加，每次加1

package com.test01;
/*
    数组动态初始化：
        初始化的时候，手动指定数组的长度，系统会为数组容器分配初始值

    数组元素访问格式：
        数组名[索引]

        索引：数组中数据的编号方式，编号从0开始
        作用：访问数组容器中的空间位置
 */
public class Demo03_index {
    public static void main(String[] args) {
        int [] arr = new int[3];    //0,1,2
        System.out.println(arr);  //会打印数组的内存地址  [I@1b6d3586

        //数组名[索引]       访问数组容器中的空间位置
       //证明动态初始化，有默认初始值
        System.out.println(arr[0]);     //0；这里打印的0，就是系统为数组容器分配初始值
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        //数组在创建完毕后，即使没有赋值，也可以取出
        //但取出的元素都是默认初始化值
        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]);
    }
}

▲注意：数组在创建完毕后，即使没有赋值，也可以取出但取出的元素都是默认初始化值

5.内存分配

<1>Java中内存分配

​ Java程序在运行时，需要在内存中分配空间，为了提高效率，就对空间进行了不同区域的划分。每一片区域都有特定的处理数据的方式和内存管理方式。

①栈内存：

​ 方法运行时，进入的内存，局部变量都放于这块内存当中

②堆内存：

​ 存储对象或数组，new出来的内容都会进入堆内存，并且会存在地址值

③方法区：

​ 字节码文件（.class文件）加载时进入的内存

④本地方法栈：

​ 虚拟机在操作系统功能的时候使用，调用操作系统相关资源

⑤寄存器：

​ 交给CPU去使用

<2>一个数组的内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2S0B9ar6-1685003245703)(E:\java笔记\笔记图片\数组内存图.png)]

<3>多个数组的内存图

package com.test01;

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

        int [] arr = new int[2];
        System.out.println(arr);
        arr[0] = 11;
        arr[1] = 22;
        System.out.println(arr[0]);
        System.out.println(arr[1]);

        System.out.println("-----------------");

        int [] arr2 = new int[3];
        System.out.println(arr2);
        arr2[0] = 33;
        arr2[1] = 44;
        arr2[2] = 55;
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BPEqNm6y-1685003245705)(E:\java笔记\笔记图片\多个数组内存图.png)]

注意：

​ 每new一次，在堆内存中，都是一块新的空间，堆内存的空间地址不会出现重复的现象**

<4>多个数组指向相同

package com.test01;
//两个数组指向相同
public class Demo05_Array {
    public static void main(String[] args) {
        int [] arr = new int[2];
        arr[0] = 11;
        arr[1] = 22;

        /*
        数组类型应该记录的是什么？===》地址值
         */
        int [] arr2 = arr;
        arr2[0] = 33;

        System.out.println(arr[0]);        // 33
        System.out.println(arr[1]);        // 22

        System.out.println("-----------------");

        System.out.println(arr2[0]);    // 33
        System.out.println(arr2[1]);    // 22

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VuBkWdJT-1685003245706)(E:\java笔记\笔记图片\多个数组指向相同内存图.png)]

<5>数据类型在内存中的默认值：

数据类型	内存中默认值
整数	0
浮点数	0.0
布尔	false
字符	空字符
引用数据类型	null

**引用数据类型：**引用、记录了地址值的变量，所对应的数据类型，就是引用数据类型

​ 例如： int [] arr = new int [3];

6.数组遍历

​ 数组的遍历（重点：数组的基本操作）

​ 遍历：将容器中的元素一个一个的获取到，做后续操作（打印，判断，计算）

package com.test01;
/*
    数组的遍历（重点：数组的基本操作）

    遍历：将容器中的元素一个一个的获取到，做后续操作（打印，判断，计算）
 */
public class Demo07_bianli {
    public static void main(String[] args) {
        //定义数组，静态初始化完整格式
        //int [] arr = new []{1,2,3,4,5};
        
        //静态初始化简化格式
        int[] arr = {1, 2, 3, 4, 5};
        //遍历数组
        //笨办法遍历数组===》打印1-5的本办法===》使用for循环优化
        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]);

        System.out.println("-------------------");

        //动态获取数组长度
        System.out.println(arr.length);

        //一个数组最大索引是多少
        //arr.length-1

        //for循环遍历数组
        for (int i = 0; i <5; i++) {
            //i代表每一个索引
            System.out.println(arr[i]);


        //快捷键===》数组名.fori
            for (int i1 = 0; i1 < arr.length; i1++) {
                
            }

        }
    }
}

7.数组常见操作

<1>数组元素求和及平均值

package com.test01;

public class Demo08_arr_sum {
    /*
    需求：
        定义一个int类型的数组，元素自拟
        打印数组元素的和，还有元素平均值
     */
    public static void main(String[] args) {
        //定义int类型的数组
        int [] arr = {11,22,33,44,55,66,77,88,99,};
        //定义求和变量
        int sum = 0;
        //数组遍历
        for (int i = 0; i < arr.length; i++) {
            //累加求和
            sum += arr[i];
        }
        //计算平均值
        double pj = sum / arr.length;
        System.out.println("数组元素的和为"+sum);
        System.out.println("数组元素的平均值为："+pj);
    }
}

<2>获取数组元素最值

​ 获取最值：

​ int [] arr = {12,23,34,45,56};\

​ 思路：

​ ①定义一个变量，用于保存最值 ===》int max;

​ ②取数组中第一个数据作为变量的初始值===》int max = arr[0];

​ ③与数组中剩余的数据逐个比对===》

​ for(int i = 1; i < arr.lenght; i++){

​ if(arr[i] >max){

​ max = arr[i];

​ }

​ }

​ ④循环结束后打印变量的值===》System.out.println(max);

package com.test01;
/*
需求：
    从数组中查找最大值 int [] arr = {12,45,98,73,60};
思路：
    1.假设数组中的第一个元素为最大值
    2.遍历数组，获取每一个元素，准备进行比较
    3.比较过程中出现了比max大的，让max记录更大的值
    4.循环结束后，打印最大值
 */
public class Demo09_arr_max {
    public static void main(String[] args) {

        int [] arr = {12,45,98,73,60};

        int max = arr[0];

        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > max){
                max = arr[i];
            }
        }
        System.out.println("数组中的最大值是"+max);

        //获取最小值
        int min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < min ){
                min = arr[i];

            }
        }

        System.out.println("数组中的最小值为"+min);
    }
}

<3>评委打分

package com.test01;

import java.util.Scanner;

/*
需求：
    6个评委给一个选手打分，分数是[1-100]之间的整数
    将分数装入一个合适的容器中
    要求去掉最高分和最低分，计算选手的分数的平均值
 */
public class Demo10_arr_score {
    public static void main(String[] args) {
        //1.创建键盘对象
        Scanner sc = new Scanner(System.in);

        //创建数组容器
        double [] arr = new double[6];

        
        /*
        重点：通过遍历数组，使用键盘给元素赋值
         */
        
        
        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            //提示用户打分,通过键盘录入给元素赋值
            System.out.println("请输入第"+(i+1)+"评委的分数");
            arr[i] =sc.nextInt();
        }


        //求最大值
        double max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>max){
                max = arr[i];
            }
        }

        //求最小值
        double min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]<min){
                min = arr[i];
            }
        }

        //求元素总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }

        //求平均值

        double avg = (sum-max-min)/6 ;

        //打印分数
        System.out.println("去掉一个最大值"+max+"分");
        System.out.println("去掉一个最小值"+min+"分");
        System.out.println("选手最终得分"+avg+"分");
    }
}

<4>判断奇偶

package com.test01;
//定义一个数组存储1，2，3，4，5，6，7，8，9，10
//遍历一遍数组得到每一个元素
/*
需求：
1，如果是奇数，则将当前数字扩大两倍
2.如果是偶数，则将当前数字变成二分之一
 */
public class Demo11 {
    public static void main(String[] args) {
        //1.定义数组
        int [] arr = {1,2,3,4,5,6,7,8,9,10};
        //2.遍历数组
        for (int i = 0; i < arr.length; i++) {
            //判断奇偶数
            if(arr[i]%2 == 0){
                arr[i] = arr[i]/2;
            }else{
                arr[i] = arr[i]*2;
            }
            System.out.println(arr[i]);
        }

    }
}

<5>随机数存入数组

import java.util.Random;

/*
需求：生成10个1-100之间的随机数存入数组
    1.求出所有数据的和
    2.求出所有数据的平均数
    3.统计有多少个数据比平均值小
 */
/*
分析：
    1.定义数组，动态初始化
    2.把随机数存入到数组当中
 */
public class Demo12 {
    public static void main(String[] args) {
        //1.定义数组，动态初始化
        int [] arr =new int[10];
        //2.定义随机数
        Random r = new Random();
        //接收随机数
        for (int i = 0; i < arr.length; i++) {
            //每循环一次就会生成一个新的随机数
            int number = r.nextInt(100)+1;
            //把生成的随机数添加到数组当中
            arr[i] = number;
            System.out.println(arr[i]);
        }
        //定义求和变量
        double sum = 0;
        int count = 0;
        double avg = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
            avg = sum/arr.length;
            if(avg>arr[i]){
                count++;
            }
        }
        System.out.println("数据的总和为："+sum);

        System.out.println("数据的平均值为："+avg);

        System.out.println("数组中比平均值小的数据有"+count+"个");
    }
}

<6>交换数组中的数据

package com.test01;
/*
需求：定义一个数组，存入1，2，3，4，5，按照要求交换索引对应的元素
    交换前：1，2，3，4，5
    交换后：5，2，3，4，1
 */
public class Demo13 {
    public static void main(String[] args) {
        //定义一个数组
        int [] arr = {1,2,3,4,5};
        //将数组0索引和最大索引处的值进行交换
        //可以利用第三方变量进行交换
        int temp = arr[0];
        arr[0] = arr[4];
        arr[4] = temp;
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }

    }
}

package com.test01;
/*
需求：定义一个数组，存入1，2，3，4，5，交换索引首尾对应的元素
    交换前：1，2，3，4，5
    交换后：5，2，3，4，1
 */
public class Demo14 {
    public static void main(String[] args) {
        //定义数组，存储数据
        int [] arr = {1,2,3,4,5};
        //利用循环交换数据
        for (int i = 0,  j = arr.length-1; i<j;i++,j--) {
            //交换i和j指向的元素
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        //遍历后打印验证
            for (int i1 = 0; i1 < arr.length; i1++) {
                System.out.println("交换后的顺序为"+arr[i1]);
            }
        }
    }

package com.test01;
//需求：定义一个数组，存入1-5，要求打乱数组中所有的数据的顺序
import java.util.Random;
/*难点：如如何获取数组中的随机索引
    int []arr = {1,2,3,4,5};  //索引范围：0，1，2，3，4
    Random r = new Random();
    int Randomindex = r.nextInt(arr.length);
 */
public class Demo15 {
    public static void main(String[] args) {
        //定义一个数组
        int [] arr = {1,2,3,4,5};  //索引范围：0，1，2，3，4
        //2.循环遍历数组，从0索引开始打乱索引的顺序
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            //生成随即索引
            int Randomindex = r.nextInt(arr.length);
            //拿着随机索引和i指向的元素进行交换
            int temp = arr[i];
            arr[i] = arr[Randomindex];
            arr[Randomindex] = temp;
        }
        //当循环介结束后，那么数组中所有的数据已经打乱顺序了
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }


    }
}

7.数组常见问题

1，越界异常：

​ 当访问了 数组中不存在的索引，就会引发越界异常

​ 最小索引：0

​ 最大索引：数组长度-1