Java 数组中最高的偶数

我想要数组中最高的偶数

public static void main(String[] args) {
    int[] a = new int[]{10, 46, 78, 32, 3, 80, 92, 11, 39, 57};
    System.out.println(Arrays.toString(a));

    int largest = Integer.MAX_VALUE;
    for(int number : a) {
        if(number > largest) {
            largest = number;
        }
    }
    System.out.println(largest);
}

输出为：

[10, 46, 78, 32, 3, 80, 92, 11, 39, 57]
2147483647

---

不要将最大值初始化为最大整数：

int largest = Integer.MAX_VALUE;

改为将其设置为minint

int largest = Integer.MIN_VALUE;

或者，正如@Stultuske所建议的，初始化为数组中的第一个值：

int largest = a[0];

正如@Zabusa所指出的，你想要偶数。因此，改进if语句，使其仅在偶数上触发：

if (number > largest && number % 2 == 0) {

---

不要将最大值初始化为最大整数：

int largest = Integer.MAX_VALUE;

改为将其设置为minint

int largest = Integer.MIN_VALUE;

或者，正如@Stultuske所建议的，初始化为数组中的第一个值：

int largest = a[0];

正如@Zabusa所指出的，你想要偶数。因此，改进if语句，使其仅在偶数上触发：

if (number > largest && number % 2 == 0) {

最简单的方法（如果您确实使用这种小型阵列）是： 第一步。对数组进行排序 第二步。打印最后一个元素

对于较大的阵列，Stefan提供的解决方案确实是更好的选择。

最简单的方法（如果您确实使用这种小型阵列）有： 第一步。对数组进行排序 第二步。打印最后一个元素

---

对于较大的阵列，Stefan提供的解决方案确实是更好的选择。

适用于正数和负数偶数

    int[] a = new int[]{100, 45, 77, 33, 3, 81, 80, 8, 120, 100,-2};
    int maxvalue = Integer.MIN_VALUE;
    for (int anA : a) {
        if (anA % 2 == 0) {
            if (anA >= maxvalue)
                maxvalue = anA;
        }
    }

---

为正数和负数工作偶数

    int[] a = new int[]{100, 45, 77, 33, 3, 81, 80, 8, 120, 100,-2};
    int maxvalue = Integer.MIN_VALUE;
    for (int anA : a) {
        if (anA % 2 == 0) {
            if (anA >= maxvalue)
                maxvalue = anA;
        }
    }

---

使用Streams的另一种简单解决方案：

int[] a = new int[] { 10, 46, 78, 32, 3, 80, 92, 11, 39, 57 };
System.out.println(Arrays.toString(a));

int largest = Arrays.stream(a).filter((i) -> i % 2 == 0).max().getAsInt();


System.out.println(largest);

高效快捷的方法。如果列表中没有偶数，则

getAsInt（）

将抛出一个

NoSuchElementException

，该异常可以以任何方式轻松捕获和处理

---

如果您不想处理异常，但希望定义一个表示输入可能格式不正确的值，则也可以使用

orElse（-1）

或类似的方法，而不是

getAsInt（）

。

使用流的替代简单解决方案：

int[] a = new int[] { 10, 46, 78, 32, 3, 80, 92, 11, 39, 57 };
System.out.println(Arrays.toString(a));

int largest = Arrays.stream(a).filter((i) -> i % 2 == 0).max().getAsInt();


System.out.println(largest);

高效快捷的方法。如果列表中没有偶数，则

getAsInt（）

将抛出一个

NoSuchElementException

，该异常可以以任何方式轻松捕获和处理

如果您不想处理异常，但希望定义一个表示输入可能存在错误的值，则也可以使用

orElse（-1）

或类似值，而不是

getAsInt（）

。

解释 您的代码有两个问题。第一个是，正如其他人已经指出的，您以

Integer.MAX_VALUE

作为初始猜测，这是错误的逻辑

您需要使用可能最坏的最大值作为初始猜测。否则，您的元素总是较小的，因此您最初的猜测是最大的元素。这就是为什么我们首先猜测

MIN\u值

为最大元素。因为数组的元素只能变得更大。只需在纸上播放像

{1，2}

这样的小示例的算法，您就会明白为什么这样做是有意义的

第二个问题是，你实际上在考虑<强>所有值，但是你只想考虑<强>偶数值< /强>。我们可以通过跳过所有奇数值轻松解决这个问题

---

代码 以下是您的代码和两个修复程序：

public static void main(String[] args) {
    int[] a = new int[]{10, 46, 78, 32, 3, 80, 92, 11, 39, 57};
    System.out.println(Arrays.toString(a));

    // Start with lowest value as initial guess
    int largest = Integer.MIN_VALUE;
    for (int number : a) {
        // Skip number if odd
        if (number % 2 == 1) {
            continue;
        }

        // Now we only consider and collect even numbers
        if (number > largest) {
            // Update the current guess
            largest = number;
        }
    }
    // We now considered all elements, the guess is
    // final and correct.
    // And also even since we skipped odd values.
    System.out.println(largest);
}

---

笔记

如果数组不包含任何偶数，则输出将是代码>整数.MyIsValue，您可以考虑这个特殊情况并用“<代码> >如果子句。< /P> 其他人建议使用数组的一个元素作为初始猜测。由于您只希望值相等，所以可以只考虑数组的<强> >值> /强>此初始猜测。否则，如果数组不包含偶数值，您将再次输出奇数

您可以使用通用且紧凑的

流

解决方案作为自定义方法的替代方案：

int maxEven = Arrays.stream(a)
    .filter(a -> a % 2 == 0) // Only even values
    .max()  // OptionalInt
    .orElse(-1); // Gets the value or uses -1 if not present

解释 您的代码有两个问题。第一个是，正如其他人已经指出的，您以

Integer.MAX_VALUE

作为初始猜测，这是错误的逻辑

您需要使用可能最坏的最大值作为初始猜测。否则，您的元素总是较小的，因此您最初的猜测是最大的元素。这就是为什么我们首先猜测

MIN\u值

为最大元素。因为数组的元素只能变得更大。只需在纸上播放像

{1，2}

这样的小示例的算法，您就会明白为什么这样做是有意义的

第二个问题是，你实际上在考虑<强>所有值，但是你只想考虑<强>偶数值< /强>。我们可以通过跳过所有奇数值轻松解决这个问题

---

代码 以下是您的代码和两个修复程序：

public static void main(String[] args) {
    int[] a = new int[]{10, 46, 78, 32, 3, 80, 92, 11, 39, 57};
    System.out.println(Arrays.toString(a));

    // Start with lowest value as initial guess
    int largest = Integer.MIN_VALUE;
    for (int number : a) {
        // Skip number if odd
        if (number % 2 == 1) {
            continue;
        }

        // Now we only consider and collect even numbers
        if (number > largest) {
            // Update the current guess
            largest = number;
        }
    }
    // We now considered all elements, the guess is
    // final and correct.
    // And also even since we skipped odd values.
    System.out.println(largest);
}

---

笔记

如果数组不包含任何偶数，则输出将是代码>整数.MyIsValue，您可以考虑这个特殊情况并用“<代码> >如果子句。< /P> 其他人建议使用数组的一个元素作为初始猜测。由于您只希望值相等，所以可以只考虑数组的<强> >值> /强>此初始猜测。否则，如果数组不包含偶数值，您将再次输出奇数

您可以使用通用且紧凑的

流

解决方案作为自定义方法的替代方案：

int maxEven = Arrays.stream(a)
    .filter(a -> a % 2 == 0) // Only even values
    .max()  // OptionalInt
    .orElse(-1); // Gets the value or uses -1 if not present

---

如果您有权访问Java8和更高版本，我一定会查看。您可以将整数数组视为一个值流。使用该流，您可以访问高级函数，如min、max和filter。在Java中使用流有许多优点，如下面提到的一个

Java8流可以看作是延迟构造的集合，其中的值是在用户需要时计算的。实际集合的行为与之完全相反，它们是一组迫切需要计算的值（无论用户是否需要特定值）

你可以继续阅读

那么，对answ来说