的Java 8流 - 排序嵌套列表層次

Question

考慮下面的例子，我想這對列表進行排序，並嵌套列表

class Foo { 
    public int sort; 
    public List<Bar> bars; 
    public Foo(int sort) { 
     this.sort = sort; 
    } 

} 

class Bar { 
    public int sort; 

    public Bar(int sort) { 
     this.sort = sort; 
    } 
} 

@Test 
public void testSortering() { 
    Foo foo = new Foo(1); 
    Foo foo2 = new Foo(2); 
    Bar bar = new Bar(1); 
    Bar bar2 = new Bar(2); 
    foo.bars = Arrays.asList(bar2, bar); 
    foo2.bars = Arrays.asList(bar2, bar); 

    List<Foo> foos = Arrays.asList(foo2, foo); 

    //I would like to iterate foos and return a new foos sorted, and with bars sorted, so that this goes green 

    assertEquals(1, foos.get(0).sort); 
    assertEquals(1, foos.get(0).bars.get(0).sort); 
    assertEquals(2, foos.get(0).bars.get(1).sort); 
    assertEquals(2, foos.get(1).sort); 
    assertEquals(1, foos.get(1).bars.get(0).sort); 
    assertEquals(2, foos.get(1).bars.get(1).sort); 

} 

我已經試過這樣的流函數：

List<List<Bar>> foosSorted = foos.stream() 
     .sorted((o1, o2) -> Integer.compare(o1.sort, o2.sort)) 
     .map(f -> f.bars.stream().sorted((o1, o2) -> Integer.compare(o1.sort, o2.sort)).collect(Collectors.toList())) 
     .collect(Collectors.toList()); 

但這會返回Bar，而我想要一個Foo列表

Answer 1

List<Foo> foosSort = foos.stream() 
        .sorted((o1, o2) -> (o1.sort - o2.sort)) 
        .map(f -> { 
          List<Bar> bars = f.bars.stream() 
          .sorted((o1, o2) -> (o1.sort- o2.sort)) 
          .collect(Collectors.toList()); 
          f.bars = bars; 
          return f; 
        }) 
        .collect(Collectors.toList()); 

Answer 2

以下將對和bars分別排序foo，但由於peek操作正在變異f，如果涉及到並行性，這將會出現意想不到的行爲。

List<Foo> foosSorted = foos.stream() 
      .sorted(Comparator.comparingInt(o -> o.sort)) 
      .peek(f -> { 
       f.bars = f.bars.stream().sorted(Comparator.comparingInt(o -> o.sort)).collect(Collectors.toList()); 
      }) 
      .collect(Collectors.toList()); 

我所說的其實是爲你增添的Foo一個構造採取sort和bars和使用map代替peek。這樣，我們不會改變任何Foo對象，所以這可以並行運行而沒有麻煩。

List<Foo> foosSorted = foos.stream() 
      .sorted(Comparator.comparingInt(o -> o.sort)) 
      .map(f -> { 
       return new Foo(f.sort, f.bars.stream().sorted(Comparator.comparingInt(o -> o.sort)).collect(Collectors.toList())); 
      }) 
      .collect(Collectors.toList()); 

有：

class Foo { 
    public int sort; 
    public List<Bar> bars; 
    public Foo(int sort) { 
     this.sort = sort; 
    } 
    public Foo(int sort, List<Bar> bars) { 
     this.sort = sort; 
     this.bars = new ArrayList<>(bars); 
    } 
}