[从0开始学Java|第五天]Java数组

数组的概述和静态初始化

什么是数组?

数组指的是一种容器,可以用来存储同种数据类型的多个值.

-数组容器在存储数据的时候,需要结合隐式转换考虑

-建议:容器的类型,和存储的数据类型保持一致.

数组的定义

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

范例: int [ ] array

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

范例: int array[ ]

数组的初始化

**初始化:**就是在内存中,为数组容器开辟空间,并将数据存入容器中的过程

数组的静态初始化

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

范例: int[] array = new int[]{11,22,33};

范例: double[] array2 = new double[]{11.1,22.2,33.3};

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

范例: int[] array = {11,22,33};

(源代码)

package arraydemo;

public class ArrayDemo1 {
    public static void main(String[] args) {
        //需求1:定义数组存储5个学生的年龄
        int[] arr1 = new int[]{11,12,13,14,15};
        int[] arr2 = {11,12,13,14,15};
        //需求2:定义数组存储3个学生的姓名
        String[] arr3 = new String[]{"张三","李四","王五"};
        String[] arr4 = {"张三","李四","王五"};
        //需求3:定义数组存储4个学生的身高
        double[] arr5 = new double[]{1.93,1.75,1.73,1.81};
        double[] arr6 = {1.93,1.75,1.73,1.81};
    }
}

数组的地址值和元素访问

数组的地址值

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

定义一个数组,就是在内存中开辟了一处空间,如下图:

例如:

(源代码)

package arraydemo;

public class ArrayDemo1 {
    public static void main(String[] args) {
        //需求1:定义数组存储5个学生的年龄
        int[] arr1 = new int[]{11,12,13,14,15};
        int[] arr2 = {11,12,13,14,15};
        //需求2:定义数组存储3个学生的姓名
        String[] arr3 = new String[]{"张三","李四","王五"};
        String[] arr4 = {"张三","李四","王五"};
        //需求3:定义数组存储4个学生的身高
        double[] arr5 = new double[]{1.93,1.75,1.73,1.81};
        double[] arr6 = {1.93,1.75,1.73,1.81};
        System.out.println(arr6);//[D@f6f4d33
    }
}

(运行结果截图)

扩展:

解释一下地址值的格式含义 [D@f6f4d33

[ :表示当前是一个数组

D:表示当前数组里面的元素都是double类型的

@:表示一个间隔符.(固定格式)

f6f4d33:数组真正的地址值

平时我们习惯性地会把这个整体叫做数组的地址值

数组元素访问

格式: 数组名[索引];

索引

**索引:**也叫做下标,角标.

**索引的特点:**从0开始,逐个+1增长,连续不间断

练习:利用索引对数组中的元素进行访问

1.获取数组里面的元素

格式: 数组名[索引];

(源代码)

package arraydemo;

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        //获取数组中的第一个元素
        //其实就是0索引上对应的元素
        int number = arr[0];//1
        System.out.println(number);
        //获取数组中1索引上对应的数据,并直接打印出来
        System.out.println(arr[1]);//2
    }
}

(运行结果截图)

2.把数据存储到数组当中

格式: 数组名[索引] = 具体数据/变量;

细节:一旦覆盖之后,原来的数据就不存在了.

(源代码)

package arraydemo;

public class ArrayDemo3 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        arr[0] = 100;
        System.out.println(arr[0]);//100
    }
}

(运行结果截图)

数组的遍历和三道综合练习

什么是数组的遍历?

**数组遍历:**将数组中的所有内容取出来,取出来后可以(打印,求和,判断)

**注意:**遍历指的是取出数据的过程,不要局限的理解为,遍历就是打印

小提示:

在Java当中,关于数组的一个长度属性: length

调用方式: 数组名.length

package arraydemo;

public class ArrayDemo4 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {1,2,3,4,5};
        //2.获取数组里面的所有元素
        /*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]);*/

        //利用循环改进代码
        //开始条件:0
        //结束条件:数组的长度 - 1 (最大索引)
        /*for (int i = 0; i <= 4; i++) {
            //i:0 1 2 3 4
            System.out.println(arr[i]);
        }*/

        //在Java当中,关于数组的一个长度属性: length
        //调用方式:数组名.length
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

扩展:

IDEA提供的自动地快速生成数组的遍历方式: 数组名.fori

练习:遍历数组并求和

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

(源代码)

package arraydemo;

public class ArrayDemo5 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int sum = 0;
        for(int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        System.out.println(sum);//15
    }
}

(运行结果截图)

练习:统计个数

**需求:**定义一个数组,存储1,2,3,4,5,6,7,8,9,10,遍历数组得到每一个元素,统计数组里面一共有多少个能被3整除的数字

(源代码)

package arraydemo;

public class ArrayDemo6 {
    public static void main(String[] args) {
        /*需求:定义一个数组,存储1,2,3,4,5,6,7,8,9,10,
        遍历数组得到每一个元素,统计数组里面一共有多少个能被3整除的数字*/

        //分析:
        //1.定义一个数组,存储1,2,3,4,5,6,7,8,9,10
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int count = 0;
        //2.遍历数组得到每一个元素
        for(int i = 0; i < arr.length; i++) {
            //3.判断当前的元素是否为3的倍数,如果是那么统计变量就需要自增一次
            if(arr[i] % 3 == 0) {
                count++;
            }
        }
        System.out.println("能被3整除的数字有" + count + "个");
    }
}

(运行结果截图)

练习:变化数据

**需求:**定义一个数组,存储1,2,3,4,5,6,7,8,9,10,遍历数组得到每一个元素,要求:1.如果是奇数,则将当前数字扩大两倍;2.如果是偶数,则将当前数字变成二分之一

(源代码)

package arraydemo;

public class ArrayDemo7 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for(int i = 0; i < arr.length; i++) {
            if(arr[i] % 2 ==0) {
                arr[i] /= 2 ;
            }else{
                arr[i] *= 2 ;
            }
            System.out.println(arr[i]);//运行结果可以,但是不推荐这样写
        }
    }
}

注: 上述代码运行结果正确,但是不推荐这样写,一个循环尽量只做一件事情..

[修改后代码]

package arraydemo;

public class ArrayDemo7 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for(int i = 0; i < arr.length; i++) {
            if(arr[i] % 2 ==0) {
                arr[i] /= 2 ;
            }else{
                arr[i] *= 2 ;
            }
        }
        for(int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

(运行结果截图)

数组的动态初始化和常见问题

什么是动态初始化?

**动态初始化:**初始化时只指定数组长度,由系统为数组分配初始值.

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

特点:在创建的时候,由我们自己指定数组的长度,由虚拟机给出默认的初始化值.

范例: int[] arr = new int[3]
数组默认初始化值的规律:

整数类型 :默认初始化值0

小数类型 :默认初始化值 0.0

字符类型 :默认初始化值 '/u0000' 空格

布尔类型 :默认初始化值 false

引用数据类型 :默认初始化值 null

练习

**需求:**定义一个数组,用来存储班级中50个学生的姓名,学生姓名未知,等学生报道之后再进行添加

(源代码)

package arraydemo;

public class ArrayDemo8 {
    public static void main(String[] args) {
        /*需求:定义一个数组,用来存储班级中50个学生的姓名,
        学生姓名未知,等学生报道之后再进行添加*/
        String[] arr = new String[50];
        arr[0] = "张三";
        arr[1] = "李四";
        System.out.println(arr[0]);//张三
        System.out.println(arr[1]);//李四
        System.out.println(arr[2]);//null

        int[] arr2 = new int[3];
        System.out.println(arr2[0]);//0
        System.out.println(arr2[1]);//0
        System.out.println(arr2[2]);//0
    }
}

(源代码)

数组动态初始化和静态初始化的区别

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

**使用场景:**只明确元素个数,不确定具体数值,推荐使用动态初始化.

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

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

数组常见问题

索引越异常

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

例如:

(源代码)

package arraydemo;

public class ArrayDemo9 {
    public static void main(String[] args) {
        //1.定义一个数组
        int[] arr = {1,2,3,4,5};
        //长度:5
        //最小索引:0
        //最大索引:4(数组长度 - 1)

        //2.打印数组
        System.out.println(arr[10]);//索引越界异常
    }
}

(运行结果截图)

数组常见操作

求最值

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

思路分析:

**注:**max的初始化值一定要是数组中的值

(源代码)

package arraydemo;

public class ArrayDemo10 {
    public static void main(String[] args) {
        int[] arr = {33,5,22,44,55};
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        System.out.println(max);//55
    }
}

(运行结果截图)

扩展问题:

1.根据求最大值的思路,自己改写一下求最小值

(源代码)

package arraydemo;

public class ArrayDemo11 {
    public static void main(String[] args) {
        int[] arr = {33,5,22,44,55};
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        System.out.println(min);//5
    }
}

(运行结果截图)

遍历数组求和

**需求:**生成10个1~100之间的随机数存入数组,要求:1.求出所有数据之和;2.求所有数据的平均值;3.统计有多少个数据比平均值小

(源代码)

package arraydemo;

import java.util.Random;

public class ArrayDemo12 {
    public static void main(String[] args) {
        Random r = new Random();
        int[] number = new int[10];
        int sum = 0;
        int count = 0;
        for(int i = 0 ; i < 10 ; i++) {
            number[i] = r.nextInt(100) + 1;
            sum = sum + number[i];
        }
        System.out.println("数组的和为：" + sum);
        System.out.println("数组的平均值为：" + (sum / 10));
        for(int i = 0 ; i < 10 ; i++) {
            if(number[i] < (sum/10)) {
                count++;
            }
        }
        System.out.println("数组中小于平均值的个数为：" + count);

        for(int i = 0 ; i < 10 ; i++) {
            System.out.print(number[i] + " ");
        }
    }
}

(源代码)

交换数组中的数据

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

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

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

(源代码)

package arraydemo;

public class ArrayDemo13 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] arr2 = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
        for(int i = 0; i < arr.length; i++) {
            arr2[i] = arr[4 - i];
        }
        System.out.println();
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr2[i]);
        }
    }
}

(运行结果截图)

打乱数组中的数据

**需求:**定义一个数组,存入1~5.要求打乱数组中所有数据的顺序.

(源代码)

package arraydemo;

import java.util.Random;

public class ArrayDemo14 {
    public static void main(String[] args) {
        //需求:定义一个数组,存入1~5.要求打乱数组中所有数据的顺序.

        //分析:
        //1.定义数组存储1~5
        int[] arr = {1,2,3,4,5};
        //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;
        }
        //3.打印打乱后的数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

(运行结果截图)

数组的内存图

Java内存分配

-栈:方法运行时使用的内存,比如main方法运行,进入方法栈中执行

-堆:存储对象或者数组,new来创建的,都存储在堆内存

-方法区:存储可以运行的class文件

-本地方法栈:JVM在使用操作系统功能的时候使用,和我们开发无关

-寄存器:给CPU使用,和我们开发无关

**注意:**从JDK8开始,取消方法区,新增元空间.把原来方法区的多种功能进行拆分,有的功能放到了堆中,有的功能放到了元空间中.

最简单的代码的内存

数组的内存图

一个数组的内存图和两个数组的内存图

总结

1.只要是new出来的,一定是在堆里面开辟了一个小空间.

2.如果new了多次,那么在堆里面有多个小空间,每个小空间中都有各自的数据.

两个数组指向同一个空间的内存图

总结

当两个数组指向同一个小空间时,其中一个数组对小空间中的值发生了改变,那么其他数组再次访问的时候都是修改后的结果了.