Java 8 如何按组递增

有一个表，现在添加一个新列--

sort\u num int default 0

id  level   sort_num
1   1   0
2   1   0
3   2   0
4   2   0
5   2   0
6   3   0
7   3   0
8   3   0
9   3   0

现在我想设置sort_num值，如下所示

id  level   sort_num
1   1   1
2   1   2
3   2   1
4   2   2
5   2   3
6   3   1
7   3   2
8   3   3
9   3   4

实现上述需求的Java代码是

    int sortNum = 0;
    int currentLevel = fooList.get(0).getLevel();
    for (RuleConf foo : fooList) {
        if(currentLevel != foo.getLevel()){
            sortNum = 0;
            currentLevel = foo.getLevel();
        }
        foo.setSortNum(++sortNum);
    }

我想知道

Java8

是否可以简化上述代码

PS.使用

mysql

实现此要求

set @index:=0; update t set sort_num = (@index:=@index+1) where level = 1 order by id;
set @index:=0; update t set sort_num = (@index:=@index+1) where level = 2 order by id;
set @index:=0; update t set sort_num = (@index:=@index+1) where level = 3 order by id;

---

最好的方法是坚持您的普通增强for循环。我认为不可能提出一个单一的

流

解决方案，因为您需要中间值。比如：

Map<Integer, List<RuleConf>> levels = fooList.stream()
    .collect(Collectors.groupingBy(RuleConf::getLevel));
levels.values().forEach(v -> 
    IntStream.range(0, v.size()).forEach(i -> v.get(i).setSortNum(i + 1))
);

Map levels=dublist.stream（）
.collect（Collectors.groupingBy（RuleConf:：getLevel））；
levels.values（）.forEach（v->
IntStream.range（0，v.size（））.forEach（i->v.get（i）.setSortNum（i+1））
);

如果您自己跟踪下一个订单号，您可以使用一个流进行跟踪。此解决方案也是线程安全的，因此应使用并行流：

Map<Integer, AtomicInteger> orders = new ConcurrentHashMap<>();
fooList.stream().forEachOrdered(foo -> {
    orders.putIfAbsent(foo.getLevel(), new AtomicInteger());
    foo.setOrder(orders.get(foo.getLevel()).incrementAndGet());
});

Map orders=new ConcurrentHashMap（）；
愚人主义者.stream（）.forEachOrdered（foo->{
orders.putIfAbsent（foo.getLevel（），new AtomicInteger（））；
setOrder（orders.get（foo.getLevel（））.incrementAndGet（））；
});

---

它的性能应该优于其他流解决方案，因为它只需要迭代列表中的流。

如果您是指

stream

而不是

java8

，那么我会说不。因为有些状态依赖于已经看到的元素。@flwn:我不明白为什么我提供的解决方案依赖于任何顺序？还需要考虑

id

吗？因此，我应该将

forEach

更改为

forEachOrdered

，这会纠正解决方案，但牺牲性能（从未要求过）。