java数组知识总结_java数组学习个人总结

数组

理解容器的概念
掌握数组的第一种定义方式
掌握数组的第二种定义方式
掌握数组的第三种定义方式
使用索引访问数组的元素
了解数组的内存图解
了解空指针和越界异常
掌握数组的遍历
掌握数组最大值的获取
了解数组反转的原理
了解数组作为方法参数传递
了解数组作为方法的返回值

---

1.1 数组的定义

数组（Array）:是多个相同数据类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

数组定义： 数组就是存储相同数据类型的，长度固定的数据 的容器。

理解数组：
容器：是将多个数据存储到一起，每个数据称为该容器的元素。
生活中的容器：水杯，衣柜，教室

1.2数组相关的概念：

数组名：
元素：
角标/下标/索引
数组的长度：元素的个数

1.3数组的特点：

1.数组本身是引用数据类型，而数组中的元素尅是任何数据类型，包括基本数据类型和引用数据类型。
2.创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
3.数组的长度一旦确定，就不能修改（长度在程序运行期间不可改变）。
4.我们可以直接通过下标（或索引）的方式调用指定位置的元素。速度很快。

1.4 数组的分类

按照维度：一维数组、二维数组、三维数组、…
按照元素的数据类型分：基本数据类型元素的数组，引用数据类型元素的数组（即对象数组）

1.5一维数组的使用

（1）一维数组的声明和初始化
（2）如何调用数组的指定位置的元素
（3）如何获取数组的长度
（4）如何遍历数组
（5）数组元素的默认初始化值
（6）数组内存解析

分割线----------------------------------------------------------------------------------------------

数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。
两种常见的初始化方式：

1. 动态初始化（指定长度）
2. 静态初始化（指定内容）
3. 动态初始化数组的格式：
   数据类型[] 数组名称 = new 数据类型[数组长度];
   解析含义： 左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型 左侧的中括号：代表我是一个数组 左侧数组名称：给数组取一个名字 右侧的new：代表创建数组的动作 右侧数据类型：必须和左边的数据类型保持一致 右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字

方式一：动态初始化

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

数组定义格式详解：
数组存储的数据类型： 创建的数组容器可以存储什么数据类型。
[] : 表示数组。
数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名 字操作数组。
new：关键字，创建数组使用的关键字。
数组存储的数据类型： 创建的数组容器可以存储什么数据类型。
[长度]：数组的长度，表示数组容器中可以存储多少个元素。
注意：数组有定长特性，长度一旦指定，不可更改。
和水杯道理相同，买了一个2升的水杯，总容量就是2升，不能多也不能少。
举例：
定义可以存储3个整数的数组容器，代码如下：
int[] arr = new int[3];

方式二：静态初始化

格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};
举例：int[] arr = new int[]{1,2,3,4,5};
定义存储1，2，3，4，5整数的数组容器。

代码演示数组初始化:

package com.fan.pojo;

public class ArrayTest {
    public static void main(String[] args) {
        //引入：在说一维数组的初始化之前。我们类比变量的声明和初始化
        int num;//声明变量
        num = 10;//变量的初始化
        //或者这种一步到位的
        int a = 100;//变量的 声明 + 初始化

        //同样，数组的类似
        int[] arr1;//声明
        //1.静态初始化:数组的初始化和数组元素的赋值操作同时进行
        arr1 = new int[]{1,2,3,4};
        //2.动态初始化：数组的初始化和数组的赋值操作分开进行
        String[] names = new String[5];

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

初始化方式三:省略初始化

格式：数据类型[] 数组名 = {元素1,元素2,元素3…};
举例：int[] arr = {1,2,3,4,5};
定义存储1，2，3，4，5整数的数组容器

总结三种定义方式：当带长度的时候，不能一起带数组的元素，当带数组元素的时候不能带数组的长度。
比较：
int[] arr = new int[3];
int[] arr = new int[]{1,2,3,4,5};
int[] arr = {1,2,3,4,5};

1.6 数组的访问

索引： 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引，有时候也叫下标或者角标；
(index)，可以通过数组的索引访问到数组中的元素。
格式：数组名[索引]
数组的长度属性： 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为： 数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为 数组名.length-1 。

public static void main(String[] args) {
int[] arr = new int[]{1,2,3,4,5};
//打印数组的属性，输出结果是5
System.out.println(arr.length);
}
1
2
3
4
5

获取数组的长度

属性：length

//int[] arr1 = new int[]{1,2,3,4,5};
System.out.println(arr1.length);
1
2

数组的默认初始化值：

数组元素是整型（byte/short/int/long）:0
数组元素是浮点型：0.0
数组元素是char型：0或者’\u0000’,而非’0’
数组元素是boolean型：false
数组元素是引用数据类型：null

一维数组的内存解析：

2.二维数组的使用

二维数组的理解：

我们可以画一张表格，一维数组的话，表格中只有一行；二维数组的话，表格中就有多行。也就是 我们可以看成一维数组arr又作为另一个一维数组arr2 的元素而存在。从数组的底层运行机制来看，其实没有多维数组的。
内存结构图理解：

2.1二维数组的初始化：

代码演示：

package com.fan.pojo;

public class ArrayTest {
    public static void main(String[] args) {
       //引入：先看一维数组的初始化
        int[] arr =  new int[]{1,2,3};//一维数组的初始化

        //二维数组的初始化
        //静态初始化
        int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
        //动态初始化1
        String[][] arr2 = new String[3][4];
        //动态初始化2：
        String[][] arr3 =  new String[3][];
        //错误情况
        //String [][] arr4 = new String[][4];
        //String [4][3] arr5 = new String[][];
        //int [][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};

        //真确写法:将[][]放到变量名后也可以，一维数组也有类似的写法
        int arr4[][] = new int[][]{{1,2,3},{4,5},{6,7,8}};
        int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2.2二维数组如何调用指定位置的元素和遍历

代码演示说明：

package com.fan.pojo;

public class ArrayTest {
    public static void main(String[] args) {
       //引入：先看一维数组的初始化
        int[] arr =  new int[]{1,2,3};//一维数组的初始化

        //二维数组的初始化
        //静态初始化
        int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
        //动态初始化1
        String[][] arr2 = new String[3][4];
        //动态初始化2：
        String[][] arr3 =  new String[3][];
        //错误情况
        //String [][] arr4 = new String[][4];
        //String [4][3] arr5 = new String[][];
        //int [][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};

        //真确写法:将[][]放到变量名后也可以，一维数组也有类似的写法
        int arr4[][] = new int[][]{{1,2,3},{4,5},{6,7,8}};
        int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};

        //2.如何调用数组的指定位置的元素
        System.out.println(arr1[0][1]);//arr1的第一行第二个元素：2
        System.out.println(arr2[1][1]);//arr2数组的第二行第二列元素：null

        arr3[1] = new String[4];//如果要不报错，需要添加这一行代码。并将地址给arr3[1]
        System.out.println(arr3[1][0]);//运行报错：空指针异常，因为只是申请了三个元素的位置，但是每一个位置上没有东西。

        //3.获取数组的长度
        System.out.println(arr4.length);//3,其实就是外层数组的长度。即行数
        System.out.println(arr4[0].length);//arr4[0]还是一个数组，是数组就有length属性。//3，即列数
        System.out.println(arr4[1].length);//2,即{4,5}的元素的个数

        //4.如何遍历二维数组：几维数组遍历就需要几个for循环
        for (int i = 0; i < arr4.length ; i++) {
            for (int j = 0; j < arr4[i].length; j++) {
                System.out.println(arr4[i][j] + " ");
            }
            System.out.println();//换行
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

2.3二维数组的默认初始化

规定：二维数组分为外层数组的元素，内层数组的元素

int[] arr = new int[4][3];
//外层元素：arr[0],arr[1]等
//内层元素：arr[0][0],arr[1][2]等。
1
2
3

针对一初始化方式一：比如int[][] arr = new int[4][3];;

• 外层元素的初始化值为：地址值
• 内层元素的初始化值为：与一维数组初始化情况相同

针对于初始化方式二：比如：int[][] arr = new int[4][];

• 外层元素的初始化值为：null
• 内层元素的初始化值为：不能调用，否则报错，空指针异常。

代码演示说明：

package com.fan.pojo;

public class ArrayTest {
    public static void main(String[] args) {
        int[][] arr = new int[4][3];
        System.out.println(arr[0]);//地址值：[I@5ebec15其中【代表是数组，I代表是int型，@后为位置
        System.out.println(arr[0][0]);//0

        System.out.println(arr);//[[I@6d06d69c
        System.out.println("\n=======================");
        //初始化方式一
        String[][] arr2 = new String[4][2];//4行2列中每个元素先赋值为默认值null
        System.out.println(arr2[1]);//地址值
        System.out.println(arr2[1][1]);//null

        System.out.println("\n========================");
        //初始化方式二
        double [][] arr3 = new double[4][];
        System.out.println(arr3[1]);//null
        //System.out.println(arr3[1][0]);//报空指针异常。因为我们没有给内层数组指定空间。
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

二维数组内存图解：

数组经典练习

1.利用二维数组打印杨辉三角。

package com.fan.pojo;
/*利用二维数组打印杨辉三角*/
public class ArrayTest {
    public static void main(String[] args) {
        int[][] arr = new int[10][];//动态赋值的一种方式
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new int[i+1];//[i+1]内层数组元素的个数是不同的
            for (int j = 0; j < arr[i].length; j++) {
                if(j == 0 || i == j){//给第一列 赋值为1，给行列相等的位置也赋值为1
                    arr[i][j] = 1;
                }else{//其他位置元素符合，当前元素  等于 头顶元素  + 头顶元素的前一个元素的 和
                    arr[i][j] = arr[i-1][j] + arr[i-1][j-1];
                }
            }
        }

        //遍历输出赋值后的二维数组：
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

二分法查找：前提是：数组有序

package com.fan.pojo;
/*二分查找方法*/
public class ArrayTest {
    public static void main(String[] args) {
        //静态初始化,二分查找的前提是，数组必须有序，升序或者降序
        int[] arr = new int[]{1,3,5,7,9,11};
        //定义要查找的数key
        int key = 99;
        //定义开始索引和结束索引
        int start = 0;
        int end = arr.length - 1;

        //设置是否找到的开关、旗帜，flag
        boolean flag = false;
        while (start <= end){
            int middle = (start + end)/2;//在循环中，每次求出的中间索引
            if(key == arr[middle]){//如果目标值等于  数组中间索引所对应的元素，则找到了
                System.out.println("找到了"+key+"，位置是："+middle);
                flag = true;
                break;
            }else if(arr[middle] > key){//假如中间数大于目标值,则在左半边找。右边界索引重置成 middle
                end = middle - 1;//索引等一  middle的前一个索引
            }else{//目标值在右边
                start = middle + 1;//middle的后一个索引
            }
        }

        //循环外判断开关
        if(!flag){
            System.out.println("没找到");
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

数组的排序

3.1 数组越界异常

创建数组，赋值3个元素，数组的索引就是0，1，2，没有3索引，因此我们不能访问数组中不存在的索引，程序运
行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界异常是不能出现的，一
旦出现了，就必须要修改我们编写的代码。

3.2 数组空指针异常

arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候
会抛出 NullPointerException 空指针异常。在开发中，数组的越界异常是不能出现的，一旦出现了，就必须要修
改我们编写的代码。

3.4 数组获取最大值元素（比武招亲）

最大值获取：从数组的所有元素中找出最大值。
实现思路：
定义变量，保存数组0索引上的元素
遍历数组，获取出数组中的每个元素
将遍历到的元素和保存数组0索引上值的变量进行比较
如果数组元素的值大于了变量的值，变量记录住新的值
数组循环遍历结束，变量保存的就是数组中的最大值

public static void main(String[] args) {
	int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
	//定义变量，保存数组中0索引的元素
	int max = arr[0];
	//遍历数组，取出每个元素
	for (int i = 0; i < arr.length; i++) {
	//遍历到的元素和变量max比较
	//如果数组元素大于max
	if (arr[i] > max) {
	//max记录住大值
	max = arr[i];
	}
	}
	System.out.println("数组最大值是： " + max);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

第四章 数组作为方法参数和返回值

数组作为方法参数传递，传递的参数是数组内存的地址。
数组作为方法的返回值，返回的是数组的内存地址

public static void main(String[] args) {
//调用方法，接收数组的返回值
//接收到的是数组的内存地址
int[] arr = getArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
	/*
	创建方法，返回值是数组类型
	return返回数组的地址
	*/
	public static int[] getArray() {
	int[] arr = { 1, 3, 5, 7, 9 };
	//返回数组的地址，返回到调用者
	return arr;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

总结: 方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值.