标签: java-stream

我有一些 DTO 的链接哈希列表，其中包含 name （字符串）和 isActive （布尔）属性。我需要从头到尾迭代所有成员，并检查 isActive 中是否有任何成员具有错误值。当我找到这个元素时，我需要切断这个元素和列表的其余部分，并仅返回该元素之前的元素。

我想使用java流来解决这个问题。我尝试通过谓词使用流和过滤元素来检查元素是否处于活动状态，但这与我想要的逻辑不匹配。正如我所说，我需要找到第一个处于活动状态的元素，并将其及其后的所有内容从列表中删除。

如果我们在 LinkedHashSet<> 中有这个 ElementDto 列表

0 - name:test, isActive:true
1 - name:test2, isActive:true
2 - name:inActive, isActive:false
3 - name:activeAfterInactive, isActive:true

预期输出将是包含元素 0,1 的列表

我有一个可能重复的列表。我通过 ID 识别重复项。这些对象有子对象，现在我想合并重复项，以便子对象仅附加到一个对象。我如何最好地识别重复项，也许是通过流？

public class Foo {
  private String id;
  private Collection<String> childs;
}

  private Collection<Foo> mergeDuplicates(Collection<Foo> fooList) {
    /*this method should call the mergeChilds on found Duplicates,
    and return the processed Collection of Foos*/
  }

  private Foo mergeChilds(Foo foo1, Foo foo2) {
    ...
  }

我搜索了类似的问题，但我只发现了不适用于这种情况的对象字符串：

想要转换List<List<Integer>> list为int[][] array使用流

到目前为止我得到了这个：

int[][] array= list.stream().map(List::toArray)...

我以我发现的其他类似问题为基础。但这些使用 String 并且不能使其适用于 Integers->int：

// Example with String 1:    
String[][] array = list.stream()
        .map(l -> l.stream().toArray(String[]::new))
        .toArray(String[][]::new);

// Example with String 2:    
    final List<List<String>> list = ...;
    final String[][] array = list.stream().map(List::toArray).toArray(String[][]::new);

我有DTO一些属性，例如id、name、desc等。

它的所有属性都有 getter 和 setter。

我从服务中得到一个Page<MyDto>，我需要根据属性对 DTO 进行分组name。

首先，我使用转换Page<MyDto>为。List<MyDto>page.getContent

我需要通过使用对其进行分组来将其转换List为Map<String, Object> （不是Map<String,String>）。namesJava8

我找到了一些例子，但它们没有解决我的问题。

如何将MyDto列表分组到地图中？

其中键是名称 ( String)，值是Array<MyDto>每个名称的一个。

例如：

If `List<MyDto>` is : 
[
{"id":1, "name":"albert", "desc":"science"},
{"id":2, "name":"george", "desc":"econ"},
{"id":3, "name":"christ", "desc":"math"},
{"id":4, "name":"george", "desc":"literature"} // george repeats twice
]

输出Map应该是：

{

"george":

[
{"id":2, "name":"george", "desc":"econ"},
{"id":4, "name":"george", …

我正在尝试生成 a 的所有排列，List<List<String>>但我没有得到独特的排列。

我的List<List<String>>看起来像

[
 [Test, Test 1, Test 2],
 [Apple, Sandwich, Banana],
 [Cake, Ice Cream, Fruit]
] 

我试图List<String为父级中的每个组合提供所有可能的组合List<String>。因此，例如，第一个实例应该具有：

[Test, Test 1, Test 2]
[Test, Test 2, Test 1]
[Test 2, Test, Test 1]
[Test 2, Test 1, Test]
[Test 1, Test, Test 2]
[Test 1, Test 2, Test]

现在，我的尝试将只是迭代并重复元素而不更改顺序，因此[Test, Test 1, Test 2]只会重复父级的大小List<String>。这是我的方法。任何帮助表示赞赏：

List<List<String>> allPerms = parentList.stream().map(line -> parentList.stream()).flatMap(l -> l.filter(j -> !j.equals(l))).collect(Collectors.toList());

我有一个名为“foodList”的列表，其中包含“Food”类型的元素。对象 Food 包含一个名为“categories”、类型为“Category”的列表。

我目前正在实施一种搜索算法，通过排除某些类别来过滤食物。

排除的类别存储在名为“excludedCategories”的列表中。

如何使用 Java 8 和流，通过排除类别列表包含排除类别列表中任何元素的食物对象来过滤 foodList？

带循环的示例代码：

for (Food f: foodList)
{
     for (Category c: f.categories)
     {
          if (excludedCategories.contains(c))
          {
               // REMOVE ITEM FROM foodList
          }
     }
}

谢谢你！

是否可以使用 Streams 过滤器访问列表的索引？我的意思是...我知道可以使用循环（while、for 等）来做到这一点，但就好像列表在变成流时会丢失有关索引的信息。

我想是这样的：

list.stream().filter(x -> x > 100)
    .fiter(--getIndexOfEachValue--)
    .collect(Collectors.toList())

如果我有 List=[10,200,30,150,400,30]...

我期望结果=[1,3,4]

这UserMst是对象，users也是我从中获取 LoginId && TenantId 的列表。

LinkedHashMap<String, String> Tmap = users.stream().collect(Collectors.toMap(
                    UserMst::getLoginId, UserMst::getTenantId,
                        (x, y)-> ((x=="1") ? "Rocks" : (x=="2")
                                           ? "Mocks" : (x=="3")
                                           ? "Docs"  : (x=="4")
                                           ? "Pocks" : "")
                                   + " ,  " + ( (y=="1") ? "Rocks": (y=="2")
                                                         ? "Mocks": (y=="3")
                                                         ? "Docs" : (y=="4")
                                                         ? "Pocks": ""),
                        LinkedHashMap::new));


///////////////////

LinkedHashMap<String, String> Tmap =
    users.stream().collect(
        Collectors.toMap( UserMst::getLoginId, UserMst::getTenantId,
        (x, y)-> x + ", " + y, LinkedHashMap::new)); 

```

It gives output as answer:: …

我正在尝试编写一个函数来查找数组（1D）中任意两个元素之间的最大差异。我已经通过多种方式解决了（我在Java中应用）

1. 有2 个嵌套循环（有效，找到差异并取最大值）
2. 通过1 次循环迭代（有效，在返回它们的差值后找到最小值和最大值：（最大值 - 最小值））
3. 使用流两次（有效，使用流的 min() 和 max() 函数查找最大值和最小值并返回差值）。

现在的问题是：如何编写一个函数，使用1 个流来计算数组中任意 2 个元素之间的最大差异？

这是我写的最后一篇：

public static int maxDifference(int[] arr) {
    return Arrays.stream(arr).min().orElseThrow(NoSuchElementException::new) -
           Arrays.stream(arr).max().orElseThrow(NoSuchElementException::new);
}

有人告诉我 Java Stream 是处理大量数据的不错选择，我最近做了一个比较测试。然而测试结果却出人意料：

问题来自CodeWar：

假设有一个最初有100人的地铁，每一站都有几个人上车，也有几个人下车。目标是统计大量停靠站后留在地铁中的人数（100000）。

这是我的代码：

import java.util.ArrayList;

public class Metro1 {
    private final static int STOPS = 100000;
    private static ArrayList<int[]> metro = new ArrayList<int[]>();

    public static int sum1() {
        int sum = 0;
        for(int[] x: metro) {
            sum +=x[0] - x[1];
        }
        return sum;
    }

    public static int sum2() {
        return metro.stream()
                .mapToInt(x -> x[0]-x[1])
                .sum();
    }
    public static void main(String[] args) {
        long start=0;
        long end = 0;
        metro.add(new int[] {100,0});
        for(int i=1;i<STOPS;i++) {
            int in …