【JAVA入门】Day03 - 数组
文章目录
- 【JAVA入门】Day03 - 数组
- 一、数组的概念
- 二、数组的定义
- 2.1 数组的静态初始化
- 2.2 数组的地址值
- 2.3 数组元素的访问
- 2.4 数组遍历
- 2.5 数组的动态初始化
- 2.6 数组的常见操作
- 2.7 数组的内存分配
- 2.7.1 Java内存分配
- 2.7.2 数组的内存图
一、数组的概念
数组就是一种容器，可以用来存储同种数据类型的多个值。
数组在存储数据时，存在隐式转换现象。例如：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 也会发生变化。
