分区流

Question

I am working with a Stream of Person data and I've run into a partitioning issue related to the data.

I have a Stream of data which I'll represent below in a table:

ID  Name Ticket IsEmployee
1   A      Y        Y
2   B     
3   C      Y
4   D

I am trying to return a List that is sorted by:

1. whether or not they're an Employee
2. if they have any Tickets
3. then by Name

I've looked into Collections.groupBy and Collections.partitioningBy , but so far haven't been able to come up withe the correct result.

My expectations are to return a list in the following order (by ID):

1   [name="A",Ticket="**[100,101]**", IsEmployee="**Y**"],
3   [name="C",Ticket="**[200,201]**", IsEmployee=""],
2   [name="**B**",Ticket="", IsEmployee=""],
4   [name="D",Ticket="", IsEmployee=""]

Any thoughts on how this might be accomplished without having to totally break apart the Stream?

Below is what my Person looks like:

public class Person {

   private long id;
   private String name;
   private List<Ticket> tickets;
   private String employeeType;  // This is just a 'Y'/'N' value.  This property has morphed into something else but I'm stuck using it.

   public long getId(){
    return id;
   }
   public String getName(){
    return name;
   }
   public List<Ticket> getTickets(){
    return tickets;
   }
   public String getEmployeeType(){
    return id;
   }
   // Setters are the exact same as getters, meaning I have no transient methods
}

Answer 1

Since you are saying “ I am trying to return a List that is sorted by …”, it's not clear why you started looking for grouping or partitioning, instead of aiming exactly at, what your problem description is about, get a List and sort it by your criteria:

// collect into a mutable List, if it isn’t a mutable List in the first place
List<Person> list=stream.collect(Collectors.toCollection(ArrayList::new));

// sort by your specified criterie (note: false < true)
list.sort(Comparator.comparing((Person p) -> !p.getEmployeeType().equals("y"))
                    .thenComparing(p -> p.getTickets().isEmpty())
                    .thenComparing(Person::getName) );

You can also specify the operation as part of the Stream operation, eg

List<Person> list=stream
    .sorted(               
        Comparator.comparing((Person p) -> !p.getEmployeeType().equals("y"))
                  .thenComparing(p -> p.getTickets().isEmpty())
                  .thenComparing(Person::getName) )
    .collect(Collectors.toList());

but there is no technical benefit. The Stream implementation has to collect the entire contents into a temporary buffer internally, to sort it before it is collected (ie copied) into the resulting List . The in-place sorting of ArrayList may get away with lesser or even without data copying (not that it matters for four elements, but in general).