Java 数组

发表于 | 更新于 | 评论数： | 阅读次数：

写在开头

 大朋友小朋友节日快乐 🎈
 “你可以不太乖 你不可以学坏”
 今天编辑了下About页面，复习了之前学过的内容，接下来再啃一块大骨头。
 进入正题，搜索功能已经完善好了，可以直接从左侧搜索~  这一篇写java数组。

概念

举个栗子：
 现在想存储5名同学的姓名，目前我们可以用定义5个String类型的变量,存储学生姓名来实现。

 现在我想存储5000名同学的姓名，我们一个再用定义5个String类型的变量，就显得异常复杂，且查找同学的时候也变得很困难。

 我们就想着找一个容器，存放着大量的数据，这个容器就是数组。

 数组可以存放任意类型，但是同一次存放的必须是同一个类型。数组自动编号，通过数组这种特有的方式,将每一个学生的信息都获取到，编号从0开始。

数组的定义方法 //两种定义方式

引用数据类型: 类(class),数组,接口

动态定义

定义格式:
数据类型[] 数组名 = new 数据类型[数组的长度];
int[] arr = new int[3];

数组定义格式分析:

  1. 数据类型 : 当前数组容器中,可以存放什么类型的数据

  2. [] : 表示是一个数组,一维数组

  3. 数组名: 名字,符合标识符的规范

  4. new : 新建,给数组在内存中开辟一块空间,用于存储数据

  5. 数据类型: 与前面的数据类型保持一致

  6. [数组长度]: 数组长度必须给出,确定在内存中给数组开辟的空间是多大

    举例: int[] arr = new int[3];

 说明: 数组作为引用数据类型存在,变量值已经不是普通的数值,变量就表示当前数组在内存中的地址(类的变量名也是一样,都是在内存中的地址值)

静态定义:

 当明确知道数组中的内容,可以进行静态定义,静态定义仍然在内存中开辟空间,只不过JVM给的初始值0,还是有,JVM赋完初值后,数组大括号中的数据依次替换到对应的索引位置处

定义方式: 数据类型[] 数组名 = {数据};
举例: int[] arr = {2,3,4,7,-2,77};// 数组长度为6

索引: 0索引上的元素值2,依次类推,… 5索引上的元素为77

说明: 大括号中的数据个数,没有限定

在代码中展示下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//数组的定义
public class  ArrDefine
{
	public static void main(String[] args) 
	{
		// 定义一个int类型的数组,数组的长度为3,动态定义
        int[] arr = new int[3];
		System.out.println(arr);//[I@15db9742


		// 静态的定义
		int[] arr1 = {1,2,4,5,-9,77};
		System.out.println(arr1);//[I@6d06d69c
		System.out.println(arr1[4]);// -9 

		// 动静结合

		int[] arr2 = new int[]{1,2,4,5,-9,77};
		System.out.println(arr2);//[I@7852e922
		System.out.println(arr2[5]);// 77 

	}
}

数组中元素的获取 // 索引

int[] arr = new int[3];// 索引 0-2
arr数组,里面能存储3个int类型的元素

索引: index,所有类型的数组,都具有索引
索引就表示,在数组中,每个元素在数组中的房间号,与数组的内存地址无关
索引都从0开始,到(数组长度-1)结束

如何通过索引获取到对应的元素?
数组名[索引];
arr[0];
arr[1];
arr[2];

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 获取数组中的元素
public class ArrGet1 
{
	public static void main(String[] args) 
	{
		// 定义一个int类型的数组,长度为3
		int[] arr = new int[3];// 索引 0-2
		System.out.println(arr);
		// 获取数组中的元素,通过索引的方式
		int x = arr[0];
		int y = arr[1];
		int z = arr[2];

		System.out.println(x);
		System.out.println(y);
		System.out.println(z);
	}
}

数组的内存图

数组元素的手动赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 获取数组中的元素
public class ArrGet1 
{
	public static void main(String[] args) 
	{
		// 定义一个int类型的数组,长度为3
		int[] arr = new int[3];// 索引 0-2
		System.out.println(arr);
		// 给数组中的元素进行赋值  数组名[索引] = 值;
		arr[0] = 5;
		arr[1] = 8;
		arr[2] = 5;

		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
	}
}

数组与内存地址的对应案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//每次new都在内存中创建新的地址空间
//数组的内存地址解析
public class  ArrAddress
{
	public static void main(String[] args) 
	{
		// i 和 i1 都是内存中的地址值,i和i1在内存中的地址一不一样
		int[] i = new int[3];
		int[] i1 = new int[3];
		boolean b  = i == i1;// false

		System.out.println(i);//[I@15db9742
		System.out.println(i1);//[I@6d06d69c
		System.out.println(b);//false
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//A数组地址赋值给B数组后,B数组中元素的变化案例
//数组的内存地址解析
public class  ArrAddress
{
	public static void main(String[] args) 
	{
		// i 和 i1 都是内存中的地址值,i和i1在内存中的地址一不一样
		int[] i = new int[3];
		int[] i1 = new int[3];
		int[] i2 = new int[6];
		i1 = i2;// 将i2在内存中的地址值赋值给i1,现在i1和i2指向内存中的同一块空间
		boolean b  =  i == i1;// false
		boolean b1  =  i1 == i2; //true

		System.out.println(i);//[I@15db9742
		System.out.println(i1);//[I@6d06d69c
		System.out.println(i2);//[I@6d06d69c
		System.out.println(b);//false
		System.out.println(b1);//true
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

//数组的内存地址解析
public class  ArrAddress
{
	public static void main(String[] args) 
	{
		// i 和 i1 都是内存中的地址值,i和i1在内存中的地址一不一样
		int[] i = new int[3];
		int[] i1 = new int[3];
		i1[0] = 5;// i1的0索引元素赋值5
		int[] i2 = new int[6];
		i2[0] = 9;// i2的0索引元素赋值9
		i1 = i2;// 将i2在内存中的地址值赋值给i1,现在i1和i2指向内存中的同一块空间

		System.out.println(i);//[I@15db9742
		System.out.println(i1);//[I@6d06d69c
		System.out.println(i2);//[I@6d06d69c
		System.out.println(i1[0]);// 9 
	}
}

晚安

 今天就到这里了，明天见，加油！

-------------本文结束感谢您的阅读-------------
0%