Java教程

Java数组

本文主要是介绍Java数组,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

Java数组

一、一维数组

1、知识点:

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

 

  1.2、数组实际上是一个容器,可以同时容纳多个元素。(数组是一个数据的集合)

 

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

 

  1.4、数组因为是引用类型,所以数组对象存储在 堆内存 当中。(数组是存储在堆当中的)

 

  1.5、数组当中如果存储的是“java对象”的话,实际上存储的是对象的“引用(内存地址)”,数组中不能直接存储java对象。

 

  1.6、数组一旦创建,在java中规定,长度不可变。(数组长度不可变)

 

  1.7、数组的分类:一维数组、二维数组、三维数组、多维数组…(一维数组较多,二维数组偶尔使用!)

 

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

 

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

      比如:int类型数组只能存储int类型,Person类型数组只能存储Person类型。

 

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

  

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

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

 

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

 

2、怎么声明/定义一个一维数组?

语法格式:

 int[]array1;
 double[]array2;
 boolean[]array3;
 String[]array4;
 Object[]array5;

3、怎么初始化一个一维数组呢?

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

 

静态初始化语法格式:

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。

注意:

采用动态初始化,数组会赋默认值!

 

什么时候采用静态初始化方式,什么时候使用动态初始化方式呢?

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

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

 

4、怎么修改一维数组某一个元素的值?

语法格式:

 数组名[下标] = 值;

eg.

 a[1] = 100;

 

5、方法形参为一维数组如何传参?

 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,它是一个数组对象。

6、数组扩容(效率低)

方法:(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, a.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] 来说,其中 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、数组这种数据结构的优点和缺点是什么?

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

  原因:

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

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

  第三:知道第一个元素内存地址,知道每一个元素占用空间的大小,又知道下标,所以

  通过一个数学表达式就可以计算出某个下标上元素的内存地址。直接通过内存地址定位元素,所以数组的检索效率是最高的。

注意:

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

  因为数组中元素查找的时候不会一个一个找,是通过数学表达式计算出来的。(算出一个内存地址,直接定位的。)

 

缺点:

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

  第二:数组不能存储大数据量。

  因为很难在内存空间上找到一块特别大的连续的内存空间。

  注意:

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

 

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()方法的使用

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

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

 

7、数组长度为0不等于null:

 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);//空指针异常

 

这篇关于Java数组的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!