如何使用 Java lambda 解决嵌套循环

Question

I have an object which uses 2 nested loops to find matching processes based on a pid. The goal is to collect all the processes which occur in tuple. A tuple is used to store 2 processes that have the same processName but different process pids. Processes are always spawned in pairs.

Here is a snippet of the class.

class Process{

  private String name;
  private String pid;
  private String processName;

   public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Process)) return false;
    Process that = (Process) o;
    return Objects.equals(pid , that.pid);
    etc...
 }

   class Tuple {
      Process parent;
      Process child;
      Tuple(Process first, Process second){
      }
   }

Here is how I process the list of orders:

  List<Process> processes..
  List<Tuple> tuples = new ArrayList<>();
  for( Process p0 : processes){
     for(Process p1 : processes){
        if(p0.processName.equals(p1.processName)){
          p1.pid != p0.pid;
          Tuple tp= new Tuple(p0, p1);
          tuples.add(tp);
        }
     } 

  }

How can I use a Lambda function to accomplish this in Java 12?

Answer 1

When you ask for "lambda function to accomplish this" , I believe your actually asking for how to do it using streams .

I'll assume that Tuple is a separate top-level class, or a static nested class, not an inner class, as it currently shows in the question.

List<Tuple> tuples = processes.stream()
        .flatMap(p0 -> processes.stream()
                .filter(p1 -> p0.getPid() != p1.getPid()
                           && p0.getProcessName().equals(p1.getProcessName()))
                .map(p1 -> new Tuple(p0, p1)))
        .collect(Collectors.toList());

For better performance, I would however suggest doing it like this:

List<Tuple> tuples2 = processes.stream()
        .collect(Collectors.groupingBy(Process::getProcessName))
        .values().stream()
        .filter(list -> list.size() > 1)
        .flatMap(list -> list.stream()
                .flatMap(p0 -> list.stream()
                        .filter(p1 -> p0.getPid() != p1.getPid())
                        .map(p1 -> new Tuple(p0, p1))
                )
        )
        .collect(Collectors.toList());

I hope you realize that all tuples will have mirrors, ie for every tuple(a,b) you're going to also have a tuple(b,a) . To prevent that, change the p0.getPid() != p1.getPid() conditions to p0.getPid() < p1.getPid() .