Danh sách phân vùng Java 8 thành các nhóm theo điều kiện liên quan đến các phần tử trước

Question

Giả sử tôi có một danh sách các khoảng thời gian (sắp xếp theo bắt đầu) và tôi muốn chia nhỏ chúng để tôi có danh sách các nhóm chồng chéo nhau. Vì vậy, ví dụ, với Interval như:

public class Interval { 
    private final int start; 
    private final int end; 

    public Interval(int start,int end){ 
     this.start = start; 
     this.end = end; 
    } 

    public int getStart(){return start;} 
    public int getEnd(){return end;} 

    public String toString(){ return "("+start+","+end+")"; } 
} 

Và một List<Interval> như:

[(0,4),(1,7),(6,10),(13,17),(20,100),(22,31),(60,65)] 

Tôi muốn có một sản lượng List<List<Interval>>:

[[(0,4),(1,7),(6,10)],[(13,17)],[(20,100),(22,31),(60,65)]] 

tôi có thể mã này lên, nhưng tôi thực sự thích cách tiếp cận chức năng hơn của Java 8, và muốn biết nếu có bất cứ điều gì giống như một cách thành ngữ để làm điều này bằng cách sử dụng các luồng Java 8.

Tôi đã xem kiểu "nhóm theo" được cung cấp Collectors, nhưng dường như chúng không áp dụng vì tôi không thực sự nhóm theo trình phân loại - bạn không thể tính toán các nhóm chỉ dựa trên một thuộc tính của từng phần tử riêng lẻ, bạn phải xem xét các thuộc tính của từng phần tử liên quan đến các nhóm đã được tính toán cho đến nay.

Chắc chắn có cách không điên rồ để làm điều này bằng các ngôn ngữ chức năng (mặc dù tôi nói như một người không thực sự là một lập trình viên chức năng :-)). Làm thế nào tôi có thể làm điều đó với các luồng trong Java 8?

Answer 1

Bạn không thể. Các luồng không phù hợp với loại sự cố này; các luồng không có khái niệm về "các phần tử trước" và được phép hoạt động trên các phần tử theo thứ tự tùy ý. Bạn có thể làm điều đó trong Java, chắc chắn, và bạn có thể làm điều đó bằng các ngôn ngữ chức năng, nhưng điều đó không có nghĩa là các luồng hoạt động giống như các cấu trúc dữ liệu ngôn ngữ chức năng mà bạn đã từng sử dụng.

Answer 2

Bạn đang tìm đúng nơi khi nghiên cứu các nhà sưu tầm groupingBy, nhưng bạn cũng đúng rằng họ sẽ không cung cấp logic cần thiết cho các khoảng thời gian hợp nhất. Nhưng chúng là các yếu tố kết hợp khái niệm vào trạng thái được tạo ra bởi các phần tử trước đó. Bạn phải tự mình thực hiện một bộ sưu tập tương tự.

Dựa vào đặc điểm kỹ thuật của bạn rằng các yếu tố đã presorted bởi chỉ số bắt đầu của họ, bạn có thể làm điều đó thích:

Comparator<Interval> byStart = Comparator.comparingInt(Interval::getStart); 
Comparator<Interval> byEnd = Comparator.comparingInt(Interval::getEnd); 
Collection<List<Interval>> merged = intervalList.stream().collect(
     () -> new TreeMap<Interval,List<Interval>>(byStart), 
     (map,i) -> { 
      Map.Entry<Interval,List<Interval>> e=map.floorEntry(i); 
      if(e!=null && Collections.max(e.getValue(), byEnd).getEnd()>=i.getStart()) 
       e.getValue().add(i); 
      else map.computeIfAbsent(i, x->new ArrayList<>()).add(i); 
     }, 
     (m1,m2) -> m2.forEach((i,list) -> { 
      Map.Entry<Interval,List<Interval>> e=m1.floorEntry(i); 
      if(e!=null && Collections.max(e.getValue(), byEnd).getEnd()>=i.getStart()) 
       e.getValue().addAll(list); 
      else m1.put(i, list); 
     }) 
    ).values(); 

này tạo ra một Collection chứ không phải là một List, nhưng bạn chỉ có thể tạo ra một List ra khỏi nó:

List<List<Interval>> list = new ArrayList<>(merged); 

bạn nên làm điều đó chắc chắn nếu bạn có ý định giữ kết quả trong một thời gian dài chứ không phải chế biến nó ngay lập tức, như Collection trở bởi người sưu tập là chế độ xem thành một tài khoản TreeMap có nhiều tài nguyên hơn mức cần thiết.

Tôi đoán, trong hầu hết các trường hợp, bạn nên sử dụng giải pháp dựa trên vòng lặp.