Question

我想创建一个方法，该方法可以接收数组和要比较的值。它应该以数组形式返回大于比较值的数字。

例如，greaterThan([3, 4, 5, 6], 4])应该返回[5, 6]，而greaterThan([3, 4, 5, 6], 5])应该返回[6]。

由于length数组的result是动态的，因此每次发现较大的元素时，我都会增加其大小。

static String greaterThan(int[] vectorCompare, int valueCompare)
{   
    Arrays.sort(vectorCompare);         // make it faster

    int size = 0;

    int[] result = new int[size];

    for (int value : vectorCompare)
    {
        if (valueCompare < value)
        {               
            size++;             
        }           
    }

    int[] resultCopy = Arrays.copyOf(result, size);

    // what to do next?

    return Arrays.toString(resultCopy);

}

对我有什么提示吗？我曾想过使用ArrayList，但有点卡住了。

Answer 1

您不需要对其进行排序，只需将元素收集在列表中，然后在内容上调用toString。如果顺序很重要，则可以对收集的值列表进行排序。

    static String greaterThan(int[] vector, int compare) {
        List<Integer> greater = new ArrayList<>();

        for (int i : vector) {
            if (i > compare) {
                 greater.add(i);
            }
        }

        return greater.toString();
    }

Answer 2

使用上述方法对输入进行排序实际上会使它变慢。使用常规数组迭代和比较，您的复杂度将为O（n），而进行排序时的复杂度将为O（nlogn）。相反，您可以尝试此。

static String greaterThan(int[] vectorCompare, int valueCompare)
   {
      List<Integer> list = new ArrayList<>();
      for (int value : vectorCompare)
      {
         if (valueCompare < value)
         {
            list.add(value);
         }
      }
         return list.toString();
   }

通过使用Arraylist，您将不必担心要返回的元素数。

Answer 3

可以通过以下方式完成：

    List<Integer> list = new ArrayList<>();
    list.add(2);
    list.add(1);
    list.add(4);
    list.add(6);
    list.add(7);

    int valToCompare = 4;
    List<Integer> result = find(list, valToCompare);

    private static List<Integer> find(List<Integer> list, int val) {
        return list.stream().filter(v -> v > val).collect(Collectors.toList());
    }

Answer 4

这几乎可以得到。这适用于数组。

   public static int[] greaterThan(int[] numbs, int max) {
      return Arrays.stream(numbs).parallel().filter(a -> a > max).toArray();
   }

您也可以对列表执行相同的操作。

   public static List<Integer> greaterThan(List<Integer> numbs, int max) {
      return numbs.parallelstream().filter(a -> a > max).collect(Collectors.toList());
   }

在两种情况下，列表或数组都转换为并行的值流。那些被过滤以仅允许那些大于最大通过管道的那些。然后将它们收集到List或数组中并返回。此特定任务适用于多线程中的并行操作，并且可以加快执行速度，尤其是在您的PC具有多个内核的情况下。

即使您是Java的新手，lambda和stream都是该语言的重要功能，应该学习。

更大的元素数组

4 个答案: