Problem with indexes, really stuck! Help!!

Question

Hi,
I am having a slight problem and don't know how to fix it.
I have a string with a list of numbers, eg
strA = "910111213...." and so on up to 22
I have a method that checks whether there is a word between the numbers and returns a string with the numbers separated by commas which works like this:
---- The first number 9 is passed to the method
---- It searches for the index of 9 in the string
---- Then gets the length of 9
-----The index of 9 is then added to the length to give the "equivalent" index of the next number in the string
----- Then the method gets the index of "9 + 1" i.e. the index of 10
---- A comparison is made between the the two indexes and if they are not equal, it means that there is a word between them
However here is where the problem is. If there is no word between the numbers I expect the method to return a string containing the numbers separated by commas i.e. 9,10,11, 12, 13 etc... However, the string that is returned does not contain the number 21 and this is my thinking of why;
since 21 actually occurs when transitioning from 12 to 13 .. i.e. "1213", as it would not return the correct index, since it would return an index of "6", instead of "23", so the method meets a stumbling block and is not sure of how to proceed, so does not return 21 in the string, so this is how I went about trying to solve that:
//originally i grab the indexes like this
String strA = "910111213141516171819202122"
int number ;  // number passed to the method
int nIndex = strA.indexOf(String.valueOf(number)); // get the index of the number in the string
// find next index using the previous index as the starting point
int nextIndex = strA.indexOf(String.valueOf(number + 1), nIndex);
// ideally I would think this would give me the result I expect that is
String rtnStrA = "9,10,11,12,13,14,15,16,17,18,19,20,21"  // method excludes the last as I don't need that one
// However, this is what I got
rtnStrA = "9,10,11,12,13,14,15,16,17,18,19,20"
// Here is where my hopeful solution begins. I first decided to make a special condition if "number = 21"
if(number == 21)
     int nextIndex = strA.lastIndexOf(String.valueOf(number + 1), nIndex); // hopefully this would return correct index of 23
// the returned string still did not include 21, so i next decided to add the difference 17 to the index, since due to "1213" it
was returning an index of "6".
// in the above if, I then add 17
nextIndex += 17;
// However still did not return the string with 21At this point I really do not know what else to do to get the returned string to include 21
Any help will be much appreciated....
Thanks

Answer 1

About the concept of mutable integer, I would be interested in learning more about utilising that concept and I would appreciate some insight from you.Having no pass by reference in Java, I was tempted to write one a couple of times, simple versions would be
class MutableInteger{
public int value;
}or just passing an int array of size 1.
Although I wished for it, I always came up with different solutions without the need for one, which I think are cleaner. Wrapping the method in a class so the integer can be a field variable would be one solution, many other times one can get rid of it by rethinking the logic.
The only times I do use arrays of size 1 is if I have to wrap a computation in a Runnable and need a result of that e.g. for returning. But this stems more from the problem that it needs to be final and mutable the same time.
int method() {
    final int[] returnValue = new int[] {0};
    someObject.syncExec(new Runnable(){
         public void run() {
              returnValue[0] = 10;
    return returnValue[0];
}In your case, you could make a class out of your method like
class NumberString {
     private final String numberString;
     private final int startNumber;
     private final int endNumber;
     private int currentIndex = 0; // it's now become a field variable, no need to pass it
     public NumberString(String numberString, int startNumber, int endNumber)
          this.numberString = numberString;
          this.startNumber = startNumber;
          this.endNumber= endNumber;
     public boolean hasNextNumber() {
          // are we finished?
     public boolean isNextNumberEmpty() {
          // your computation goes here
}So the state of your method is wrapped in an object rather than passing it every time (which looks more like a C construct):
public boolean emptyNumberString(int number, MutableInteger currentIndex)Although this is now more a statement against passing mutable integers, I hope you see my point and you can draw something useful out of it.