首页 > 代码库 > Java编程基础-数组

Java编程基础-数组

2024-09-05 02:46:53   221人阅读

一、数组的定义。

1、数组的含义：数组是一组具有相同数据类型的元素的有序集合。数组可以分为一维数组和多维数组。(数组是一个引用类型的容器，从0开始编号存储相同数据类型的数据。)

2、数组的定义语法格式：

(1)、格式一：数据类型  [ ] 数组名=new 数据类型[元素的个数或数组的长度];

例如:int[ ] arr=new int[3];//定义了一个整型数组，数组中有3个元素（数组长度为3）

附：数组名放在[ ] 前面也是可以的,即int arr[ ] =new int[3];//但一般不建议这么定义。

(2)、格式二：数据类型  [ ] 数组名=new 数据类型[ ]{元素1,元素2,元素3,......};

例如:int[ ] arr=new int[ ]{1,2,3,4,5};//直接给数组进行赋值，需要注意的是new int[ ] 的括号中不能够指定数组中存放元素的个数，因为我们不清楚后面定义的数组个数。如果写了元素个数，JVM虚拟机在运行的时候会报错。

(3)、格式三:数据类型  [ ] 数组名={元素1,元素2,元素3,......};

例如：int[ ] arr= {1,2,3,4,5};//属于直接赋值的方式

格式二和格式三也称静态初始化，就是在定义数组的同时就为数组的每个元素赋值。

注意：

a)arr(即数组名)是引用数据类型中的数组类型，arr存的是地址值。该变量必须指向一个有效的数组对象，如果该变量的值为null，arr不再指向堆内存中的数组，此时通过该变量访问数组中的元素会出现空指针异常(NullPointerException)。堆内存中数组被虚拟机视为垃圾，(虚拟机会启动垃圾回收机制)不定时间内最终被清除。

b)数组中元素最小的索引(下标、角标)是0，最大的索引是数组的长度-1.访问元素时超出了数组的索引范围会出现数组角标越界异常（ArrayIndexOutOfBoundsException）。在Java中，为了方便获得数组的长度，提供了一个length属性，在程序中可以通过“数组名.length”的方式来获得数组的长度，即元素的个数。

c)不同数据类型数组的元素都有默认初始化值，其中byte、short、int、long的默认初始化值为0,float和double类型的默认初始化值为0.0,char类型的默认初始化值为一个空字符，即"\u0000",boolean类型的默认初始化值为false,引用类型的默认初始化值为null，表示变量不引用任何对象。

代码示例演示：

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         int[] arr = new int[3];// 声明一个数组arr,并开辟内存空间  
  5.         System.out.println("数组的长度为：" + arr.length);  
  6.         // 数组元素的访问通过数组名[下标]的方式访问  
  7.         System.out.println("数组的第一个元素为：" + arr[0]);//由于未初始化，所以访问的元素为默认值  
  8.         System.out.println("数组的第二个元素为：" + arr[1]);  
  9.         System.out.println("数组的第三个元素为：" + arr[2]);  
  10.   
  11.         System.out.println(arr[3]);  
  12.         // 由于数组arr的最大下标为length-1,即最大下标为2,所以访问下标为3的元素会报数组角标越界异常  
  13.         //arr = null;  
  14.         //System.out.println(arr[0]);  
  15.         // 由于数组的引用为null,不再指向内存中的数组地址值,此时再访问数组中的0角标元素会报空指针异常  
  16.   
  17.     }  
  18.   
  19. }  

输出结果为：

数组的长度为：3
数组的第一个元素为：0
数组的第二个元素为：0
数组的第三个元素为：0
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
at Demo.main(Demo.java:11)

//Exception in thread "main" java.lang.NullPointerException
at Demo.main(Demo.java:14)

二、数组的常见操作。

1、数组的遍历

在操作数组时，经常需要依次访问数组中的每一个元素，这种操作称作数组的遍历。由于数组中元素类型的相同，而且元素是有序的，从0开始到最大下标，所以常用循环的方式遍历数组。

代码示例演示：

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         int[] arr = { 5, 12, 21, 9, 7 };// 声明并初始化一个长度为5的int类型数组  
  5.         for (int i = 0; i < arr.length; i++) {// 循环遍历数组中的每一个元素  
  6.             System.out.println("arr[" + i + "]=" + arr[i]);// 打印输出元素值  
  7.         }  
  8.         // 使用增强for循环的方式遍历输出数组中的元素  
  9.         for (int a : arr) {  
  10.             System.out.print(a+" ");  
  11.         }  
  12.   
  13.     }  
  14.   
  15. }  

输出的结果为：

arr[0]=5
arr[1]=12
arr[2]=21
arr[3]=9
arr[4]=7
5 12 21 9 7 
2、数组的最值

在操作数组时，经常需要获取数组中元素的最值。

代码示例演示：

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.   
  5.         int[] arr = { 5, 1, 2, 8, 7, 21, 12 };// 定义一个数组  
  6.         int max = getMax(arr);// 调用获取元素最大值的方法  
  7.         System.out.println("max=" + max);// 打印最大值  
  8.         System.out.println("最大值为：" + getMax_2(arr));  
  9.   
  10.         int min = getMin(arr);// 调用获取元素最小值的方法  
  11.         System.out.println("min=" + min);// 打印最小值  
  12.         System.out.println("最小值为：" + getMin_2(arr));  
  13.   
  14.     }  
  15.   
  16.     public static int getMax(int[] arr)// 定义了一个求最大值的方法  
  17.     {  
  18.         int max = arr[0];// 定义变量max用于记住最大数，先假设第一个元素为最大值  
  19.         // 需要注意的是：在for循环中的变量i是从1开始的，这样写的原因是程序已经假设第一个元素为最大值,  
  20.         // for循环中只需要从第二个元素开始比较，从而提高程序的运行效率。  
  21.         for (int x = 1; x < arr.length; x++)// 通过for循环遍历数组中的元素  
  22.         {  
  23.             if (arr[x] > max)// 比较arr[x]的值是否大于max  
  24.             {  
  25.                 max = arr[x]; // 条件成立，将arr[x]的值赋给max  
  26.             }  
  27.         }  
  28.         return max;// 返回最大值  
  29.     }  
  30.   
  31.     public static int getMax_2(int[] arr) {// 获取最大值的第二种方法，初始化为数组中元素任意一个角标。  
  32.         int max = 0;  
  33.         for (int x = 1; x < arr.length; x++) {  
  34.             if (arr[x] > arr[max]) {  
  35.                 max = x;  
  36.             }  
  37.         }  
  38.         return arr[max];  
  39.   
  40.     }  
  41.   
  42.     public static int getMin(int[] arr)// 定义了一个求最小值的方法  
  43.     {  
  44.         int min = arr[0];// 定义变量min用于记住最小数，先假设第一个元素为最小值  
  45.         for (int x = 1; x < arr.length; x++)// 通过for循环遍历数组中的元素  
  46.         {  
  47.             if (arr[x] < min)// 比较arr[x]的值是否小于min  
  48.             {  
  49.                 min = arr[x]; // 条件成立，将arr[x]的值赋给min  
  50.             }  
  51.         }  
  52.         return min;// 返回最小值  
  53.     }  
  54.   
  55.     public static int getMin_2(int[] arr) {// 获取最小值的第二种方法  
  56.         int min = 0;  
  57.         for (int x = 1; x < arr.length; x++) {  
  58.             if (arr[x] < arr[min]) {  
  59.                 min = x;  
  60.             }  
  61.         }  
  62.         return arr[min];  
  63.     }  
  64. }  

输出结果为：

max=21
最大值为：21
min=1
最小值为：1
3、数组的排序

在操作数组时，经常需要对数组中的元素进行排序，数组排序的方法有很多种，比如选择排序，冒泡排序，插入排序，希尔排序等。(这里就只简答介绍选择和冒泡排序。)

(1)、选择排序

每一次从待排序的数据元素中选取最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

代码实现：

 

[java] view plain copy
  1. public static void selectSort(int[] arr)// 定义选择排序方法  
  2.     {  
  3.         for (int x = 0; x < arr.length - 1; x++) {  
  4.             for (int y = x + 1; y < arr.length; y++) {  
  5.                 if (arr[x] > arr[y]) // 满足条件，进行位置置换  
  6.                 {  
  7.                     int temp = arr[x];  
  8.                     arr[x] = arr[y];  
  9.                     arr[y] = temp;  
  10.                 }  
  11.             }  
  12.         }  
  13.     }  

(2)、冒泡排序

遍历要排序的数列，依次比较相邻两个元素，如果符合条件，把顺序错误的交换过来，让较大的数往下沉，较小的数往上冒。重复进行直到没有要交换的。

代码实现：

 

[java] view plain copy
  1. public static void bubbleSort(int[] arr)// 定义冒泡排序方法  
  2.     {  
  3.         for (int x = 0; x < arr.length - 1; x++) {  
  4.             for (int y = 0; y < arr.length - x - 1; y++) // -x:让每一次比较元素减少。-1：避免角标越界。  
  5.             {  
  6.                 if (arr[y] > arr[y + 1])// 满足条件，进行位置置换  
  7.                 {  
  8.                     int temp = arr[y];  
  9.                     arr[y] = arr[y + 1];  
  10.                     arr[y + 1] = temp;  
  11.                 }  
  12.             }  
  13.         }  
  14.     }  

4、数组元素的查找(折半查找)

折半查找也称二分查找，假设表中元素按升序排列，将表中位置的元素与查找的值比较，如果二者相等，则查找成功。否则从中间将表分成前后两个部分，如果中间位置记录的元素大于查找的元素，则查前部分，否则查后部分，重复直到找到或表已查完。

优点是比较次数少，查找速度快，平均性能好；

缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.   
  5.         int[] arr = { 1, 2, 5, 7, 9, 12, 21, };  
  6.         // 调用折半查找方法查找元素5的位置  
  7.         System.out.println("index=" + halfSearch(arr, 5));  
  8.         System.out.println("index=" + halfSearch(arr, 6));//测试返回-1的情况  
  9.     }  
  10.   
  11.     public static int halfSearch(int[] arr, int key)//arr是已排好的升序数组，返回找到值的下标，返回-1表示没找到。  
  12.     {  
  13.         int min, max, mid;  
  14.         min = 0; // 最小下标  
  15.         max = arr.length - 1; // 最大下标  
  16.         mid = (max + min) / 2; // 中间下标  
  17.   
  18.         while (arr[mid] != key) {  
  19.             if (key > arr[mid])  
  20.                 min = mid + 1;  
  21.             else if (key < arr[mid])  
  22.                 max = mid - 1;  
  23.             if (min > max) // 如果最小的下标大于最大的下标就说明没有折半可能。  
  24.                 return -1;  
  25.             mid = (max + min) / 2;  
  26.         }  
  27.         return mid;  
  28.     }  
  29.   
  30. }  

5、数组工具类(Arrays)

在java.util包中有一个Arrays工具类，该工具类包含操作数组的各种方法，如查找、排序、搜索等。

如使用Arrays实现数组排序：Arrays.sort(arr);该方法有函数重载，可以提供short、long等其他数据类型的排序。

实际中建议使用该方法，因为简单不容易错，但面试切勿这样写。


三、多维数组。

1、多维数组的含义：多维数组可以简单的理解为在数组中嵌套数组，即数组中的元素还是数组。在程序中比较常见的是二维数组。

2、二维数组的语法定义格式：

(1)、格式一：数据类型[ ][ ] 数组名=new [ 二维数组长度][一维数组长度 ];

(2)、格式二：数据类型[ ][ ] 数组名=new [ 二维数组长度][ ];

(3)、格式三：数据类型[ ][ ] 数组名=new [ ][ ]{{元素1,元素2,..},{元素1,元素2,..},{元素1,元素2,..}......};

或者 数据类型[ ][ ] 数组名={{元素1,元素2,..},{元素1,元素2,..},{元素1,元素2,..}......};

定义格式提醒：数组名可以放在数据类型后面，两个中括号之间以及两个中括号之后。

代码示范上述：

 

[java] view plain copy
  1. public class Demo {  
  2.   
  3.     public static void main(String[] args) {  
  4.         // 定义了长度为5的二维数组，每个二维数组中的元素又是一个长度为2的一维数组。  
  5.         int[][] arr1 = new int[5][2];  
  6.         // 定义了长度为3的二维数组，但数组中的每个元素的长度不确定。  
  7.         int[][] arr2 = new int[3][];  
  8.         // 二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2,3},{5,8},{7,3,5}。  
  9.         // 对二维数组元素的访问也是通过角标的方式，如要访问二维数组中第一个元素数组的第二个元素。  
  10.         // 代码为:arr3[0][1];  
  11.         int[][] arr3 = new int[][] { { 1, 2, 3 }, { 5, 8 }, { 7, 3, 5 } };  
  12.   
  13.         // 数组名放在这三个位置都可以  
  14.         int a[][] = new int[1][2];  
  15.         int[] b[] = new int[1][2];  
  16.         int[][] c = new int[1][2];  
  17.     }  
  18.   
  19. }  

3、二维数组的遍历

二维数组的遍历同一维数组一样采用循环遍历，不同的是由于数组中还是数组，需要用到循环嵌套。

代码实现：

 

[java] view plain copy
    1. public class Demo {  
    2.   
    3.     public static void main(String[] args) {  
    4.   
    5.         int[][] arr = { { 1, 2, 3 }, { 5, 8 }, { 7, 3, 5 } };  
    6.         for (int i = 0; i < arr.length; i++) {  
    7.             for (int j = 0; j < arr[i].length; j++) {  
    8.                 System.out.print(arr[i][j]);// 打印元素  
    9.             }  
    10.             System.out.println();// 换行  
    11.         }  
    12.     }  
    13. } 

Java编程基础-数组


联系
我们