java数组-3

 

目录

8.3数组应用

8.3.1 数组排序

8.3.2 求数组最大值

8.3.3 向数组中插入元素

8.3.4 技能训练

---

8.3数组应用

8.3.1 数组排序

数组排序是实际开发中比较常用的操作，如果需要对存放在数组中的五位学员的考试成绩从低到高排序，应如何实现呢？其实在 Java 中这个问题很容易解决。先看下面的语法。

语法

Arrays.sort(数组名);

说明：Arrays 是 Java 中提供的一个类，而 sort()是该类的一个方法。关于“类”和“方法”的含义将在后续章节中详细讲解。这里我们只需要知道，按照上面的语法，即将数组名放在 sort() 方法的括号中，就可以完成对该数组的排序。因此，这个方法执行后，数组中的元素已经有序(升序)了。

为了掌握数组排序的方法，下面就解决上述问题，即对五位学员的考试成绩从低到高排序。

示例2

package cn.jbit.array;
import java.util.Arrays;
import java.util.Scanner;
public class ScoreSort {
    public static void main(String[] args) {
        int[] scores = new int[5]; //成绩数组
        Scanner input = new Scanner(System.in);
        System.out.println("请输入5位学员的成绩：");
        //循环录入学员成绩
        for(int i = 0; i < scores.length; i++){
            scores[i] = input.nextInt();
        }
        Arrays.sort(scores);   //对数组进行升序排序
        System.out.print("学员成绩按升序排列：");
        //利用循环输出学员成绩
        for(int i = 0; i < scores.length; i++){
            System.out.print(scores[i] + " ");
        }
    }
}

图 8.8 示例 2 的运行结果

为了对成绩数组 scores 排序，只需要把数组名 scores 放在 sort()方法的括号中，该方法执行后,利用循环输出数组中的成绩，可以看到数组中的成绩已经按升序排列。

8.3.2 求数组最大值

问题：从键盘上输入五位学员的 Java 考试成绩，求考试成绩的最高分。

在解决这个问题之前，我们先来看"比武打擂"的场景，如图 8.9 所示。首先假定第一个上擂台的是擂主，然后下一个竞争选手与他比武。如果他胜利了，他仍然是擂主，继续跟后面的竞争对手比武。如果他失败了，则他的竞争对手便在擂台上。作为目前的擂主，他会继续与后面的选手比武。依此类推，最后胜利的那个便是本次比武的冠军。那么，类似于比武，求最高分就是找出这次考试的擂主。

图 8.9 比武打擂

根据上面的描述，可以用代码表示如下。

……

max = scores[0];

if(a[1] > max)
   max = scores[1];
if(a[2] > max)
   max = scores[2];

if(a[3] > max)
   max = scores[3];

……

最终变量 max 中存储的就是本次考试的最高分。这样写代码似乎太烦琐了，能不能进行简此呢？观察可知：这是一个循环的过程， max 变量依次与数组中的元素进行比较。如果 max 小于比较的元素，则执行置换操作。如果 max 较大，则不执行操作。因此，采用循环的方式来写代码会大大简化代码量，提高程序效率，如示例 3 所示。

示例3

package cn.jbit.array;
import java.util.Scanner;
public class MaxScore {
    /**
     * 求数组最大值
     */
    public static void main(String[] args) {
        int[] scores = new int[5];
        int max = 0;   //记录最大值
        System.out.println("请输入5位学员的成绩：");
        Scanner input = new Scanner(System.in);
        for(int i = 0; i < scores.length; i++){
            scores[i] = input.nextInt();
        }
        //计算最大值
        max = scores[0];
        for(int i = 1; i < scores.length; i++){
            if(scores[i] > max){
                max = scores[i];
            }
        }
        System.out.println("考试成绩最高分为：" + max);
    }
}

程序运行结果如图 8.10 所示。

图 8.10 示例 3 的运行结果

经过比较，可以得出本次考试的最高成绩是 96 分。示例 3 是求最大值，如何求最小值呢？请大家首先想一想，在后面的练习中我们再具体求最小值。

8.3.3 向数组中插入元素

问题：有一组学员的成绩是｛99,85,82,63,60｝，将它们按降序排列，保存在一个数组中。现需要增加一个学员的成绩，将它插入数组，并保持成绩降序排列。

分析：首先将五个学员的成绩保存在长度为 6 的整型数组中。然后，要找到新增成绩的插入位置。为了保持数组中的成绩有序，需要从数组的第一个元素开始与新增的成绩进行比较，直到找到要插入的位置，可以使用循环进行比较。找到插入位置后，将该位置后的元素后移一个位置，最后将新增的成绩信息插入该位置即可。

示例4

import java.util.*;
public class Insert {
   public static void main(String[] args) {
      int[] list = new int[6]; // 长度为为6的数组
         list[0] = 99;
         list[1] = 85;
         list[2] = 82;
         list[3] = 63;
         list[4] = 60;

         int index = list.length;   //保存新增成绩插入位置
         System.out.println("请输入新增成绩： ");
         Scanner input = new Scanner(System.in);
         int num = input.nextInt(); // 输入要插入的数据
         //找到新元素的插入位置
           for(int i = 0; i < list.length; i++){
               if( num > list[i]){
                   index = i;
                   break;
               }
           }       
          //元素后移
           for(int j = list.length-1; j > index; j--){
               list[j] = list[j-1];   //index下标开始的元素后移一个位置
           }
         list[index] = num;//插入数据
         System.out.println("插入成绩的下标是："+index);
         System.out.println("插入后的成绩信息是： ");
         for (int k = 0; k < list.length; k++) { // 循环输出目前数组中的数据
            System.out.print(list[k] + "\t");
         }
   }
}

程序运行结果如图 8.11 所示。

图 8.11 示例 4 的运行结果

从运行结果可以看出，插入成绩 88 以后，成绩序列依然是按降序排列的。

小结：在实际开发中，数组应用非常广泛，本章只是抛砖引玉，讲解了几种常见的应用数组的情况。数组经常与选择结构、循环结构搭配来解决问题。大家需要多思考，能够举一反三，掌握使用数组解决问题的思路和方法。

8.3.4 技能训练

上机练习 3

练习——字符逆序输出

需求说明

• 有一列乱序的字符：a、c、u、b、e、p、f、z,排序并按照英文字母表的升序和逆序输出。
• 
  程序运行结果如图 8.12 所示。

图 8.12 上机练习 3 的运行结果

提示：参考实现步骤如下。

(1) 创建数组，存储原字符序列。

(2) 利用 Array 类的 sort() 方法对数组进行排序，并循环输出。

(3) 使用循环，从最后一个元素开始，将数组中的元素逆序输出。

参考代码示范

package cn.jbit.array;
import java.util.Arrays;
public class CharsSort {
    /**
     * 字符逆序输出
     */
    public static void main(String[] args) {
        char[] chars = new char[]{'a','c','u','b','e','p','f','z'};
        System.out.print("原字符序列：");
        for(int i = 0; i < chars.length; i++){
            System.out.print(chars[i] + " ");
        }
        Arrays.sort(chars);       //对数组进行升序排序
        System.out.print("\n升序排序后：");
        for(int i = 0; i < chars.length; i++){
            System.out.print(chars[i] + " ");
        }
        System.out.print("\n逆序输出为：");
        for(int i = chars.length-1; i >= 0; i--){
            System.out.print(chars[i] + " ");
        }
    }
}

上机练习4

练习——向有序字符列中插入字符

需求说明

• 在上机练习 3 的基础上改进功能，现有一组有序的字符序列a、b、c、e、f、p、u、z,要向此字符序列中插入一个新的字符，要求插入之后字符序列仍保持有序。
• 
  程序运行结果如图 8.13 所示。

图 8.13 上机练习 4 的运行结果

提示：参考实现步骤如下。

(1) 修改上机练习 3 代码，定义长度为 9 的数组，保存原字符序列。

(2) 按上机练习 3 的方法实现字符序列排序。

(3) 找到新增字符的插入位置。

(4) 从插入位置开始的元素均后移一个位置。

(5) 插入新的字符，并输出结果。

参考代码示范

package cn.jbit.array;
import java.util.*;
public class CopyInsert {
    public static void main(String[] args) {
        //字符排序
        char[] chars = new char[9];
        chars[0] = 'a';
        chars[1] = 'b';
        chars[2] = 'c';
        chars[3] = 'e';
        chars[4] = 'f';
        chars[5] = 'p';
        chars[6] = 'u';
        chars[7] = 'z';

        System.out.print("原字符序列：");
        for(int i = 0; i < chars.length; i++){
            System.out.print(chars[i] + " ");
        }
      /*Arrays.sort(chars);     //对数组进行升序排序
      System.out.print("\n升序排序后：");
      for(int i = 0; i < chars.length; i++){
         System.out.print(chars[i] + " ");
      }*/
        //实现插入字符
        int index = chars.length;  //保存新增成绩插入位置
        char ch='m';
        System.out.println("\n待插入的字符是： "+ch);

        //找到新元素的插入位置
        for(int i = 0; i < chars.length; i++){
            if(ch < chars[i]){
                index = i;
                break;
            }
        }
        //元素后移
        for(int j = chars.length-1; j > index; j--){
            chars[j] = chars[j-1]; //index下标开始的元素后移一个位置
        }
        chars[index] = ch;//插入数据
        System.out.println("插入字符的下标是："+index);
        System.out.print("插入后的字符序列是： ");
        for (int k = 0; k < chars.length; k++) { // 循环输出目前数组中的数据
            System.out.print(chars[k] + " ");
        }
    }
}

上机练习5

练习——求商品最低价格

需求说明

张浩想买一部手机，他询问了四家店的价格，分别是3000元、3150元、2900元和2950元,请编程求出最低价格。

程序运行结果如图 8.14 所示。

图 8.14 上机练习 5 的运行结果

提示：参考实现步骤如下。

(1) 定义数组存储价格，并利用循环输入。

(2) 定义变量 min，保存当前的最低价，初始值为第一家店的手机价格。

(3) 利用循环，将 min 和数组中的其余元素依次比较，得到最低价格。

本章总结

• 数组是可以在内存中连续存储多个元素的结构，数组中的所有元素必须属于相同的数据类型。
• 数组中的元素通过数组的下标进行访问，数组的下标从 0 开始。
• 数组可用一个循环为元素赋值，或者用一个循环输出数组中的元素信息。
• 通过数组，length 可获得数组长度。
• 利用 Arrays 类提供的 sort()方法可以方便地对数组中的元素进行排序。