public class Calculator {

    interface IntegerMath {
        int operation(int a, int b);
    }

    public int operateBinary(int a, int b, IntegerMath op) {
        return op.operation(a, b);
    }

    public static void main(String... args) {

        Calculator myApp = new Calculator();
        IntegerMath addition = (a, b) -> a + b;
        IntegerMath subtraction = (a, b) -> a - b;
        System.out.println("40 + 2 = " +
            myApp.operateBinary(40, 2, addition));
        System.out.println("20 - 10 = " +

    private static Set<Class<?>> pullClasses(Class annotationFilter){
        Set<URL> urls = ClasspathHelper.forPackage("com.something.stuff");

        Reflections reflections = new Reflections(new ConfigurationBuilder()
                .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix("com.something.stuff")))
                .setUrls(urls)
                .setScanners(new TypeAnnotationsScanner())
        );

        return reflections.getTypesAnnotatedWith(annotationFilter);
    }

public static Generator generate(String key, String arg) throws ReflectiveOperationException{
    Constructor<?> con;
    for(Class<?> clazz : pullClasses(someString)){
        if(key.equals(clazz.getAnnotation(SomeString).value())){
            con = clazz.getDeclaredConstructor(String.class);
            return (Generator)con.invoke(arg);
        }
    }

    return null;
}

Pattern foo = Pattern.compile(".*(\\d+)\\s*(\\w+)");
Matcher bar = foo.matches(string);
// bar.group(1) is the digits
// bar.group(2) is the string

    Pattern foo = Pattern.compile(".*(\\d+)\\s*(\\w+)");
    Matcher bar = foo.matcher(arg);
    if(bar.matches()) {
        // bar.group(1) is digits
        // bar.group(2) is string
    }

Pattern foo = Pattern.compile(".*(\\d+)\\s*(\\w+)");
Matcher bar = foo.matcher("1234 ms");
if(bar.matches()) {
    // bar.group(1) is "1234"
    // bar.group(2) is "ms"
}