Java数组多方面详解

Java数组

---

一、数组

数组的概念

概念：具有一组相同数据类型的数据结构。（理解为容器，就是存储数据的）

• 相同数据类型
• 数据结构：在内存中是连续的内存空间。

数组的使用

数组中可以存储任意类型的数据，但是数组本身是引用类型的

创建数组

语法：
动态创建数组：创建和赋值分开写。

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];

数组定义格式详解：
1.数组存储的数据类型： 创建的数组容器是什么类型就可以存储对应的数据类型。
2.[] : 表示数组。
3.数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
4.new ：关键字，创建（初始化）数组使用的关键字。
5.数组存储的数据类型： 创建的数组容器可以存储什么数据类型
6.[ 长度]：数组的长度，表示数组容器中可以存储多少个元素。
*注：创建数组时要指明数组的大小(长度，容量)，然后再使用,数组有定长特性，长度一旦指定，不
可更改。

示例：

int [] arr = new int[3]; //先创建
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

静态创建数组：创建数组和赋值写一起

1 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
2 数据类型[] 数组名 = {元素1,元素2,元素3...};
例如：int[] arr = {1,2,3,4,5}

示例：
3 public class Demo1 {
4 public static void main(String[] args) {
5
6 int i = 100;
7
8 /*
9 数组的标识是[];arr=Array
10 语法：
11 数据类型[] 数组名 = new 数据类型[数组的长度];
12 数组是引用类型
13 数组声明之后，没有赋值，那么他的默认值和成员变量一样。。。
14
15 */
16
17 //第一种定义方式：动态初始化，
18 int[] arr = new int[3];
19 //System.out.println(arr);
20 //方法数组元素的语法：数组名[下标]
21
22 arr[0] =1;//存数据
23 arr[1] =2;
24 arr[2]= 5;
25 System.out.println(arr[0]);//取数据
26
27 System.out.println("arr[1]--->"+arr[1]);
28 System.out.println("arr[2]---->"+arr[2]);
29 //System.out.println("arr[2]---->"+arr[3]);//访问数组的元素的时候，下标超过了边界，那
30 //java.lang.ArrayIndexOutOfBoundsException: 3,这个叫数组越界异常
31
32 // String[] arr2 = new String[3];
33 // System.out.println("arr2[0]---->"+arr2[0]);
34
35
36
37 //可以新建任意类型的数组，但是数组本身是引用类型
38 //Object[] arr2 = new Object[3];
39
40
41 //第二种：静态初始化
42 /*
43 左边是声明数组，开辟内存；
44 右边里面大括号{}包含的元素个数，顺序，会自动计算长度，还有元素的位置
数组名(arrName)，数组的类型(type)，长度(容量length)，下标(index)，元素(element)
注意点：
数组只有一个名称，即标识符
元素索引标明了元素在数组中的位置，下标从0开始
数组中的每个元素都可以通过下标来访问
数组的长度固定不变，避免数组越界
数组变量属于引用类型
数组元素的默认值和成员变量的默认值一样
数组的遍历
方法一
普通for循环：
1 for(int i =0 ;i < arr.length;i++){
2 System.out.println(arr[i]);
3 }
方法二
增强for循环(jdk1.5)：
1 //语法：
2 for(type element : array){
3 System.out.println(element);
4 }
5
6 //示例代码：
7 for (int e : arr) {
8 System.out.println("--->" + e);
45 */
46 int[] arr2 = {1,4,5,6,7};//
47
48 //访问数组的长度:数组名.length
49 System.out.println("arr2.length="+arr2.length);

数组名(arrName)，数组的类型(type)，长度(容量length)，下标(index)，元素(element)
注意点：

• 数组只有一个名称，即标识符
• 元素索引标明了元素在数组中的位置，下标从0开始
• 数组中的每个元素都可以通过下标来访问
• 数组的长度固定不变，避免数组越界
• 数组变量属于引用类型
• 数组元素的默认值和成员变量的默认值一样

数组的遍历（读取使用）

方法一

普通for循环：

1 for(int i =0 ;i < arr.length;i++){
2 System.out.println(arr[i]);
3 }

方法二：

增强for循环(jdk1.5)：

//语法：
2 for(type element : array){
3 System.out.println(element);
4 }
5
6 //示例代码：
7 for (int e : arr) {
8 System.out.println("--->" + e);
9 }

缺陷：遍历数组或集合时无法访问索引(下标)值
用途：一般用于遍历显示数组或集合中元素的内容。

可变参数

一个方法中，参数的类型确定，但是数量不确定。就可以使用可变参数。
方法当中可变参数，就是数组。
语法： 参数类型 … 参数名
调用：参数的数量：0-多个

/**
2 * 求多个整数的和：数量不确定，类型确定
3 * 可变参数：
4 * 语法：数据类型 ... 参数名
5 *
6 * @return
7 */
8 public int getSum(int... nums) {
9 int sum = 0;
10 for(int i= 0;i<nums.length;i++){
11 sum += nums[i];
12 }
13 return sum;
14 }

注意事项：
1.一个方法最多只能有一个可变参数。
2.如果形参列表中，除了可变参数，还有其他的参数，可变参数要位于参数列表的末尾。

数组拷贝

浅拷贝：拷贝的是内存地址，
深拷贝：拷贝的是数值。

public class Demo {
4 public static void main(String[] args) {
5 int[] nums = new int[3];
6 nums[0] = 1;
7 nums[1] = 4;
8 nums[2] =5;
9
10 for(int i=0;i<nums.length;i++){
11 System.out.println("nums["+i+"]---->"+nums[i]);
12 }
13 System.out.println();
14
15 int[] arr = nums;//拷贝的是内存地址，
16 arr[0] = 20;
17 System.out.println(arr[0]);
18 System.out.println(nums[0]);
19
20
21 int[] arr2 = new int[3];
22
23 for(int i=0;i<nums.length;i++){
24 arr2[i] = nums[i];//拷贝的是数值。
25 }
26
27 arr2[0] = 90;
28 System.out.println("arr2[0]--->"+arr2[0]);
29 System.out.println("nums[0]--->"+nums[0]);
30
31
32 }
33 }

Arrays数组的工具类

常用方法：
binarySearch(数组，key)–>int，二分搜索
sort(数组)–>void，排序
toString(数组)–>String，按照字符串打印数组中的内容
copyOf(原始数组，新数组长度)–>新数组，数组拷贝
equals(数组1，数组2)–>boolean
示例：

int[] arr1 = {1,3,4,5,8,3};
3 int key = 5;
4 System.out.println("5所在的下标："+Arrays.binarySearch(arr1,key));
5
6 //Arrays.copyOf,从arr1数组中找打4个元素给新的数组
7 int[] arr2 = Arrays.copyOf(arr1,15);//深拷贝
8 System.out.println("遍历新的数组:");
9 for(int e:arr2){
10 System.out.print(e+"\t");
11 }
12 System.out.println();
13 arr2[0] = 100;
14 System.out.println("arr1[0]--->"+arr1[0]);
15 System.out.println("arr2[0]--->"+arr2[0]);
16
17 System.out.println("-------------");
18
19 int[] arr3 = {1,3,4,5};
20 int[] arr4 = {1,3,4,5};
21 System.out.println("两个数组是否相等："+arr3.equals(arr4));
22 System.out.println("两个数组是否相等："+Arrays.equals(arr3,arr4));
23
24 System.out.println("---------");
25
26 System.out.println(Arrays.toString(arr4));
27
28 System.out.println("---------");
29
30 boolean[] arr5 = new boolean[5];
31 Arrays.fill(arr5,false);
32 System.out.println("打印一下：");
33 System.out.println(Arrays.toString(arr5));
34 // for(int i=0;i<arr5.length;i++){
35 // arr5[i] = true;
36 // }
37
38
39 System.out.println("------------");
40 int[] arr6 = {4,43,6,4,7};
41 Arrays.sort(arr6);
42 System.out.println(Arrays.toString(arr6));

二维数组

一维数组，容器，存储了一组数据。数组名配合下标获取到的就是元素数据了，也就是数值。
二维数组，容器，存储一维的一维。二维数组中的元素，而是一维数组。
示例：

public class Demo4 {
4 public static void main(String[] args) {
5
6 int[] arr = {1,3,5,6,6};
7
8
9
10 int[][] arr2 = new int[3][4];
11 System.out.println("arr2:"+arr2);//二维数组的地址
12 System.out.println("arr2.length:"+arr2.length);//二维数组的长度
13 System.out.println("arr2[0]:"+arr2[0]);//第一个一维数组的地址
14 System.out.println("arr2[0].length:"+arr2[0].length);//第一个一维数组的长度
15 System.out.println("arr2[0][0]:"+arr2[0][0]);//第一个一维数组的第一个元素；
16
17 System.out.println("--------------------------");
18 //二维的数组的静态声明
19 int[][] arr3 = {{1,2,3},{4,5},{6,7}};
20
21 System.out.println("二维数组的打印：");
22
23 for(int i=0;i<arr3.length;i++){//外层控制二维里面有多少个一维
24
25 for(int j=0;j<arr3[i].length;j++){
26 System.out.print(arr3[i][j]+"\t");
27 }
28 System.out.println();
29 }
30
31 System.out.println("--------------");
32 int[][] arr4 = new int[3][];
33 System.out.println(arr4[0]);
34 arr4[0] = new int[3];
35 arr4[1] = new int[2];
36 arr4[2] = new int[4];
37
38
39 }
40 }