Arrays.stream对数组前i取最大值

可以使用Java 8中的Arrays.stream方法和IntStream.rangeClosed方法来实现对数组前i个元素取最大值的操作。代码示例如下：

int[] arr = {10, 5, 8, 3, 6};
int i = 3; // 取前3个元素

int max = Arrays.stream(Arrays.copyOfRange(arr, 0, i))
                .max()
                .orElse(0); // 如果数组为空，返回0

System.out.println("前" + i + "个元素的最大值为：" + max);

解释一下代码：

- 首先，使用Arrays.copyOfRange方法截取数组的前i个元素，并将截取后的数组转换为IntStream类型。
- 然后，使用IntStream.max方法获取该流中的最大值。
- 最后，使用Optional.orElse方法指定如果数组为空时的默认返回值。

运行代码，输出结果为：

前3个元素的最大值为：10

这里假设数组中至少有i个元素。如果数组中不足i个元素，将会返回截取后的所有元素的最大值。

相关问题

第2关：灵活使用Java对数组操作的方法 - 成绩统计

第二关涉及的是在Java中利用数组进行成绩统计的操作，通常包括创建数组、读取元素、计算平均分、查找最高分和最低分等任务。下面是一个简单的例子：

import java.util.Arrays;

public class GradeStatistics {
    public static void main(String[] args) {
        // 创建一个学生分数的整型数组
        int[] scores = {85, 90, 78, 92, 88};
        
        // 对数组进行操作
        // 1. 计算平均分 (sum / count)
        double sum = Arrays.stream(scores).sum();
        int count = scores.length;
        double average = sum / count;
        System.out.println("平均分: " + average);

        // 2. 查找最高分 (Arrays.stream().max())
        int maxScore = Arrays.stream(scores).max().getAsInt();
        System.out.println("最高分: " + maxScore);

        // 3. 查找最低分 (Arrays.stream().min())
        int minScore = Arrays.stream(scores).min().getAsInt();
        System.out.println("最低分: " + minScore);
    }
}

在这个示例中，我们首先创建了一个包含学生分数的数组，然后通过`Arrays.stream()`将数组转换为流来方便地进行数学运算。接着，我们计算了总分并除以学生数得到平均分，找到最大值作为最高分，最小值作为最低分。

创建一个1×1000的一维数组，对数组中的元素进行随机赋值（使用Math.random()生成10-100之间的浮点数）。通过算法找到该数组中最大的5个数，要求从大到小输出这5个数和它们的和。

首先，我们可以创建一个一维数组并初始化它的所有元素为0。然后使用Math.random()函数生成10到100之间的浮点数，遍历整个数组将每个元素替换为随机生成的数。接下来，我们使用一种叫做快速选择（QuickSelect）或堆排序（Heapsort）的算法，找出数组中的前五个最大值，并按照降序存储。最后计算这五个数的总和。

以下是使用Java语言的一个简单示例：

import java.util.Arrays;
import java.util.Random;

public class Main {
    public static void main(String[] args) {
        int[] array = new int[1000];
        Random random = new Random();
        
        // 初始化数组并填充随机数
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(100) + 10;  // 生成10到100的随机数
        }
        
        // 使用快速选择或堆排序找前五大的数
        QuickSelect quickSelect = new QuickSelect(array);
        int[] largestFive = quickSelect.selectKthLargest(5);
        
        // 输出结果
        System.out.println("最大的5个数:");
        for (int num : largestFive) {
            System.out.print(num + " ");
        }
        double sum = Arrays.stream(largestFive).sum();
        System.out.println("\n它们的和: " + sum);
    }

    // 快速选择的简化实现
    private static class QuickSelect {
        private int[] arr;

        QuickSelect(int[] arr) {
            this.arr = arr.clone();  // 复制原始数组避免修改原数组
        }

        int[] selectKthLargest(int k) {
            return quickSelect(arr, 0, arr.length - 1, k);
        }

        private int[] quickSelect(int[] arr, int left, int right, int k) {
            if (left == right) {
                return new int[]{arr[left]};
            }

            int pivotIndex = partition(arr, left, right);
            if (k == pivotIndex) {
                return Arrays.copyOfRange(arr, pivotIndex, pivotIndex + 1);
            } else if (k < pivotIndex) {
                return quickSelect(arr, left, pivotIndex - 1, k);
            } else {
                return quickSelect(arr, pivotIndex + 1, right, k);
            }
        }

        private int partition(int[] arr, int left, int right) {
            int pivot = arr[right];
            int i = left - 1;
            for (int j = left; j < right; j++) {
                if (arr[j] >= pivot) {
                    i++;
                    swap(arr, i, j);
                }
            }
            swap(arr, i + 1, right);
            return i + 1;
        }

        private void swap(int[] arr, int i, int j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
}