【JAVA入门】Day03 - 数组

---

---

一、数组的概念

        数组就是一种容器，可以用来存储同种数据类型的多个值。
        数组在存储数据时，存在隐式转换现象。例如：int 类型数组可以存储（byte short int）这几种类型，因为 int 相比另外二者更高级，在存储时会自动转换为 int 型。同样地，如果把 int 型存入 double 数组，一样会转换为 double 类型存储，double 类型可以存储（byte short int long float double）。

二、数组的定义

        数组有两种定义方法：

• int [ ] array
• int array[ ]

int是数据类型，[ ]表示是数组，array是数组名。

2.1 数组的静态初始化

在内存中，为数组提前开辟好空间，并将数据存入容器中。

• 完整格式：
  数据类型[ ] 数组名 = new 数据类型[ ] { 元素1， 元素2， 元素3…}；
• 例：

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

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

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

2.2 数组的地址值

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

        这里直接输出，用数组名作参数，返回的是数组的地址值，表示数组在内存中的位置。[ 表示当前是一个数组，I 表示这是一个 int 型数组，@是一个间隔符号，6d03e736 是数组真正的地址值（十六进制）。

2.3 数组元素的访问

        利用索引来访问数组某个元素。
        格式：数组名[索引];
例：

int[] arr = {1, 2, 3, 4, 5};
int number = arr[0];
System.out.println(number); //1
System.out.println(arr[1]); //2

        利用索引也可以把数据存储到数组中：

arr[0] = 100;
System.out.println(arr[0]); //100

2.4 数组遍历

        数组遍历，就是把数组中所有的内容都取出来。

//1.定义数组
int[] arr = {1, 2, 3, 4, 5};
//2.获取数组里面所有的元素
for(i = 0; i < 5; i++;) {
	System.out.println(arr[i]); //1 2 3 4 5
}
//3.如果不知道数组长度，可以用length
for(i = 0; i < arr.length; i++) {
	System.out.println(arr[i]); //1 2 3 4 5
}

【例1】遍历数组并求和

//1.定义一个数组，并添加数据1，2，3，4，5
int[] arr = {1, 2, 3, 4, 5};
//2.遍历数组得到每一个数据，累加求和
int sum = 0;  //求和变量
for(int i = 0; i < arr.length; i++) {
	sum = sum + arr[i];
}

【例2】统计数组元素个数

//统计数组中能被3整除的数组有多少个
int[] arr = {1,2,3,4,5,6,7,8,9,10};
count = 0;
for(int i = 0; i < arr.length; i++) {
	if(arr[i] % 3 == 0){
		System.out.println(arr[i]);
		count++;
	}
}
System.out.println("数组中能被3整除的数字有" + count + "个");

【例3】变化数组
定义一个数组，遍历之，如果是奇数，当前数字乘2，如果是偶数，当前数字变为二分之一。

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] = arr[i] / 2;
	}
	else {
		arr[i] = arr[i] * 2;
	}
	System.out.println(arr[i]);
}

2.5 数组的动态初始化

        动态初始化时，只指定数组长度，由系统为数组分配初始值。
格式：数据类型[ ] 数组名 = new 数据类型[数组长度];
例：

int[] arr = new int[3];

        动态初始化后，可以直接给新增的空间位置赋值，即填入元素。

//初始化一个字符串数组
String[] arr = new String[3];
arr[0] = "xiaozhan";
arr[1] = "dingzhen";

        获取元素时，除了已赋值的元素，还可以获取未赋值的空位置，这个位置上存储的值应为默认的初始值。

System.out.println(arr[0]);  //xiaozhan
System.out.println(arr[1]);  //dingzhen
System.out.println(arr[2]);  //null（初始值）

        不同数据类型的数组初始化后有不同的初始值：

//整数类型：0
//小数类型：0.0
//字符类型：'/u0000' 即空格
//布尔类型：false
//引用类型：null （String也是引用类型）

2.6 数组的常见操作

【例1】求最值。
需求：已知数组元素为 {33，5，22，44，55}

int[] arr = {33,5,22,44,55};
int max = arr[0];
for(int i = 0; i < arr.length; i++) {
	if(arr[i] >= max) {
    	max = arr[i];
    }
}
System.out.println(max);

• 注意，max 的初始值一定要是数组中存在的值，这样才不容易出错。

【例2】遍历数组求和。
需求：生成10个1~100之间的随机数存入数组。然后求出数组的和、平均数，统计多少个元素比平均数小，最后打印数组。

import java.util.Random;

int[] arr = new int[10];
        Random r = new Random();

        for(int i = 0; i < arr.length; i++) {
            //每循环一次，就生成一个新的随机数
            int number = r.nextInt(100) + 1;
            //把生成的随机数添加到数组当中
            arr[i] = number;
        }

        //遍历数组求和
        int sum = 0;
        for(int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("数组中所有数的和为："+ sum);

        //求平均值
        int avg = sum / arr.length;
        System.out.println("数组中所有数的平均值为："+ avg);

        //统计有多少个数据比平均值小
        int count = 0;
        for(int i = 0; i < arr.length; i++) {
            if(arr[i] < avg) {
                count++;
            }
        }
        System.out.println("有"+count+"个数比平均值小");

        //遍历打印数组
        for(int i = 0; i < arr.length; i++)
            System.out.print(arr[i] + " ");

【例3】交换数组中的数据
需求：定义一个数组，存入1，2，3，4，5.按照要求交换索引对应的元素。
交换前：1，2，3，4，5
交换后，5，2，3，4，1

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

//利用第三方变量进行交换
int temp = arr[0];
arr[0] = arr[4];
arr[4] = temp;

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

需求变式：将数组倒置。

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

for(int i = 0,j = arr.length - 1 ; i < j; i++,j--) {
	temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}
for(int i = 0; i < arr.length; i++) {
	System.out.print(arr[i] + " ");
}

【例4】打乱数组顺序。
需求：给定一个数组{1，2，3，4，5}，要求打乱这五个数字的顺序。
思路：可以利用 Random 把索引打乱，数组元素自然也会打乱。

int[] arr = {1,2,3,4,5};
//索引范围：0 1 2 3 4
Random r = new Random();
//从0索引开始，打乱数据的顺序
for(int i = 0; i < arr.length; i++) {
	int randomIndex = r.nextInt(arr.length);//随机0~4，括号里要填5，这里arr.length就是5，这样写更泛用
	int temp = arr[i];
	arr[i] = arr[randomIndex];
	arr[randomIndex] = temp;
}
for(int i = 0; i < arr.length; i++) {
	System.out.print(arr[i] + " ");
}

2.7 数组的内存分配

2.7.1 Java内存分配

Java的虚拟机（JVM）在运行时也会占用一部分计算机的内存空间，而 JVM 有更精细的规划：

注：从 JDK8 开始，“方法区”被移除，改换“元空间”，把原方法区多种功能进行拆分，一部分放到了堆中，一部分放入了元空间中。

各区域用途：

• 栈                      方法运行时使用的内存，比如 main 方法运行，进入方法栈中执行。
• 堆                      存储对象或者数组，new 创建的东西，都存储在堆内存。
• 方法区               存储可以运行的 class 文件。
• 本地方法栈        JVM 在使用操作系统功能的时候使用。
• 寄存器               给CPU使用。

2.7.2 数组的内存图

数组在内存中的存储同时用到了栈空间和堆空间，具体存储方式如下：

public static void main(String[] args) {
	int[] arr = new int[2];
	
	sout(arr);
	sout(arr[0]);
	sout(arr[1]);
	
	arr[0] = 11;
	arr[1] = 22;
	sout(arr[0]); 

	sout("-----------------");
	int[] arr2 = {33, 44, 55};
	sout(arr2);
	sout(arr2[0]);
	sout(arr2[1]);
	sout(arr2[2]);
}

        如图所示，创建一个二元数组，在堆中开辟了一处空间，存放了数组长度、数组元素和索引，然后将这块堆空间的地址值记录下来放入栈中，代表数组 arr 的地址。通过寻访栈内存中的数组地址值，可以找到堆内存中的这块空间，从而找到数组的数据存储所在。
        下图中我们又创建了一个数组 arr2，这次直接将其初始化，同样地也在堆空间里开辟了一块空间存储，然后将这块空间的地址值存储在栈空间。在访问时，先访问栈空间，再根据栈空间的地址值访问堆空间，找到数组内容。


        除了以上那种基本的存储方法，还存在两个数组指向同一个空间的内存这样的情况。

public static void main(String[] args) {
	int[] arr1 = {11, 22};
	int[] arr2 = arr1;

	sout(arr1[0]);
	sout(arr2[0]);
	
	arr2[0] = 33;

	sout(arr1[0]);
	sout(arr2[0]);
}

        根据上方的代码，显然 arr1 和 arr2 是同一个数组。在创建 arr1 数组后，仍是开辟了一块堆空间和一块栈空间。

        而在创建 arr2 数组后，指向了 arr1 ，它们存储的是同一个的地址值。

        因此它们指向的一定是同一块堆空间，这样就只开辟了一块堆空间。在寻址时，找的自然也是同一块堆空间。因此，我们通过 arr2[0] = 33；修改了堆空间索引为 0 的位置上的值：

此时 arr1[0] 位置上的值，也会发生改变。因此：

sout(arr1[0]);
sout(arr2[0]);

        输出的值应为一样的，都是33。这是 JAVA 内存存储方式导致的。在使用时，只需要默认认为 arr1 和 arr2 是同一个数组即可，修改 arr1 ，arr2 也会发生变化。