Java程序设计（基础）- 数组

￡神魔★判官ぃ 2022-01-28 01:29 324阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70]数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。  
Java语言中提供的数组是用来存储固定大小的同类型元素。  
你可以声明一个数组变量，如numbers\[100\]来代替直接声明100个独立变量number0，number1，…，number99。  
Java数组的声明、创建和初始化，并给出其对应的代码。

# 声明数组变量 #

dataType[] arrayRefVar;   // 首选的方法
    //或
    dataType arrayRefVar[];  // 效果相同，但不是首选方法

double[] myList;         // 首选的方法
    double myList[];         // 效果相同，但不是首选方法

注意: 建议使用dataType\[\] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar\[\] 风格是来自 C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。

# 创建数组 #

arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事：

*  一、使用dataType\[arraySize\]创建了一个数组。
 *  二、把新创建的数组的引用赋值给变量 arrayRefVar。  
    数组变量的声明，和创建数组可以用一条语句完成，如下所示：

dataType[] arrayRefVar = new dataType[arraySize];

另外，你还可以使用如下的方式创建数组。

dataType[] arrayRefVar = { value0, value1, ..., valuek};

数组的元素是通过索引访问的。数组索引从0开始，所以索引值从0到arrayRefVar.length-1。  
实例:

public class TestArray { 
    
      public static void main(String[] args) { 
         // 数组大小
         int size = 10;
         // 定义数组
         double[] myList = new double[size];
         myList[0] = 5.6;
         myList[1] = 4.5;
         myList[2] = 3.3;
         myList[4] = 4.0;
         myList[5] = 34.33;
         myList[6] = 34.0;
         myList[7] = 45.45;
         myList[8] = 99.993;
         myList[9] = 11123;
         // 计算所有元素的总和
         double total = 0;
         for (int i = 0; i < size; i++) { 
            total += myList[i];
         }
         System.out.println("总和为： " + total);
      }
    }

以上实例输出结果为：

总和为： 11354.173

下面的图片描绘了数组myList。这里myList数组里有10个double元素，它的下标从0到9。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70 1]

# 处理数组 #

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者foreach循环。

*  示例

public class TestArray { 
     
       public static void main(String[] args) { 
          double[] myList = { 1.9, 2.9, 3.4, 3.5};
     
          // 打印所有数组元素
          for (int i = 0; i < myList.length; i++) { 
             System.out.println(myList[i] + " ");
          }
          // 计算所有元素的总和
          double total = 0;
          for (int i = 0; i < myList.length; i++) { 
             total += myList[i];
          }
          System.out.println("Total is " + total);
          // 查找最大元素
          double max = myList[0];
          for (int i = 1; i < myList.length; i++) { 
             if (myList[i] > max) max = myList[i];
          }
          System.out.println("Max is " + max);
       }
    }

以上实例编译运行结果如下：

1.9
    2.9
    3.4
    3.5

# 数组作为函数的参数 #

数组可以作为参数传递给方法。例如，下面的例子就是一个打印int数组中元素的方法。

public static void printArray(int[] array) { 
     for (int i = 0; i < array.length; i++) { 
       System.out.print(array[i] + " ");
     }
    }

下面例子调用printArray方法打印出 3，1，2，6，4和2

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

# 数组作为函数的返回值 #

public static int[] reverse(int[] list) { 
     int[] result = new int[list.length];
    
     for (int i = 0, j = result.length - 1; i < list.length; i++, j--) { 
       result[j] = list[i];
     }
     return result;
    }

以上实例中result数组作为函数的返回值。

# Arrays 类 #

java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：

*  给数组赋值：通过fill方法。
 *  对数组排序：通过sort方法,按升序。
 *  比较数组：通过equals方法比较数组中元素值是否相等。
 *  查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

具体说明请查看下表：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>public static int binarySearch(Object[] a, Object key)</td> 
   <td>用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>public static boolean equals(long[] a, long[] a2)</td> 
   <td>如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>public static void fill(int[] a, int val)</td> 
   <td>将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>public static void sort(Object[] a)</td> 
   <td>对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。</td> 
  </tr> 
 </tbody> 
</table>

# 二维数组 #

## 获取全部元素 ##

假设有一个矩阵为 5 行 5 列，该矩阵是由程序随机产生的 10 以内数字排列而成。下面使用二维数组来创建该矩阵，代码如下：

public class Test11
    { 
       public static void main(String[] args）
       { 
           //创建一个二维矩阵
           int[][] matrix=new int[5][5];
           //随机分配值
           for(int i=0;i<matrix.length;i++)
           { 
               for(int j=0;j<matrix[i].length;j++)
               { 
                   matrix[i][j]=(int)(Math.random()*10);
               }
           }
           System.out.println("下面是程序生成的矩阵\n");
           //遍历二维矩阵并输出
           for(int k=0;k<matrix.length;k++)
           { 
               for(int g=0;g<matrix[k].length;g++)
               { 
                   System.out.print(matrix[k][g]+"");
               }
               System.out.println();
           }
       }
    }

在该程序中，首先定义了一个二维数组，然后使用两个嵌套的 for 循环向二维数组中的每个元素赋值。其中，Math.random() 方法返回的是一个 double 类型的数值，数值为 0.6、0.9 等，因此乘以 10 之后为 10 以内的整数。最后又使用了两个嵌套的 for 循环遍历二维数组，输出二维数组中的值，从而产生矩阵。

运行该程序的结果如下所示。

34565
    96033
    48741
    10583
    63985

## 获取整行元素 ##

除了获取单个元素和全部元素之外，还可以单独获取二维数组的某一行中所有元素的值，或者二维数组中某一列元素的值。获取指定行的元素时，需要将行数固定，然后只遍历该行中的全部列即可。  
例如：编写一个案例，接收用户在控制台输入的行数，然后获取该行中所有元素的值。代码如下：

public static void main(String[] args)
    { 
       double[][] class_score={ { 100,99,99},{ 100,98,97},{ 100,100,99.5},{ 99.5,99,98.5}};
       Scanner scan=new Scanner(System.in);
       System.out.println("当前数组只有"+class_score.length+"行，您想查看第几行的元素？请输入：");
       int number=scan.nextInt();
       for(int j=0;j<class_score[number-1].length;j++)
       { 
           System.out.println("第"+number+"行的第["+j+"]个元素的值是："+class_score[number-1][j]);
       }
    }

执行上述代码进行测试，输出结果如下所示。
    当前数组只有4行，您想查看第几行的元素？请输入：
    3
    第3行的第[0]个元素的值是：100.0
    第3行的第[1]个元素的值是：100.0
    第3行的第[2]个元素的值是：99.5

# 获取整列元素 #

例如：编写一个案例，接收用户在控制台中输入的列数，然后获取二维数组中所有行中该列的值。代码如下：

public static void main(String[] args)
    { 
       double[][] class_score={ { 100,99,99},{ 100,98,97},{ 100,100,99.5},{ 99.5,99,98.5}};
       Scanner scan=new Scanner(System.in);
       System.out.println("您要获取哪一列的值？请输入：");
       int number=scan.nextInt();
       for(int i=0;i<class_score.length;i++)
       { 
           System.out.println("第 "+(i+1)+" 行的第["+number+"]个元素的值是"+class_score[i][number]);
       }
    }

执行上述代码进行测试，如下所示。

您要获取哪一列的值？请输入：

2
    第 1 行的第[2]个元素的值是99.0
    第 2 行的第[2]个元素的值是97.0
    第 3 行的第[2]个元素的值是99.5
    第 4 行的第[2]个元素的值是98.5

# 数组排序 #

## Java sort()方法 ##

使用 java.util.Arrays 类中的 sort() 方法对数组进行排序分为以下两步：

*  导入 java.util.Arrays 包。
 *  使用 Armys.sort(数组名) 语法对数组进行排序，排序规则是从小到大，即升序。

例 1  
假设在数组 scores 中存放了 5 名学生的成绩，现在要实现从低到高排列的功能。在这里使用 Arrays.sort() 方法来实现，具体代码如下：

import java.util.Arrays;
    public class Test23
    { 
       public static void main(String[] args)
       { 
           //定义含有5个元素的数组
           double[] scores=new double[]{ 78,45,85,97,87};
           System.out.println("排序前数组内容如下：");
    
           //对scores数组进行循环遍历
           for(int i=0;i<scores.length;i++)
           { 
               System.out.print(scores[i]+"\t");
           }
           System.out.println("\n排序后的数组内容如下：");
    
           //对数组进行排序
           Arrays.sort(scores);
    
           //遍历排序后的数组
           for(int j=0;j<scores.length;j++)
           { 
               System.out.print(scores[j]+"\t");
           }
       }
    }

如上述代码所示，要对一个数组进行升序排列，只需要调用 Arrays.sort() 方法即可。运行后的输出结果如下所示。

排序前数组内容如下：
    78.0    45.0    85.0    97.0    87.0   
    排序后的数组内容如下：
    45.0    78.0    85.0    87.0    97.0

## Java冒泡排序法（Bubble Sort） ##

/* * 冒泡排序 * @author 晓宇码匠 */
    public class BubbleSort { 
    　　public static void main(String[] args) { 
    　　　　int[] arr={ 6,3,8,2,9,1};
    　　　　System.out.println("排序前数组为：");
    　　　　for(int num:arr){ 
    　　　　　　System.out.print(num+" ");
    　　　　}
    　　　　for(int i=0;i<arr.length-1;i++){ //外层循环控制排序趟数
    　　　　　　for(int j=0;j<arr.length-1-i;j++){ //内层循环控制每一趟排序多少次
    　　　　　　　　if(arr[j]>arr[j+1]){ 
    　　　　　　　　　　int temp=arr[j];
    　　　　　　　　　　arr[j]=arr[j+1];
    　　　　　　　　　　arr[j+1]=temp;
    　　　　　　　　}
    　　　　　　}
    　　　　} 
    　　　　System.out.println();
    　　　　System.out.println("排序后的数组为：");
    　　　　for(int num:arr){ 
    　　　　　　System.out.print(num+" ");
    　　　　} 
    　　}
    }

## Java数组排序：Java快速排序（Quicksort）法 ##

public void quickSort(int[] arr, int low, int high) { 
           // low,high 为每次处理数组时的首、尾元素索引
    
           //当low==high是表示该序列只有一个元素，不必排序了
           if (low >= high) { 
               return;
           }
           // 选出哨兵元素和基准元素。这里左边的哨兵元素也是基准元素
           int i = low, j = high, base = arr[low];
           while (i < j) { 
               //右边哨兵从后向前找
               while (arr[j] >= base && i < j) { 
                   j--;
               }
               //左边哨兵从前向后找
               while (arr[i] <= base && i < j) { 
                   i++;
               }
               swap(arr,i,j);  //交换元素
           }
           swap(arr,low,j);  //基准元素与右哨兵交换
           
           //递归调用，排序左子集合和右子集合
           quickSort(arr,low,j-1);  
           quickSort(arr,j+1,high);
    
       }
    
       private void swap(int[] arr, int i, int j) { 
           int tmp = arr[i];
           arr[i] = arr[j];
           arr[j] = tmp;
       }

## Java数组排序：Java选择排序法 ##

package sorting;
    
    /** * 选择排序 * 平均O(n^2),最好O(n^2),最坏O(n^2);空间复杂度O(1);不稳定;简单 * @author 晓宇码匠 * */
    public class SelectionSort { 
    
       public static void selectionSort(int[] a) { 
           int n = a.length;
           for (int i = 0; i < n; i++) { 
               int k = i;
               // 找出最小值的下标
               for (int j = i + 1; j < n; j++) { 
                   if (a[j] < a[k]) { 
                       k = j;
                   }
               }
               // 将最小值放到未排序记录的第一个位置
               if (k > i) { 
                   int tmp = a[i];
                   a[i] = a[k];
                   a[k] = tmp;
               }
           }
       }
    
       public static void main(String[] args) { 
           int[] b = {  49, 38, 65, 97, 76, 13, 27, 50 };
           selectionSort(b);
           for (int i : b)
               System.out.print(i + " ");
       }
    }

## Java数组排序：Java直接插入法 ##

package sort;
    /** * 直接插入排序 的实现 * 稳定算法 * @author 晓宇码匠 * */
    public class InsertSort { 
       public static void main(String[] args) { 
           // TODO Auto-generated method stub
           int a[] = { 3,1,5,7,2,4,9,6};
           new InsertSort().insertSort(a);
       }
       /** * 直接插入排序算法的实现 * @param a */
       private void insertSort(int[] a) { 
           // TODO Auto-generated method stub
           System.out.println("———————————————————直接插入排序算法—————————————————————");
           int n = a.length;
           int i,j;
           for(i=1;i<n;i++){ 
               /** * temp为本次循环待插入有序列表中的数 */
               int temp = a[i];
               /** * 寻找temp插入有序列表的正确位置 */
               for(j=i-1;j>=0 && a[j]>temp;j--){ 
                   /** * 元素后移，为插入temp做准备 */
                   a[j+1] = a[j];
               }
               /** * 插入temp */
               a[j+1] = temp;
               print(a,n,i);
           }
           printResult(a,n);
       }
       /** * 打印排序的最终结果 * @param a * @param n */
       private void printResult(int[] a, int n){ 
           System.out.print("最终排序结果：");
           for(int j=0;j<n;j++){ 
               System.out.print(" "+a[j]);
           }
           System.out.println();
       }
       /** * 打印排序的每次循环的结果 * @param a * @param n * @param i */
       private void print(int[] a, int n, int i) { 
           // TODO Auto-generated method stub
           System.out.print("第"+i+"次：");
           for(int j=0;j<n;j++){ 
               System.out.print(" "+a[j]);
           }
           System.out.println();
       }
    }

总结，数组具有以下特点：

*  数组可以是一维数组、二维数组或多维数组。
 *  数值数组元素的默认值为 0，而引用元素的默认值为 null。
 *  交错数组是数组的数组，因此，它的元素是引用类型，初始化为 null。交错数组元素的维度和大小可以不同。
 *  数组的索引从 0 开始，如果数组有 n 个元素，那么数组的索引是从 0 到（n-1）。
 *  数组元素可以是任何类型，包括数组类型。
 *  数组类型是从抽象基类 Array 派生的引用类型。

[Java设计基础及面向对象导向][Java]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70]: /images/20220128/19490de9af074400b6a5257a3f4e22c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70 1]: /images/20220128/03ecf7a157bd482daf63c14c07e0ec9c.png
[Java]: https://blog.csdn.net/qq_37651267/article/details/90550939