我想知道如何从数组中删除某些元素[重复]答案

【问题标题】：I want to know how to remove certain elements from an array [duplicate]我想知道如何从数组中删除某些元素[重复]
【发布时间】：2019-01-04 02:10:17
【问题描述】：

在这个程序中，我希望能够从数组中删除最小值和最大值，但我不知道该怎么做。

public class Average
{

  public static void main (String [ ] args) 
  {

    double [] weights = {39.5, 34.8, 22.6, 38.7, 25.4, 30.1, 41.8, 33.6, 26.2, 27.3};
    double minimum = Integer.MAX_VALUE;
    double maximum = Integer.MIN_VALUE;

    for(int i = 0; i < weights.length; i++){
        if(minimum > weights [i])
            minimum = weights[i];
    }

    for(int i = 0; i < weights.length; i++){
        if(maximum < weights [i])
            maximum = weights[i];
    }
  } 
}

【问题讨论】：

复制到一个新的新数组？不包括 min 和 max 元素？如果这些元素出现两次或多次会怎样？
您不能真正删除或添加到数组。您最好将所有内容存储在列表中。 ArrayList 在这里可以很好地工作。运行与上面相同的循环以查找最大和最小数字，将它们存储在变量中，然后执行 ArrayList.remove(maximum); ArrayList.remove(最小);
无论是谁对问题和/或答案投了反对票，请解释一下您为什么这样做？我希望你知道你会因为投反对票而失去声誉点数..

标签： java arrays

【解决方案1】：

使用 java 8，您可以在数组中使用您不想要的 stream 到 filter。为了在filter 方法中使用您的最小和最大变量，您必须将它们放在final 变量中。您在 filter 方法中看到的w 是一个表示每个元素值的局部变量。

您也不必遍历数组两次来找到最小值和最大值。只需使用if/else if 设置适当的最小值/最大值。

import java.util.Arrays;

public class StackOverflow {
    public static void main(String args[]) {
        double[] weights = { 39.5, 34.8, 22.6, 38.7, 25.4, 30.1, 22.6, 41.8, 33.6, 26.2, 27.3 };
        double minimum = Double.MAX_VALUE;
        double maximum = Double.MIN_VALUE;

        for (int i = 0; i < weights.length; i++) {
            if (minimum > weights[i])
                minimum = weights[i];
            else if (maximum < weights[i])
                maximum = weights[i];
        }

        System.out.println("Before: " + Arrays.toString(weights));

        final double minimumFilter = minimum;
        final double maximumFilter = maximum;
        weights = Arrays.stream(weights)
                .filter(w -> w != minimumFilter && w != maximumFilter)
                .toArray();

        System.out.println("After : " + Arrays.toString(weights));
    }
}

结果：

Before: [39.5, 34.8, 22.6, 38.7, 25.4, 30.1, 22.6, 41.8, 33.6, 26.2, 27.3]
After : [39.5, 34.8, 38.7, 25.4, 30.1, 33.6, 26.2, 27.3]
// Two 22.6 minimum was removed and one 41.8 maximum was removed.

【讨论】：

【解决方案2】：

有多种方法可以解决这个问题。

遍历数组并跳过所需的索引，并将所有剩余值存储到新数组中。
使用数组复制复制没有最小值和最大值的元素。

但我建议为此目的使用集合框架。

List<Double> weights = new ArrayList<Double>();

最好使用ArrayList 而不是普通数组，这样只需提供索引即可轻松删除任何节点。但如果您只想使用数组，您可以将Array 转换为List，然后删除元素并再次将List 转换为Array。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

public class Average {

    public static void main(String[] args) {

        double[] weights = { 39.5, 34.8, 22.6, 38.7, 25.4, 30.1, 41.8, 33.6, 26.2, 27.3 };
        double minimum = Integer.MAX_VALUE;
        double maximum = Integer.MIN_VALUE;
        int minIndex = -1;
        int maxIndex = -1;

        for (int i = 0; i < weights.length; i++) {
            if (minimum > weights[i]) {
                minimum = weights[i];
                minIndex = i;
            }
        }

        for (int i = 0; i < weights.length; i++) {
            if (maximum < weights[i]) {
                maximum = weights[i];
                maxIndex = i;
            }
        }

        List<Double> list = Arrays.stream(weights).boxed().collect(Collectors.toList());
        list.remove(minIndex);
        if(minIndex<maxIndex)
            list.remove(maxIndex-1);
        else
            list.remove(maxIndex);

        weights = list.stream().mapToDouble(Double::doubleValue).toArray();

        for (double weight : weights) {
            System.out.print(weight + " ");
        }
    }
}

【讨论】：

【解决方案3】：

我认为你最好将背后的逻辑封装在一个工具方法中，如下所示：

// all minimums and maximums in the array will be deleted and return a brand-new array;
public static Double[] removeMinMax(Double[] arr) {
    if (arr == null || arr.length == 0) throw new IllegalArgumentException();
    // a trick to be used avoid lambda `effectively final` check;
    Double[] minMax = {arr[0], arr[0]};
    for (int i = 0; i < arr.length; ++i) {
        if (minMax[0].compareTo(arr[i]) > 0) minMax[0] = arr[i];
        if (minMax[1].compareTo(arr[i]) < 0) minMax[1] = arr[i];
    }
    return Arrays.stream(arr)
            .filter(a -> a.compareTo(minMax[0]) != 0 && a.compareTo(minMax[1]) != 0)
            .toArray(Double[]::new);
}

作为您的输入并进行本地测试：

public static void main(String... args) {
    Double[] weights = {39.5, 34.8, 22.6, 38.7, 25.4, 30.1, 41.8, 33.6, 26.2, 27.3};
    Double[] ret = removeMinMax(weights);
    System.out.println(Arrays.toString(ret));
}

结果将是：

// minimum 22.6 and maximum 41.8 are removed
[39.5, 34.8, 38.7, 25.4, 30.1, 33.6, 26.2, 27.3]

【讨论】：