下列哪个方法可以用来返回数组中的最小值? A、array.sort() B、Math.min() 或 Math.min.apply() 或 ...array C、array.reduce() D、array.indexOf()

答案是 B、Math.min() 或 Math.min.apply() 或 ...array。可以使用这些方法来返回数组中的最小值。array.sort() 方法会对数组进行排序，但并不会返回最小值。array.reduce() 方法可以用来对数组元素进行累加或其他操作，但也不会直接返回最小值。array.indexOf() 方法用于查找某个值在数组中的索引位置，也不能用来返回最小值。

相关问题

Java 1、对一个随机生成的int型数组（大小为10，范围为1- 100)，完成以下工作：找到该数组的最大值；找到该数组的最小值；计算数组中所有数的和值；计算数组中所有数的平均值；对该数组进行冒泡排序；对该数组进行选择排序

Java是一种广泛使用的高级编程语言，由Sun Microsystems（现在已被Oracle收购）开发。它以其面向对象的设计、平台无关性和安全性而闻名。以下是您提到的任务在Java中如何实现：

1. 找到最大值、最小值、总和和平均值：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] array = new int[10];
        // 随机填充数组
        for (int i = 0; i < array.length; i++) {
            array[i] = (int)(Math.random() * 100); // 生成1到100的随机数
        }
        
        int max = Arrays.stream(array).max().getAsInt();
        int min = Arrays.stream(array).min().getAsInt();
        int sum = Arrays.stream(array).sum();
        double average = (double) sum / array.length;
        
        System.out.println("Max: " + max);
        System.out.println("Min: " + min);
        System.out.println("Sum: " + sum);
        System.out.println("Average: " + average);
    }
}

2. 冒泡排序：

void bubbleSort(int[] arr) {
    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;
            }
        }
    }
}

// 使用时，在main方法里调用bubbleSort(array)

3. 选择排序：

void selectionSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

// 使用时，在main方法里调用selectionSort(array)

请注意，以上代码示例都是在一个`main`方法中直接运行的，并假设`array`已经初始化。实际应用中，你需要将这些函数封装到适当的类或模块中。

3.编写一个泛型方法，能够返回一个int类型数组的最大值和最小值，String类型数组的最大值和最小值(按字典排序)

在Java中，我们可以编写两个泛型方法，一个处理`int`类型的数组，另一个处理`String`类型的数组。这两个方法将分别找到最大值和最小值，并且对于`String`数组，我们还需要按照字母顺序（字典排序）查找最大和最小值。

首先，对于`int`数组，我们可以直接使用内置的`Math.max`和`Math.min`方法：

public class ArrayUtils {

    public <T extends Comparable<T>> T[] findMinMax(int[] arr) {
        if (arr == null || arr.length == 0) {
            throw new IllegalArgumentException("Array cannot be empty");
        }
        return new T[]{Collections.max(Arrays.asList(arr)), Collections.min(Arrays.asList(arr))};
    }

    // 类似的，处理String数组时需要先转换为Comparable并排序
    public <T extends Comparable<T>> T[] findMinMaxSorted(String[] arr) {
        if (arr == null || arr.length == 0) {
            throw new IllegalArgumentException("Array cannot be empty");
        }
        Arrays.sort(arr);
        return new T[]{arr[arr.length - 1], arr[0]};
    }
}

注意：`<T extends Comparable<T>>`意味着方法接受任何实现了`Comparable`接口的数据类型作为输入，这样我们就可以对它们进行排序。

然后在主方法中调用这两个方法：

public static void main(String[] args) {
    int[] intArr = {5, 3, 9, 1, 7};
    String[] strArr = {"z", "a", "d", "b", "c"};

    try {
        int[] minMaxInt = ArrayUtils.findMinMax(intArr);
        System.out.println("Int array: Min=" + minMaxInt[0] + ", Max=" + minMaxInt[1]);

        String[] minMaxStr = ArrayUtils.findMinMaxSorted(strArr);
        System.out.println("String array (sorted): Min=" + minMaxStr[0] + ", Max=" + minMaxStr[1]);
    } catch (IllegalArgumentException e) {
        System.out.println(e.getMessage());
    }
}