Passing method in other method Java

Question

I want to make a simple program to compare how long time takes rewrite and print out collection of Strings by `for loop`, `foreach` or `stream`. String is sentence where it replaces "i" by "y". In my case I made `count()` where I set to count `stream()` method but I want to make universal measuring method. But i dont know how to do it... It should works like: in Main class is `counter(forLoop);` It should call `forLoop();` from Method class
`counter(forEach);` It should call `forEach();` from Metrod class
`counter(stream);` It should call ` stream();` From Method class

IDont know how to pass method as a parameter

I have class where are those metods:

import java.util.*;
import java.util.stream.*;

public class Methods {

    private List<String> sentence = new ArrayList<>();
    private String oldLetter = "i";
    private String newLetter = "y";

    private String methodType;

    public String getMethodType() {
        return methodType;
    }
//making a collection with String
    public void setSizeOfCollection(int size){
        for (int i = 0; i < size; i++) {
            sentence.add("Siti Zbinek plitce zvikal sirovi pelinek.");
        }
    }

    public void forLoop(){
        methodType = "For loop";
        for (int i = 0; i < sentence.size(); i++) {
            for (int j = 0; j < sentence.size(); j++) {
                String replaceLetters = sentence.get(j);
                replaceLetters = replaceLetters.replaceAll(oldLetter, newLetter);
                sentence.set(j, replaceLetters);
            }
            System.out.println(sentence.get(i));
        }
    }

    public void forEach(){
        methodType = "For each";
        String replacedLetters = "";
        for(String oneLine: sentence){
            for(String originalLetters: sentence){
                replacedLetters = originalLetters.replaceAll(oldLetter,newLetter);
            }
            System.out.println(replacedLetters);
        }
    }
    public void stream(){
        methodType= "Stream";
        sentence.stream()
                .map(e->e.replaceAll(oldLetter,newLetter))
                .collect(Collectors.toList())
                .forEach(System.out::println);
    }
}

This is count() that works fine, but only for method stream(). In comment is my imagine how it should be. But I dont know how it do by Java :(

import org.apache.commons.lang.time.*;
public class Counter {
     private Methods methods;
     private String methodType;
     private  StopWatch stopWatch = new StopWatch();
    long timeTaken = 0;

//here should be something like any method as a parameter XXX xxx
// public void count(Methods methods XXX xxx)

    public void count(Methods methods){
     stopWatch.start();

//   here sould be something what call any function by your choice, not only stream()
 //  methods.xxx; 

     methods.stream();

     stopWatch.stop();
     timeTaken= stopWatch.getTime();
     System.out.println(methods.getMethodType()+" takes "+ timeTaken + " ms." );
 }
}

And finally Main class

public class Main {
    public static void main(String[] args) {

        Methods methods = new Methods();
        Counter counter = new Counter();

        methods.setSizeOfCollection(10000);

        counter.count(methods);
//here should be finally three times method, with  different parameters:
//      counter.count(methods, forEach);
//      counter.count(methods, forLoop);
//      counter.count(methods, stream);

    }
}

Any advice please?

Answer 1

All your methods have the signature void(). Consequently, a reference to each method can be stored in a Runnable instance.

public void count(final Runnable method) {
    stopWatch.start();

    method.run();

    stopWatch.stop();
    timeTaken= stopWatch.getTime();
    System.out.println(methods.getMethodType()+" takes "+ timeTaken + " ms.");
}

And then call as:

final Methods methods = new Methods();
final Counter counter = new Counter();

methods.setSizeOfCollection(10000);

counter.count(methods::stream);  // or count(() -> methods.stream());
counter.count(methods::forEach); // count(() -> methods.forEach());
counter.count(methods::loop);    // count(() -> methods.loop());

To be able to use method refs or lambdas, you need to have at least Java 8. For earlier Java versions, you would need to implement Runnable with an anonymous class, e.g.

counter.count(new Runnable() {
  @Override public void run() { methods.stream(); }
});

or look up the methods by name via Reflection, but Reflection is usually the slowest option.

PS. Note however that your way of measuring method execution times is flawed; see How do I write a correct micro-benchmark in Java? for directions. This answer only explains the part of passing "methods" to another method.

Answer 2

you could pass the method name as a string and look for it with reflexion.