Java基础之数组超详细知识总结

Java基础之数组超详细知识总结

一、一维数组

1、java语言中的数组是一种 引用数据类型。不属于基本数据类型。数组的父类是 Object。

2、数组实际上是一个容器，可以同时容纳多个元素。（数组是一个数据的集合）

3、数组当中可以存储“基本数据类型”的数据，也可以存储“引用数据类型”的数据。

4、数组因为是引用类型，所以数组对象存储在 堆内存 当中。（数组是存储在堆当中的）

5、数组当中如果存储的是“java对象”的话，实际上存储的是对象的“引用（内存地址）”，数组中不能直接存储java对象。

6、数组一旦创建，在java中规定，长度不可变。（数组长度不可变）

7、数组的分类：一维数组、二维数组、三维数组、多维数组…（一维数组较多，二维数组偶尔使用！）

8、所有的数组对象都有 length 属性(java自带的)，用来获取数组中元素的个数。

9、java中的数组要求数组中元素的 类型统一。

比如：int类型数组只能存储int类型，Person类型数组只能存储Person类型。

10、数组在内存方面存储的时候，数组中的元素内存地址(存储的每一个元素都是有规则的挨着排列的)是连续的。内存地址连续。（数组特点）

11、所有的数组都是拿“第一个小方框的内存地址”作为整个数组对象的内存地址。

（数组中首元素的内存地址作为整个数组对象的内存地址。）

12、数组中每一个元素都是有下标的，下标从0开始，以1递增。最后一个元素的下标是：length - 1

13、数组这种数据结构的优点和缺点是什么？

优点：查询/查找/检索某个下标上的元素时效率极高。

原因：

第一：每一个元素的内存地址在空间存储上是连续的。

第二：每一个元素类型相同，所以占用空间大小一样。

第三：知道

第一个元素内存地址，知道每一个元素占用空间的大小，又知道下标，所以通过一个数学表达式就可以计算出某个下标上元素的内存地址。直接通过内存地址定位元素，所以数组的检索效率是最高的。

注意：

数组中存储100个元素，或者存储100万个元素，在元素查询/检索方面，效率是相同的，

因为数组中元素查找的时候不会一个一个找，是通过数学表达式计算出来的。（算出一个

内存地址，直接定位的。）

缺点：

第一：由于为了保证数组中每个元素的内存地址连续，所以在数组上随机删除或者增加元素的时候，效率较低，因为随机增删元素会涉及到后面元素统一向前或者向后位移的操作。

第二：数组不能存储大数据量。因为很难在内存空间上找到一块特别大的连续的内存空间。

注意：

对于数组中最后一个元素的增删，是没有效率影响的。

14、怎么声明/定义一个一维PBLyPdezby数组？

语法格式：

int[] array1;

double[] array2;

boolean[] array3;

String[] array4;

Object[] array5;

15、怎么初始化一个一维数组呢？

包括两种方式：静态初始 化一维数组，动态初始化 一维数组。

静态初始化语法格式：

java风格：

int[] array = {100, 2100, 300, 55};

C++风格：

int array[] = {100, 2100, 300, 55};

动态初始化语法格式：

Java风格：

int[] array = new int[5]; // 这里的5表示数组的元素个数。

// 初始化一个5个长度的int类型数组，每个元素默认值0

String[] names = new String[6]; // 初始化6个长度的String类型数组，每个元素默认值null。

C++风格：

int array[] = new int[5]; // 这里的5表示数组的元素个数。

// 初始化一个5个长度的int类型数组，每个元素默认值0

String names[] = new String[6]; // 初始化6个长度的String类型数组，每个元素默认值null。

注意：

采用动态初始化，数组会赋默认值！

注意：

和c++的区别

c++定义数组

//静态初始化

int a[10];

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

int a[100] = {1, 2, 3, 4};

//动态初始化

int *a = new int[10];

16、怎么修改一维数组某一个元素的值？

语法格式：

数组名[下标] = 值;

eg.

a[1] = 100;

17、 什么时候采用静态初始化方式，什么时候使用动态初始化方式呢？

当你创建数组的时候，确定数组中存储哪些具体的元素时，采用静态初始化方式。

当你创建数组的时候，不确定将来数组中存储哪些数据，你可以采用动态初始化的方式，预先分配内存空间。

18、方法形参为一维数组如何传参？

public void print(int[] num){

for (int i = 0; i < num.length; i++){

System.out.println(num[i]);

}

}

传参：

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

print(a);

还可以这样传参：

传静态数组

print(new int[]{1, 2, 3, 4});

new int[]{1, 2, 3, 4}还可以.length是一个数组对象！

19、数组扩容（效率低）

方法：（System类的方法）

/**

*@src 拷贝源

*@srcPos 拷贝源起始位置

*@dest 目标数组

*@destPos 目标数组起始位置

*@length 拷贝长度

*/

static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

eg.

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

int[] b = new int [10];

System.arraycopy(a, 0, b, 0, aa.length);

//从a数组下标为0开始拷贝，拷贝到从b数组下标为0开始存入，长度为整个a数组

二、二维数组

1、二维数组其实是一个 特殊的一维数组，特殊在这个一维数组当中的每一个元素是一个一维数组。

2、三维数组是什么？

三维数组是一个特殊的二维数组，特殊在这个二维数组 中每一个元素是一个一维数组。

实际的开发中使用最多的就是一维数组。二维数组也很少使用。三维数组几乎不用。

3、二维数组静态初始化

int[][] array = {

{1,1,1},

{2,3,4,5},

{0,0,0,0},

{2,3,4,5},

{2,3,4,5},

{2,3,4,5},

{2,3,4,5}

};

4、二维数组动态初始化

eg.

int[][] array = new int[3][4];

5、关于二维数组中元素的：读和改。

a[二维数组中的一维数组的下标][一维数组的下标]

a[0][0]：表示第1个一维数组中的第1个元素。

a[3][100]：表示第4个一维数组中的第101个元素。

注意：

对于a[3][100]来说，其中 a[3] 是一个整体。[100]是前面a[3]执行结束的结果然后再下标100。

6、方法形参为二维数组如何传参？

public void print(int[][] num){

for (int i = 0; i < num.length; i++){

for (int j = 0; j < num[i].length; j++){

System.out.println(num[i][j]);

}

}

}

传参：

int[][] a = {{1,2,3,4},{4,5,6,76},{1,23,4}};

print(a);

还可以这样传参：

传静态数组

print(new int[][]{{1,2,3,4},{4,5,6,76},{1,23,4}});

new int[][]{{1,2,3,4},{4,5,6,76},{1,23,4}}还可以.length是一个数组对象！

三、总结

1. 数组的优点和缺点，并且要理解为什么。

第一：空间存储上，内存地址是连续的。

第二：每个元素占用的空间大小相同。

第三：知道首元素的内存地址。

第四：通过下标可以计算出偏移量。

通过一个数学表达式，就可以快速计算出某个下标位置上元素的内存地址，

直接通过内存地址定位，效率非常高。

优点：检索效率高。

缺点：随机增删效率较低，数组无法存储大数据量。

注意：数组最后一个元素的增删效率不受影响。

2. 一维数组的静态初始化和动态初始化

静态初始化：

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

Object[] objs = {new Object(), new Object(), new Object()};

动态初始化：

int[] arr = new int[4]; // 4个长度，每个元素默认值0

Object[] objs = new Object[4]; // 4个长度，每个元素默认值null

3. 一维数组的遍历

for(int i = 0; i < arr.length; i++){

System.out.println(arr[i]);

}

4. 二维数组的静态初始化和动态初始化

静态初始化：

int[][] arr = {

{1,2,34},

{54,4,34,3},

{2,34,4,5}

};

Object[][] arr = {

{new Object(),new Object()},

{new Object(),new Object()},

{new Object(),new Object(),new Object()}

};

动态初始化：

int[][] arr = new int[3][4];

Object[][] arr = new Object[4][4];

Animal[][] arr = new Animal[3][4];

// Person类型数组，里面可以存储Person类型对象，以及Person类型的子类型都可以。

Person[][] arr = new Person[2][2];

....

5. 二维数组的遍历

for(int i = 0; i < arr.length; i++){ // 外层for循环负责遍历外面的一维数组。

// 里面这个for循环负责遍历二维数组里面的一维数组。

for(int j = 0; j < arr[i].length; j++){

System.out.print(arr[i][j]);

}

// 换行。

System.out.println();

}

6. 数组的拷贝：System.arraycopy()方法的使用

数组有一个特点：长度一旦确定，不可变。

所以数组长度不够的时候，需要扩容，扩容的机制是：新建一个大数组，将小数组中的数据拷贝到大数组，然后小数组对象被垃圾回收。

补充：

数组长度为0：

int[] f = {};//数组长度为0

System.out.println(f.length);//0

int[] g = new int[0];//数组长度为0

System.out.println(g.length);//0

int[] h = null;

//System.out.println(h.length);//空指针异常

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。