Java static build similar to IntStream

My aim is to provide a class to build a chain of functions to execute some task after. Here is what I could come up with so far

Function class

public class Loop {
    private final int from;
    private final int to;

    private Loop(int from, int to) {
        this.from = from;
        this.to = to;
    }

    public static Loop from(int from) {
        return new Loop(from, 0);
    }

    public static Loop to(int to) {
        return new Loop(0, to);
    }

    public void execute(Executable executable) {
        for (int i = from; i < to; i++) {
            executable.execute();
        }
    }
}

Executable interface

@FunctionalInterface
public interface Executable {
    void execute();
}

It can work for one parameter (from or to) like

Loop.to(10).execute(() -> {});

but I want it to work for multiple parameters like

Loop.from(5).to(10).execute(() -> {});

How can I achieve that? Also I am not sure if static from and static to methods fit in Loop class well with one redundant parameter.

It would be ideal to have static variant of from and non-static one of the same name, but that is not supported. Either the arguments or the name has to differ.

Therefore I would make the private constructor public and add a second no-args constructor so that the call could become:

new Loop().from(5).to(10).execute(...)
new Loop(5, 10).execute(...)

For that to work the from and to must no longer be static. Then you have to decide if the methods mutate the Loop instance they are invoked on or if they return a new object:

public Loop from(int from) {
    return new Loop(from, to);
}

public Loop to(int to) {
    return new Loop(from, to);
}

or

public Loop from(int from) {
    this.from = from; // no longer final
    return this;
}

public Loop to(int to) {
    this.to = to; // no longer final
    return this;
}

If you want to take this further you can rename the class to LoopBuilder and create a build() method that returns a Loop that has the fields as before, but no from and to methods, just the execute method:

public static class Loop {

    private final int from;
    private final int to;

    public Loop(int from, int to) {
        this.from = from;
        this.to = to;
    }

    public void execute(Executable executable) {
        for (int i = from; i < to; i++) {
            executable.execute();
        }
    }
    
    public static LoopBuilder builder() {
        return new LoopBuilder();
    }
}

public static class LoopBuilder {
    private int from;
    private int to;

    public LoopBuilder from(int from) {
        this.from = from;
        return this;
    }

    public LoopBuilder to(int to) {
        this.to = to;
        return this;
    }

    public Loop build() {
        return new Loop(from, to);
    }
}

The call would then become

Loop.builder().from(5).to(10).build().execute(...);

There are several approach one can take. The more sophisticated the solutions get, the more complex they get normally. Let us start with a simple solution.

public class Loop {
private final int from;
private final int to;
private Loop(Builder builder) {
this.from = builder.from();
this.to = builder.to();
}
public static Builder from(int from) {
return new Builder().from(from);
}
public static Builder to(int to) {
return new Builder().to(to);
}
public void execute(Runnable executable) {
for (int i = from; i < to; i++) {
executable.run();
}
}
public static class Builder {
private int from = 0;
private Integer to = null;
private Builder() {}
public Builder from(int from) {
this.from = from;
return this;
}
private int from() {
return from;
}
public Builder to(int to) {
this.to = to;
return this;
}
private int to() {
return to;
}
public void execute(Runnable runnable) {
Objects.requireNonNull(runnable);
new Loop(this).execute(runnable);
}
}
}

<kbd>Ideone demo</kbd>

This is already quite something. But we can, for example, call from(...) or to(...) multiple times. If we were to only allow one call to from(...) and after this only allow calls to to(...), then we need to define more types. We could achieve this by adding interfaces LoopFromSetBuilder, LoopToSetBuilder and LoopAllSetBuilder:

interface LoopFromSetBuilder {
LoopAllSetBuilder to(int to);
}
interface LoopToSetBuilder {
LoopAllSetBuilder from(int from);
}
interface LoopAllSetBuilder {
void execute(Runnable runnable);
}

Together with a little tweak in method Loop

class Loop {
...
public static LoopFromSetBuilder from(int from) {
return new Builder().from(from);
}
public static LoopToSetBuilder to(int to) {
return new Builder().to(to);
}
...
}

and letting Builder implement those interfaces:

    public static class Builder implements LoopFromSetBuilder, LoopToSetBuilder, LoopAllSetBuilder {
...
}

<kbd>Ideone demo</kbd>

We elimiate the possibility for the user to call from(...) and to(...) multiple times.

I have no further experience of building those "complex" fluent APIs, but I imagine that the process of building such an API can get quite painful. For small examples, as here, we might be able to deny setting the same variable mutliple times, but it seems pretty messy with more parameters (possible states - and thus - interfaces seem to be in the order of 2^n where n is the number of fields... so yeah.

If one upvotes my answer, one should also consider upvoting Luk2302's answer since the first solution of my answer is very similar with Luk2302's solution and Luk2302's answer was posted a little bit earlier than mine.