Java学习笔记-day05-数组

1、介绍

1.1 概念

数组指的是一种容器，可以同来存储同种数据类型的多个值。但是数组容器在存储数据的时候，需要结合隐式转换考虑。

1.2 定义

格式一：数据类型 [] 数组名

例如：int [] array

格式二：数据类型 数组名 []

比如： int array []

1.3 静态初始化

初始化：在内存中为数组容器开辟空间，并将数据存入容器中的过程。

完整格式：数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，元素4...};

例如：int[] arr = new int[]{11,22,33};

简化格式：数据类型[] 数组名 = {元素1，元素2，元素3，元素4...};

例如：int[] arr = {11,22,33};

注：数组一旦创建之后，长度不能发生变化。

2、元素访问

2.1 地址值（了解）

打印数组的时候，实际出现的是数组的地址值。

数组的地址值：就表示数组在内存中的位置。

int[] arr = {1,2,3,4,5};
System.out.println(arr);//输出结果：[I@6d03e736

以[I@6d03e736为例：

[ ：表示现在打印的是一个数组。

I：表示现在打印的数组是int类型的。

@：表示一个间隔符号。（固定格式）

6d03e736：就是数组在内存中真正的地址值。（十六进制）

2.2 元素访问

格式：数组名[索引];

索引：也叫角标、下标，就是数组容器中每一个小格子对应的编号。

索引的特点：索引一定是从0开始的； 连续不间断；逐个+1增长。

public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        //作用1：获取指定索引上对应的元素
        int number = array[0];
        System.out.println(number);//获取数字1

        //2.修改指定索引上对应的元素
        //一旦修改之后，原来的值就会被覆盖了
        array[0] = 10;
        System.out.println(array[0]);//10
    }
}

3、遍历

3.1 格式

遍历：就是把数组里面所有的内容一个一个全部取出来。

数组的长度：数组名.length;

通用代码：

for(int i = 0; i < arr.length; i++){
    //在循环的过程中，i依次表示数组中的每一个索引
    System.out.println(array[i]);
}

扩展：数组名.fori，由idea提供的自动的快速生成数组的遍历方式。

3.2 练习

练习一：遍历数组并求和

需求：定义一个数组，存储1,2,3,4,5，遍历数组得到每一个元素，求数组里面所有的数据之和。

public class Test {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            //array[i]依次是数组里面的每一个元素
            sum = sum + array[i];
        }
        System.out.println(sum);
    }
}

练习二：统计个数

需求：定义一个数组，存储1~10，遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字。

public class Test {
    public static void main(String[] args) {
        //1.定义数组
        int[] array = {1,2,3,4,5,6,7,8,9,10};
        int count = 0;
        //2.遍历数组
        for (int i = 0; i < array.length; i++) {
            //3.进行判断
            if (array[i] %3 == 0){
                count++;
            }
        }
        System.out.println("能被3整除的数字个数为：" + count);
    }
}

练习三：变化数据

需求：定义一个数组，存储1~10，遍历数组得到每一个元素。如果是奇数，则将当前的数字扩大两倍；如果是偶数，则将当前数字变成二分之一。

public class Test {
    public static void main(String[] args) {
        //1.定义数组
        int[] array = {1,2,3,4,5,6,7,8,9,10};
        //2.遍历数组
        for (int i = 0; i < array.length; i++) {
            //3.进行判断
            if (array[i] % 2 == 1){
                array[i] = array[i] * 2;
            }else {
                array[i] = array[i] / 2;
            }
        }
        //一个循环尽量只做一件事情
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

4、动态初始化

4.1 格式

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

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

示例：int[] arr = new int[3];

数组默认初始化值：

整数类型：0

小数类型：0.0

布尔类型：false

字符类型：'\u0000'   空格

引用类型：null

4.2 两种初始化方式的区别

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

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

使用场景：只明确元素个数，但是不明确具体的数据，推荐使用动态初始化；已经明确了要操作的所有数据，推荐使用静态初始化。

5、常见操作

5.1 求最值

需求：已知数组元素为{33,5,22,44,55}，请找出数组中最大值并打印在控制台。

public class Test {
    public static void main(String[] args) {
        //1.定义数组
        int[] array = {33,5,22,44,55};
        //max的初始化值一定要是数组中的值
        int max = array[0];
        //2.遍历数组
        for (int i = 1; i < array.length; i++) {
            //3.进行比较
            if (array[i] > max){
                max = array[i];
            }
        }
        //4.当循环结束之后，max记录的就是数组中的最大值
        System.out.println(max);
    }
}

5.2 求和

需求：生成10个1~100之间的随机数存入数组。1）求出所有数据的和；2）求所有数据的平均数；3）统计有多少个数据比平均值小。

import java.util.Random;

public class Test {
    public static void main(String[] args) {
        //定义数组
        int[] array =new int[10];
        Random r = new Random();
        //把随机数存入数组
        for (int i = 0;i <= 9;i++){
            array[i] = r.nextInt(100) + 1;
        }
        //遍历数组
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");//去掉ln则不会换行
        }
        //1）求数据和
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum = sum + array[i];
        }
        System.out.println("所有数据的和为：" + sum);
        //2）求平均数
        int average = sum / array.length;
        System.out.println("所有数据的平均数为：" + average);
        //3）求比平均值小的数据个数
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] < average){
                count++;
            }
        }
        System.out.println("比平均值小的数据个数为:" + count);
    }
}

5.3 交换数据★

需求：定义一个数组，存入1,2,3,4,5。按照要求交换索引对应的元素。

交换前：1,2,3,4,5

交换后：5,4,3,2,1

public class Test {
    public static void main(String[] args) {
        //1.定义数组存储数据
        int[] array = {1,2,3,4,5};
        //2.利用循环交换数据
        for (int i =0,j = array.length - 1;i < j;i++,j--){
            //交换变量i和变量j指向的元素
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
        //3.遍历数组，打印验证
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

5.4 打乱数据★

需求：定义一个数组，存入1~5。要求打乱数组中所有数据的顺序。

public class Test {
    public static void main(String[] args) {
        //1.定义数组存储数据
        int[] array = {1,2,3,4,5};
        Random r = new Random();
        //2.利用循环交换数据
        for (int i =0;i < array.length;i++){
            //生成随机索引
            int randomIndex = r.nextInt(array.length);
            //将当前i指向的元素与一个随机索引指向的元素进行交换
            int temp = array[i];
            array[i] = array[randomIndex];
            array[randomIndex] = temp;
        }
        //3.遍历数组，打印验证
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

5.5 常见问题

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

6、内存图

Java的内存分配：

• 栈：方法运行时使用的内存
• 堆：存储对象或者数组，new来创建的，都存储在堆内存
• 方法区：存储可以运行的class文件
• 本地方法栈：JVM在使用操作系统功能的时候使用，和开发无关
• 寄存器：给CPU使用，和开发无关

两个数组指向同一个空间：

其中一个数组对小空间的值进行修改，那么其他数组再次访问的时候都是修改之后的结果了。