Same computational flow, but different functionalities

Question

Recently I wrote a small piece of code for my project need and the code works fine...

if (Utils.nullOrEmpty(string1))
    {
        Config config = getConfig();

        if (config != null)
        {
            doX();
        }
    }
    else
    {
        doY();
    }

    if (Utils.nullOrEmpty(string2))
    {
        Config config = getConfig();

        if (config != null)
        {
            doA();
        }
    }
    else
    {
        doB();
    }

I am not convinced the way it is written and I feel there is a scope for improvement to make it better........

Please give me some suggestions to make it better... Is there a scope to use lambdas ??.........

Answer 1

You could make an interface like :

interface Do {
    void doSometing();
}

Implement it :

class DoA implements Do {
    void doSometing() {/* do A  */} 
}

class DoB implements Do {
    void doSometing() {/* do B  */} 
}

(DoC.......DoD......etc)

And use it by :

if (someConditionX)   {
     process(string1, new DoA(), new DoB());
     process(string2, new DoC(), new DoD());
 }

where process is defined by:

void process(String string, Do doA, Do doB) {

    if(nullOrEmpty(string)){
        if (getConfig() != null) {doA.doSometing(); }   
    }else {
        doB.doSometing();
    }
}

As for using Lambda expression, you could implement the interface using Lambda:
process (string1, ()->{/* implement doSomething */;}, new DoB());

Answer 2

When you extract the common parts of the code, you get this:

void doSomething(String s, Runnable action, Runnable actionIfEmpty) {
    if (Utils.nullOrEmpty(s)) {
        Config config = getConfig();
        if (config != null) {
            actionIfEmpty.run();
        }
    } else {
        action.run();
    }
}

You would then use the above code like this:

doSomething(string1, this::doX, this::doY);
doSomething(string2, this::doA, this::doB);