Java 爪哇8。使用收集器将值列表分组到范围列表中

我需要你的帮助

在使用收集器groupingBy的Java8中，我需要像这样对列表进行分组

ValueObject {id=1, value=2.0}
ValueObject {id=2, value=2.0}
ValueObject {id=3, value=2.0}
ValueObject {id=4, value=3.0}
ValueObject {id=5, value=3.0}
ValueObject {id=6, value=4.0}
ValueObject {id=7, value=4.0}
ValueObject {id=8, value=4.0}
ValueObject {id=9, value=4.0}
ValueObject {id=10, value=4.0}

在另一个像这样的

GroupedObject {from=1, to=3, value=2.0}
GroupedObject {from=4, to=5, value=3.0}
GroupedObject {from=6, to=10, value=4.0}

这些是我使用的对象的定义

public class ValueObject {

  private int id;
  private double value;

  public String getId() {
    return id;
  }

  public float getValue() {
    return value;
  }

  public void setValue(float value) {
    this.value = value;
  }

}

public class GroupedObject {

    private int from;
    private int to;
    private double value;

    public int getFrom() {
        return from;
    }

    public void setFrom(int from) {
        this.from = from;
    }

    public int getTo() {
        return to;
    }

    public void setTo(int to) {
        this.to = to;
    }

    public double getValue() {
        return value;
    }

    public void setValue(double value) {
        this.value = value;
    }

}

这就是我如何通过编程实现的

public class Service {

    public List<GroupedObject> groupToRange(List<ValueObject> list) {

        List<GroupedObject> filtered = new ArrayList<>();

        if (list.size() > 0) {

            ValueObject current = list.get(0);
            GroupedObject dto = new GroupedObject();
            dto.setValue(current.getValue());
            dto.setFrom(current.getId());

            for (int i = 0; i < list.size(); i++) {
                ValueObject vo = list.get(i);
                if (vo.getValue() != current.getValue()) {

                    dto.setTo(current.getId());
                    filtered.add(dto);

                    dto = new GroupedObject();
                    dto.setValue(vo.getValue());
                    dto.setFrom(vo.getId());
                    current = vo;

                } else {
                    current = vo;
                }
                if (i == list.size() - 1) {
                    dto.setTo(vo.getId());
                    filtered.add(dto);
                }
            }
        }
        return filtered;
    }

}

公共类服务{
公共列表组范围（列表列表）{
List filtered=new ArrayList（）；
如果（list.size（）>0）{
ValueObject current=list.get（0）；
GroupedObject dto=新的GroupedObject（）；
setValue（current.getValue（））；
setFrom（current.getId（））；
对于（int i=0；i

这是单元测试

public class ServiceTest {

    Service service = new Service();

    @Test
    public void testgGoupToRange() {

        List entryList = new ArrayList<>();

        entryList.add(new ValueObject(1, 2.0));
        entryList.add(new ValueObject(2, 2.0));
        entryList.add(new ValueObject(3, 2.0));
        entryList.add(new ValueObject(4, 3.0));
        entryList.add(new ValueObject(5, 3.0));
        entryList.add(new ValueObject(6, 4.0));
        entryList.add(new ValueObject(7, 4.0));
        entryList.add(new ValueObject(8, 4.0));
        entryList.add(new ValueObject(9, 4.0));
        entryList.add(new ValueObject(10, 4.0));

        List responseList = service.groupToRange(entryList);

        responseList.forEach(obj-> System.out.println(obj.toString()));

        assertNotNull(responseList);
        assertEquals(3, responseList.size());

    }

}

公共类服务测试{
服务=新服务（）；
@试验
public void testggouptrange（）{
List entryList=new ArrayList（）；
添加（新的ValueObject（1,2.0））；
添加（新的ValueObject（2,2.0））；
添加（新的ValueObject（3,2.0））；
添加（新的ValueObject（4,3.0））；
添加（新的ValueObject（5,3.0））；
添加（新的ValueObject（6,4.0））；
添加（新的ValueObject（7,4.0））；
添加（新的ValueObject（8,4.0））；
添加（新的ValueObject（9,4.0））；
添加（新的ValueObject（10,4.0））；
列表响应列表=service.groupToRange（entryList）；
responseList.forEach（obj->System.out.println（obj.toString（））；
assertNotNull（响应列表）；
assertEquals（3，responseList.size（））；
}
}

---

我还没有找到一种使用java 8和收集器的方法

List<ValueObject> values = Arrays.asList(new ValueObject(1, 2.0),
                                         new ValueObject(2, 2.0),
                                         new ValueObject(3, 3.0),
                                         new ValueObject(4, 4.0),
                                         new ValueObject(5, 4.0),
                                         new ValueObject(6, 4.0));
Map<Double, IntSummaryStatistics> groupedValues = values.stream()
                                                        .collect(Collectors.groupingBy(ValueObject::getValue,
                                                                                       Collectors.summarizingInt(ValueObject::getId)));

List<GroupedObject> groupedObjects = groupedValues.entrySet()
                                                  .stream()
                                                  .map(groupedValue -> new GroupedObject(groupedValue.getValue().getMin(),
                                                                                  groupedValue.getValue().getMax(),
                                                                                  groupedValue.getKey()))
                                                  .collect(Collectors.toList());
System.out.println(groupedObjects);

---

是的，你可以编写软件来做这件事。在把你的问题交给别人帮你解决之前，请投入最少的努力。对不起，我已经做了。但是我想知道是否有一种方法可以使用收集器groupingBy。提供的ValueObject定义无法编译。很抱歉，我已经修复了它。我也提供了单元测试。有一种方法只通过一次，但它不是那么简单（）。最好还是坚持下去。真的谢谢，这是一个非常好的方法，我一直在寻找。我添加了一个排序表达式，用于按顺序检索最后一个组。排序（Comparator.comparing（GroupedObject:：getFrom））

[GroupedObject{from=4, to=6, value=4.0}, GroupedObject{from=1, to=2, value=2.0}, GroupedObject{from=3, to=3, value=3.0}]