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

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。
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。

处理数组

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者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方法能对排序好的数组进行二分查找法操作。

具体说明请查看下表：

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

二维数组

获取全部元素

假设有一个矩阵为 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设计基础及面向对象导向