Little part of the string to integer parser vs Clean Code

Index = int

My first thought as I skimmed through your code was that you have a whole class that seems to be nothing more than a wrapper for an int. The only method of any significance is isInvalid() which could easily be moved to somewhere else or just inlined when needed. I think it would be best to remove this class and just use ints as indices.

KISS

I didn't read the rest of the code very thoroughly but it seems like a lot of code to solve a simple problem. I prefer the KISS methodology (keep it simple stupid) to complicated solutions. I'm sure if you tried to rewrite your code with simplicity as a goal, you could come up with something much smaller and simpler.

Here's an example of how you could simplify. You have this function:

private int parse(String substringContainingNumbersOnly)
{
    return Integer.parseInt(substringContainingNumbersOnly);
}

Notice that all it does is call another function. You could remove this function and replace the call to it with the call to Integer.parseInt directly. Now someone reading the code will know exactly what your code is doing when they read that line. With your current code, they would have to skip to the definition of parse to figure out what is happening, because the function name "parse" doesn't really explain what it does.

In fact many of your functions are one liners. Instead of having these one line functions which are mostly called from one place only, you could just put the one line in the calling function and add a comment about what is happening (if it isn't clear already). Right now, it almost seems like every line of code is a function call to a new function.

I have written another parser class doing exactly the same. However I think that it break SRP as it parses, iterates through string and checks if letters are numeric. Could someone involved in OOP say what does he think of it? I agree that wrapping Index in class was a mistake, but it lost modularity in my opinion. I also see duplication in two IntegerParser's methods however I'm not sure how to remove it. In the end I think this is much less open for adding new functionalities.

Main.java

public static void main(String[] Args)
{
        IntegerParser intparser = new IntegerParser();
        System.out.println(intparser.getFirstNumber( "lolo543" ));
}

IntegerParser.java

package intparser;

public class IntegerParser
{
    private String parsingText;
    private int startIndex;
    private int lastIndex;

    public int getFirstNumber(  String textToParse )
    {
        parsingText = textToParse;
        startIndex = getIndexOfFirstNumericChain(0);
        lastIndex = getIndexOfLastNumberInChain(startIndex);
        if ( startIndex == -1 )
            return -1;
        if ( lastIndex == -1 )
            lastIndex = parsingText.length();
        return Integer.parseInt( parsingText.substring(startIndex, lastIndex) );
    }

    private int getIndexOfFirstNumericChain( int index )
    {
        if ( index < 0 ) return -1;
        for ( int i = index; i < parsingText.length() ; i++ )
            if (numberAt(i)) return i;
        return -1;
    }

    private int getIndexOfLastNumberInChain( int index )
    {
        if ( index < 0 ) return -1;
        for ( int i = index; i < parsingText.length() ; i++ )
            if (!numberAt(i)) return i;
        return -1;
    }

    private boolean numberAt( int index )
    {
        char letter = parsingText.charAt(index);
        if (  letter >= '0' && letter <= '9' )
            return true;
        return false;
    }   
}

Focusing on IntegerFinder:

• findFirstNumber is returning the object referenced by the field index which is mutable and will be changed by later calls to IntegerFinder's methods. This can lead to serious and difficult-to-debug problems and will usually be reported by automated bug-finding programs. Return a copy of the index instead.
• The index field looks like it is reset every call to findFirstNumber. It is also set but the value is never used in letterIsANumber. Why is not not a local instance in findFirstNumber?
• letterIsANumber could just be written as return stringHasANumberAtIndex(text, currentIndex)
• letterIsANumber could probably be replaced with Character.isDigit(String.codePointAt(index.getValue()))

More generally

• Some of your classes look like procedures that have been split up into methods and single-use fields. I appreciate that you are experimenting with object-oriented thinking and may have future use in mind for IntegerSubstringer and IntegerFinder, but:
• Consider passing the text as a constructor argument to IntegerSearch if it is your intent for those objects to represent a state of parsing a string. Otherwise, move the fields into locals to indicate that you don't intend to track the state across (public) method calls.
• If you haven't already, write some JUnit tests for your class. It will help you ensure the code is correct and may help you come up with better interfaces to your classes.

From what I understand you want a simple program which for say input abc123 returns 123, so it extracts all integers from a String.

While your solution works, it really seems an over complication for such a simple task. You can do the same thing using regex in just a few lines

public static void main(String[] args) {
    final StringBuilder buffer = new StringBuilder();
    final String input = "ab123cxyz12xba2a4aaxy1";
    final Pattern p = Pattern.compile("\\d+"); //will look for numbers in the String; matches digits; same as [0-9]
    final Matcher m = p.matcher(input);
    while (m.find()) {
        buffer.append(m.group());
    }
    System.out.println(buffer.toString());
}

You can read and learn more about regex here