【JAVA数组最详细讲解（完整版）】

小咪咪 2023-01-10 10:27 291阅读 0赞

数组

  • 1 数组概述
  • 2 一维数组的创建与使用
    • 2.1 创建一维数组
    • 2.2 初始化一维数组
    • 2.3 使用一维数组
  • 3 二维数组的创建与使用
    • 3.1 创建二维数组
    • 3.2 初始化二维数组
    • 3.3 使用二维数组
  • 4 数组的基本操作
    • 4.1 遍历数组
    • 4.2 填充替换数组元素
    • 4.3 对数组进行排序
    • 4.4 复制数组
    • 4.5 数组查询
  • 5 数组排序算法
    • 5.1 冒泡排序
      • 5.1.1 基本思想
      • 5.1.2 算法实现
    • 5.2 直接选择排序
      • 5.2.1 基本思想
      • 5.2.2 算法实现
    • 5.3 反转排序
      • 5.3.1 基本思想
      • 5.3.2 算法实现

1 数组概述

数组是具有相同数据类型的一-组数据的集合。例如，球类的集合一-足球、 篮球、羽毛球等;电器集合一电视机、 洗衣机、电风扇等。在程序设计中，可以将这些集合称为数组。数组中的每个元素具有相同的数据类型。在Java中同样将数组看作是一个对象，虽然基本数据类型不是对象，但是由基本数据类型组成的数组则是对象。在程序设计中引入数组可以更有效地管理和处理数据。可根据数组的维数将数组分为一维数组、二维数组…

2 一维数组的创建与使用

2.1 创建一维数组

数组作为对象允许使用new关键字进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型，一维数组的创建有两种方式。

1. 先声明，再用new运算符进行内存分配

  1. 数组元素类型 名字[];
  2. 数组元素类型[] 名字;
  3. //具体声明如下：
  4. int arr[];
  5. String str[];

声明数组后还不能立即访问它的任何元素，因为声明数组只是给出了数组名字和元素的数据类型，要想使用数组，还要为它分配内存空间，必须指明数组的长度，格式如下：

  1. 数组名字 = new 数组元素的类型[数组元素的个数];
  2. //实例代码如下：
  3. arr = new int[5];

注意：使用new关键字为数组分配内存时，整型数组中各个元素的初始值都为0

2. 声明的同时为数组分配内存 ：(java)中普遍使用的方法
语法如下：

  1. 数组元素的类型 数组名 = new 数组元素的类型[数组元素个数]
  2. //实例代码如下：
  3. int month[] = new int[12];

2.2 初始化一维数组

在这里插入图片描述

2.3 使用一维数组

例2.3 创建类GetDay,在主方法中创建int型数组，并实现将各月的天数输出：

  1. public class GetDay                         //创建类
  2. {
  4.     public static void main(String[] args)  //创建主方法
  5.     {
  7.         int[] day = new int[]{
  8.     31,28,31,30,31,30,31,31,30,31,30,31};
  9.         for(int i=0;i<12;i++)
  10.             System.out.println((i+1)+"月有"+day[i]+"天");
  11.     }
  12. }
  14. //输出示例
  15. /*
  16. 1月有31天
  17. 2月有28天
  18. 3月有31天
  19. 4月有30天
  20. 5月有31天
  21. 6月有30天
  22. 7月有31天
  23. 8月有31天
  24. 9月有30天
  25. 10月有31天
  26. 11月有30天
  27. 12月有31天
  28. Process finished with exit code 0
  29. */

3 二维数组的创建与使用

如果一维数组中的各个元素仍然是一个数组，那么它就是一个二维数组。

3.1 创建二维数组

1. 先声明，再用new运算符进行内存分配

  1. 数组元素类型 名字[][];
  2. 数组元素类型[][] 名字;
  3. //具体声明如下：
  4. int myarr[][];

同一维数组一样，二维数组在声明时也没有分配内存空间，同样要使用new关键字来分配内存，然后才可以进行访问每个元素，对于高维数组，有两种为数组分配内存的方式：

  1. //（1）直接为每一维分配内存空间，实例如下：
  2. a = new int[2][4];
  4. //(2)分别为每一维分配内存空间
  5. a = new int[2][];
  6. a[0] = new int[2];
  7. a[1] = new int[3];

2. 声明的同时为数组分配内存

3.2 初始化二维数组

  1. type arrayname[][] = {
  2.     value1,value2...valuen};
  3. //type:数组数据类型
  4. //arrayneme:数组名称，一个合法的标识符
  5. //value:数组中各元素的值
  6. //初始化实例如下：
  7. int myarr[][] = {
  8.     {
  9.     12,0},{
  10.     45,10}};

3.3 使用二维数组

例3.3 创建类Matrix,在主方法中编写代码实现输出一个3行4列且所有元素都为0的矩阵：

  1. public class Matrix                         //创建类
  2. {
  4.     public static void main(String[] args)  //创建主方法
  5.     {
  7.         int[][] a = new int[3][4];
  8.         for(int i=0;i<a.length;i++)
  9.         {
  11.             for(int j=0;j<a[i].length;j++)
  12.                 System.out.print(a[i][j]);
  13.             System.out.println();
  14.         }
  15.     }
  16. }
  17. //输出示例
  18. /*
  19. 0000
  20. 0000
  21. 0000
  22. Process finished with exit code 0
  23. */

4 数组的基本操作

4.1 遍历数组

遍历二维数组需要使用双层for循环，通过数组的length属性可获得数组的长度
例4.1.1 创建类Trap，在主方法中编写代码，定义二维数组，将二维数组中的元素呈梯形输出：

  1. public class Trap {
  3.     public static void main(String[] args) {
  5.         int[][] a = new int[][]{
  6.     {
  7.     1}, {
  8.     2, 3}, {
  9.     4, 5, 6}};//定义二维数组
  10.         for (int i = 0; i < a.length; i++) {
  11.     //循环遍历二维数组中的每个元素
  12.             for (int j = 0; j < a[i].length; j++) {
  14.                 System.out.print(a[i][j]);//将数组中的元素输出
  15.             }
  16.             System.out.println();//输出空格
  17.         }
  18.     }
  19. }
  21. //输出示例：
  22. /*
  23. 1
  24. 23
  25. 456
  26. Process finished with exit code 0
  27. */

在遍历数组时，使用foreach语句可能会更加简单，下面的实例就是通过foreach语句遍历二维数组。
例4.1.2 创建类Tautog,在主方法中定义二维数组，使用foreach语句遍历二维数组：

  1. public class Tautog {
  3.     public static void main(String[] args) {
  5.         int[][] arr2 = new int[][]{
  6.     {
  7.     4, 3}, {
  8.     1, 2}};  //定义二维数组
  9.         System.out.println("数组中的元素是：");
  10.         int i = 0;//外层循环计数器变量
  11.         for (int[] x :
  12.                 arr2) {
  13.         //外层循环变量为一维数组
  14.             i++;    //外层计数器递增
  15.             int j = 0;    //内层循环计数器
  16.             for (int e :
  17.                     x) {
  18.        //  循环遍历每一个数组元素
  19.                 j++;    //  内层循环计数器递增
  20.                 if (i == arr2.length && j == x.length) {
  21.         //  判断变量是二维数组中的最后一个元素
  22.                     System.out.print(e);    //输出二维数组最后一个元素
  23.                 } else {
  25.                     //如果不是二维数组中的最后一个元素
  26.                     System.out.print(e + "、");    //  输出信息
  27.                 }
  28.             }
  29.         }
  30.     }
  31. }
  33. //输出示例：
  34. /*
  35. 数组中的元素是：
  36. 4、3、1、2
  37. Process finished with exit code 0
  38. */

4.2 填充替换数组元素

数组中的元素定义完成后，可通过Arrays类的静态方法il()来对数组中的元素进行替换。该方法通过各种重载形式可完成任意类型的数组元素的替换。fll()方法有两种参数类型。下面以int型数组为例介绍ill()方法的使用方法。

  1. （1）fill(int[] a,int value)
  2. //该方法可将指定的int值分配给int型数组的每个元素，语法如下：
  3. fill(int[] a,int value);
  4. //a:要进行元素替换的数组
  5. //value:要存储数组中所有元素的值

例4.2.1 创建类Swap，在主方法中创建一维数组，并实现通过fill()方法填充数组元素，最后将数组中各个元素输出。

  1. import java.util.Arrays;    //  导入java.util.Arrays类
  3. public class Swap {
  5.     public static void main(String[] args) {
  7.         int[] arr = new int[5];  //  创建int型数组
  8.         Arrays.fill(arr, 8); //  使用同一个值对数组进行填充
  9.         for (int i = 0; i < arr.length; i++) {
  10.      //  循环遍历数组中的元素
  11.             System.out.println("第" + i + "个元素是" + arr[i]);
  12.         }
  13.     }
  14. }
  16. //输出示例：
  17. /*
  18. 第0个元素是8
  19. 第1个元素是8
  20. 第2个元素是8
  21. 第3个元素是8
  22. 第4个元素是8
  23. Process finished with exit code 0
  24. */
  26. (2)fill(int[] a,int fromIndex,int toIndex,int value)
  27. //该方法将指定的int值分配给int型数组指定范围中的每个元素。填充的范围从索引fromIndex（包括）到索引toIndex（不包括），如果fromIndex==toIndex,则填充范围为空，语法如下：
  29. fill(int[] a,int fromIndex,int toIndex,int value);
  30. //a:要进行填充的数组
  31. //fromIndex:要使用指定值填充的第一个元素的索引（包括）
  32. //toIndex:要使用指定值填充的最后一个元素的索引（不包括）
  33. //value:要存储在数组所有元素的值

注意：如果指定的索引位置大于或者等于要进行填充的数组长度，则会报出ArrayIndexOutOf-BoundsException(数组越界异常) 异常。

例4.2.2 创建类Displace,创建一维数组，并通过fill()方法替换数组元素，最后将数组中的各个元素输出。

  1. import java.util.Arrays;    //  导入java.util.Arrays类
  3. public class Displace {
  5.     public static void main(String[] args) {
  7.         int[] arr = new int[]{
  8.     45,12,2,10};  //  创建int型数组
  9.         Arrays.fill(arr,1,2,8); //  使用同一个值对数组进行填充
  10.         for (int i = 0; i < arr.length; i++) {
  11.      //  循环遍历数组中的元素
  12.             System.out.println("第" + i + "个元素是" + arr[i]);
  13.         }
  14.     }
  15. }
  17. //输出示例：
  18. /*
  19. 第0个元素是45
  20. 第1个元素是8
  21. 第2个元素是2
  22. 第3个元素是10
  23. Process finished with exit code 0
  24. */

4.3 对数组进行排序

通过Arrays类的静态sort()方法可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。语法如下：

  1. Arrays.sort(object)
  2. //object:指进行排序的数组名称

例4.3 创建类Taxis，在主方法中创建一维数组，将数组排序后输出。

  1. import java.util.Arrays;    //  导入java.util.Arrays类
  3. public class Taxis {
  5.     public static void main(String[] args) {
  7.         int[] arr = new int[]{
  8.     23,42,12,8};  //  创建int型数组
  9.         Arrays.sort(arr); //  将数组进行排序
  10.         for (int i = 0; i < arr.length; i++) {
  11.      //  循环遍历数组中的元素
  12.             System.out.println(arr[i]);
  13.         }
  14.     }
  15. }
  17. //输出示例：
  18. /*
  19. 8
  20. 12
  21. 23
  22. 42
  23. Process finished with exit code 0
  24. */

4.4 复制数组

Arrarys类的copyOf()方法与copyOfRange()方法可实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。

  1. （1）copyOf()方法，语法如下：
  2. copyOf(arr,int newlength);
  3. //arr:要进行复制的数组
  4. //newlenghth:int型常量，指复制后的新数组长度。如果新数组长度大于数组arr的长度，则用0填充（整型0填充，char型null填充），如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取到满足新数组长度为止

例4.4.1 创建类Cope,在主方法中创建一维数组，实现将此数组复制得到一个长度为5的新数组，并将新数组输出：

  1. import java.util.Arrays;    //  导入java.util.Arrays类
  3. public class Cope {
  5.     public static void main(String[] args) {
  7.         int[] arr = new int[]{
  8.     23, 42, 12};  //  创建int型数组
  9.         int[] newarr = Arrays.copyOf(arr, 5); //  复制数组arr
  10.         for (int i = 0; i < newarr.length; i++) {
  11.      //  循环遍历数组中的元素
  12.             System.out.println(newarr[i]);
  13.         }
  14.     }
  15. }
  17. //输出示例：
  18. /*
  19. 23
  20. 42
  21. 12
  22. 0
  23. 0
  24. Process finished with exit code 0
  25. */
  27. （2）copyOfRange()方法，语法如下：
  28. copyOfRange(arr,int fromIndex,int toIndex);
  29. //arr:要进行复制的数组对象
  30. //fromIndex:指定开始复制数组的索引位置，必须在0-整个数组长度之间，新数组包括fromIndex元素
  31. //toIndex:要复制范围的最后索引位置，可以大于数组arr长度，新数组不包括toIndex元素

例4.4.2 创建类Repeat,在主方法中创建一维数组，并将数组中索引位置是0-3的元素复制到新数组中，最后将新数组输出：

  1. import java.util.Arrays;    //  导入java.util.Arrays类
  3. public class Repeat {
  5.     public static void main(String[] args) {
  7.         int[] arr = new int[]{
  8.     23, 42, 12, 84, 10};  //  创建int型数组
  9.         int[] newarr = Arrays.copyOfRange(arr, 0, 3); //  复制数组arr
  10.         for (int i = 0; i < newarr.length; i++) {
  11.      //  循环遍历数组中的元素
  12.             System.out.println(newarr[i]);
  13.         }
  14.     }
  15. }
  17. //输出示例：
  18. /*
  19. 23
  20. 42
  21. 12
  22. Process finished with exit code 0
  23. */

4.5 数组查询

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供 了多种重载形式，用于满足各种类型数组的查找需要。binarySearch()方法有两种参数类型。

  1. (1) binarySearch(Object[] a, Object key)
  2. //a:要搜索的数组
  3. //key:要搜索的值

例5.1.1 创建Reference类，在主方法中创建一维数组arr,实现查找元素4在数组中的索引：

  1. import java.util.Arrays;    //  导入java.util.Arrays类
  3. public class Reference {
  5.     public static void main(String[] args) {
  7.         int[] arr = new int[]{
  8.     1, 8, 9, 4, 5};  //  创建int型数组
  9.         Arrays.sort(arr);//对数组进行排序
  10.         int index=Arrays.binarySearch(arr,4);
  11.         System.out.println("4的索引位置是："+index);
  12.     }
  13. }
  15. //输出示例：
  16. /*cd
  17. 4的索引位置是：1
  18. Process finished with exit code 0
  19. */
  21. （2）binarySearch(Object[] a,int fromlndex , int tolndex,Object key)
  22. //该方法在指定的范围内检索某一元素
  23. //a:要进行检索的数组
  24. //fromIndex:指定范围的开始索引处（包含）
  25. //toIndex:指定范围处的索引（不包含）
  26. //key:要搜索的元素

例5.1.2 创建Rakel类，在主方法创建String数组，实现查找元素“cd”在指定范围的数组str中的索引位置：

  1. import java.util.Arrays;    //  导入java.util.Arrays类
  3. public class Rakel {
  5.     public static void main(String[] args) {
  7.         String[] str = new String[]{
  8.     "ab","cd","ef","yz"};//定义String型数组
  9.         Arrays.sort(str);   //  将数组进行排序
  10.         int index = Arrays.binarySearch(str,0,2,"cd");
  11.         System.out.println("cd的索引位置是："+index);
  12.     }
  13. }
  16. //输出示例：
  17. /*
  18. cd的索引位置是：1
  19. Process finished with exit code 0
  20. */

5 数组排序算法

5.1 冒泡排序

冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是小数往前放，大数往后放，类似水中气泡往上升的动作，所以称作冒泡排序。

5.1.1 基本思想

是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面，这样较小的元素就像气泡一样从底部上升到顶部。

5.1.2 算法实现

例5.1.2 创建BubbleSort类，实现冒泡排序的一个演示，其中排序使用的是正排序：

  1. /**
  2.  * 冒泡排序算法实例
  3.  *
  4.  * @author Codeplus
  5.  */
  6. public class BubbleSort {
  8.     public static void main(String[] args) {
  10.         //创建一个数组，这个数组元素是乱序的
  11.         int[] array = new int[]{
  12.     64, 4, 24, 1, 3, 15};
  13.         //创建冒泡排序类的对象
  14.         BubbleSort sorter = new BubbleSort();
  15.         //调用排序方法将数组进行排序
  16.         sorter.sort(array);
  17.     }
  19.     /**
  20.      * 冒泡排序
  21.      *
  22.      * @param array 要排序的数组
  23.      */
  24.     public void sort(int[] array) {
  25.     i
  26.         for (int i = 1; i < array.length; i++) {
  28.             //比较相邻的两个元素，较大的数往后冒泡
  29.             for (int j = 0; j < array.length - i; j++) {
  31.                 if (array[j] > array[j + 1]) {
  33.                     int temp = array[j];//把第一个元素的值保存在临时变量里
  34.                     array[j] = array[j + 1];//把第二个元素值保存到第一个元素单元里
  35.                     array[j + 1] = temp;//把临时变量保存到第二个元素中
  36.                 }
  37.             }
  38.         }
  39.         showArray(array);       //输出冒泡排序后的数组元素
  40.     }
  42.     /**
  43.      * 显示数组中的所有元素
  44.      *
  45.      * @param array 要显示的数组
  46.      */
  47.     public void showArray(int[] array) {
  49.         for (int i :
  50.                 array) {
  51.            //遍历数组
  52.             System.out.print(" >" + i);    //输出每个数组元素值
  53.         }
  54.         System.out.println();
  55.     }
  56. }
  58. //输出示例：
  59. /*
  60.  >1 >3 >4 >15 >24 >64
  61. Process finished with exit code 0
  62. */

5.2 直接选择排序

5.2.1 基本思想

将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值。注意这里与冒泡排序的区别，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换，这样排序好的位置逐渐扩大，最后整个数组都成为已经排序好的格式。

5.2.2 算法实现

例5.2.2 创建SelectSort类，这个类作为直接选择排序的一个演示，其中排序选择的是正排序：

  1. /**
  2.  * 直接选择排序算法实例
  3.  *
  4.  * @author Codeplus
  5.  */
  6. public class SelectSort {
  8.     public static void main(String[] args) {
  10.         //创建一个数组，这个数组元素是乱序的
  11.         int[] array = new int[]{
  12.     64, 4, 24, 1, 3, 15};
  13.         //创建直接选择排序类的对象
  14.         SelectSort sorter = new SelectSort();
  15.         //调用排序方法将数组进行排序
  16.         sorter.sort(array);
  17.     }
  19.     /**
  20.      * 直接选择排序
  21.      *
  22.      * @param array 要排序的数组
  23.      */
  24.     public void sort(int[] array) {
  26.         int index;
  27.         for (int i = 1; i < array.length; i++) {
  29.             index=0;
  30.             for (int j = 1; j <= array.length - i; j++) {
  32.                 if (array[j] > array[index]) {
  34.                     index=j;
  35.                 }
  36.             }
  37.             //交换在位置array.length-i和index（最大值）上的两个数
  38.             int temp = array[array.length-i];//把第一个元素的值保存在临时变量里
  39.             array[array.length-i] = array[index];//把第二个元素值保存到第一个元素单元里
  40.             array[index] = temp;//把临时变量保存到第二个元素中
  41.         }
  42.         showArray(array);       //输出冒泡排序后的数组元素
  43.     }
  45.     /**
  46.      * 显示数组中的所有元素
  47.      *
  48.      * @param array 要显示的数组
  49.      */
  50.     public void showArray(int[] array) {
  52.         for (int i :
  53.                 array) {
  54.            //遍历数组
  55.             System.out.print(" >" + i);    //输出每个数组元素值
  56.         }
  57.         System.out.println();
  58.     }
  59. }
  61. //输出示例：
  62. /*
  63.  >1 >3 >4 >15 >24 >64
  64. Process finished with exit code 0
  65. */

5.3 反转排序

5.3.1 基本思想

把数组最后一个元素与第一个元素交换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换

5.3.2 算法实现

例5.3.2 创建ReverseSort类，实现反转排序演示：

  1. /**
  2.  * 反转排序算法实例
  3.  *
  4.  * @author Codeplus
  5.  */
  6. public class ReverseSort {
  8.     public static void main(String[] args) {
  10.         // 创建一个数组
  11.         int[] array = {
  12.     10, 20, 30, 40, 50, 60};
  13.         // 创建反转排序类的对象
  14.         ReverseSort sorter = new ReverseSort();
  15.         // 调用排序对象的方法将数组反转
  16.         sorter.sort(array);
  17.     }
  19.     /**
  20.      * 直接选择排序法
  21.      *
  22.      * @param array 要排序的数组
  23.      */
  24.     public void sort(int[] array) {
  26.         System.out.println("数组原有内容：");
  27.         showArray(array);// 输出排序前的数组值
  28.         int temp;
  29.         int len = array.length;
  30.         for (int i = 0; i < len / 2; i++) {
  32.             temp = array[i];
  33.             array[i] = array[len - 1 - i];
  34.             array[len - 1 - i] = temp;
  35.         }
  36.         System.out.println("数组反转后内容：");
  37.         showArray(array);// 输出排序后的数组值
  38.     }
  40.     /**
  41.      * 显示数组所有元素
  42.      *
  43.      * @param array 要显示的数组
  44.      */
  45.     public void showArray(int[] array) {
  47.         for (int i : array) {
  48.     // foreach格式遍历数组
  49.             System.out.print("\t" + i);// 输出每个数组元素值
  50.         }
  51.         System.out.println();
  52.     }
  53. }
  55. //输出示例：
  56. /*
  57. 数组原有内容：
  58.     10    20    30    40    50    60
  59. 数组反转后内容：
  60.     60    50    40    30    20    10
  61. Process finished with exit code 0
  62. */

发表评论

表情：
评论列表 （有 0 条评论，291人围观）

还没有评论，来说两句吧...

相关阅读