1. 全栈程序员必看首页

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

全栈程序员-用户IM • • 未分类

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设计基础及面向对象导向

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

发布者：全栈程序员-用户IM，转载请注明出处：https://javaforall.cn/106704.html原文链接：https://javaforall.cn

【正版授权，激活自己账号】： Jetbrains全家桶Ide使用，1年售后保障，每天仅需1毛

【官方授权 正版激活】： 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

赞 (0)
全栈程序员-用户IM全栈程序员-用户IM
0 0
blank

相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号