0

我有两个相同大小的 Sorted ArrayList，即team_A& team_B，其中比较 with 的每个元素team_A以team_B找到powerDiff > 0. 找到powerDiff大于 0 后，再从 中删除该元素team_B以减少下一个循环的迭代次数。

long calculateWin(){
    int wins = 0;
    int tempIndex=0;
    boolean flag = false;
    long powerDiff=0;

    for(int i=0; i<team_A.size(); i++) {

        for(int j=0; j<team_B.size(); j++) {

            powerDiff = team_A.get(i) - team_B.get(j);

            if(powerDiff>0) {
                wins++;
                tempIndex=j;
                flag=true;
                break;
            }

        }

        if(flag) {
            team_B.remove(tempIndex);
            flag = false;
        }

    }
    return wins;

}

上面的代码运行良好，但由于复杂性，我想使用 Java 8 的 Stream API 优化此代码。

4

3 回答 3

0

好的，让我们稍微理一下逻辑。

如果 a[i] > b[j]，则检查每一对。如果匹配，则删除 b[j]。
好的。long有一个总订单，所以，我们只需要它的最大值。

long max_a = team_a.stream().mapToLong(a -> a).max().getAsLong();

现在我们拥有了最强大的 A 队，我们检查一下他能打败多少人：

long wins = team_b.stream().filter(b -> a > b).count();

就是这样。

等待。我没有注意到您问题中的关键字“排序”。
这意味着我们可以进行二分查找。

首先我们得到最大值。我假设列表是按升序排列的。

long max_a = team_a.get(team_a.size()-1);

现在我们需要找到我们必须进行切割的地方：

int idx = Collections.binarySearch(team_b, max_a);

请注意，Collections.binarySearch如果最大值不在列表中，则可以返回负数。但我们只对列表中较小项目的数量感兴趣。

if (idx < 0)
    idx = -idx - 1

现在idx包含小于第一个列表中最大元素的元素数。返回：

return idx;
于 2020-04-16T15:16:41.130 回答
0

你能试试这个吗？

public static long calculateWinJava8(){
    List<Long> team_A = new ArrayList(Arrays.asList(50L,60L,70L,80L,90L,100L));
    List<Long> team_B = new ArrayList(Arrays.asList(30L,40L,25L,80L,55L,200L,250L));
    int wins = team_B.size();

    team_A.stream().forEach(itemA->{
         List<Long> removeItems = team_B.stream().filter(itemB-> (itemA-itemB)>0).collect(Collectors.toList());
         team_B.removeAll(removeItems);
    });

    System.out.println("result team_B : "+team_B.toString());
    wins = wins - team_B.size();
    System.out.println("wins : "+wins);
    return 0;
}
于 2020-04-16T11:36:01.067 回答
0

标准 JDK 没有一个好的方法，因为它缺少像 .zip() 运算符和 Tuple 类这样的基本结构。如果这样做，它看起来像这样：

val wins = team_a.zip(team_b)
                .filter { tuple -> tuple.first > tuple.second }
                .count()

那是 kotlin，但有大量提供 .zip() 和元组的 java 库。

如果你真的想只用 JDK 来做，它会是这样的：

long wins = IntStream
        .range(0, Math.min(team_a.size(), team_b.size()))
        .filter(i -> team_a.get(i) > team_b.get(i))
        .count();

这可行但并不理想，因为与第一个示例不同，您要到达管道之外。

于 2020-04-16T14:57:55.100 回答