Better way to string parse ?

[Andrew Mcmurray]

Hi all ,

I have a 16 char string I need to parse into 4 substrings. The first substring needs to be the first 3chars, next needs to be the next 3 chars, and the last two are 5 chars each. Right now I am just using substring to break up the four. Like this:

string1 = bigString.substring(0,3);
string2 = bigString.substring(3,6);
...
...

Is there a better way to do this giving that the parse pattern is always going to be the same and the bigString length is never going to change?

Thanks,

AMD

[James Brown]

sorry i can't hava a better way. but i think you can chang a
string to a char[]
like these codes:

public void getStringParse(String str){
char[] c=str.toCharArray();
String newStr="";
for(int i=0;i<c.length;i++){
newStr+=c[i];
if(i%3==0){
System.out.println(newStr);
newStr="";
}

}

}

[Scott Johnson]

Andrew,

I believe that your solution is better. I can glance at your code and see exactly what you are trying to do. Yes, you have 4 lines of code that look the same, but so what.

"hi me"'s code is very obfuscated and will be difficult to maintain.

The programmers that have to review or maintain the code will thank you.

One enhancement I would make would be to replace your "magic numbers" with constants with meaningful names:

  
 
private static final int STRING1_START_POSITION = 0;
private static final int STRING2_START_POSITION = 3;
 
string1 = bigString.substring(STRING1_START_POSITION, STRING2_START_POSITION);
...
 
  

[James Brown]

hi Scott Johnson
i think you are right. do you have better way to slove the question.and use "String.substring()" is the best way ? thank you

[Jesper de Jong]

James, please read the JavaRanch official policy on registered names and change your display name: <first name>, <space>, <last name> please. Sorry, but just "James" is not good enough.

[Scott Johnson]

do you have better way to slove the question

I don't have a better solution than Andrew's. It's simple, fast and easy for a reviewer to understand.

[Stan James]

The substringing solution is clear enough. If the repetition bothers you, you could hide it in a special parsing class. I worked in another language (EASEL) with "skip" and "take" syntax something like...

StringThing s = new StringThing( input );
var1 = s.take(3);
var2 = s.take(3);
var3 = s.take(5);
var4 = s.take(5);

EASEL could also take up to a delimiter or pattern, and skip a number or a pattern. In Java this might fit best in a Stream concept. Does that look better or worse to you?
[ August 03, 2006: Message edited by: Stan James ]

[Adam Nace]

In my personal opinion, the only way to improve upon the substring version is to create a well named method out of it.

This provides 2 advantages:

1. It will make the code in the calling location clearer, because the name of the method will basically describe exactly what it does.

2. It will be re-usable.


For example:

[I]/**
 * breaks the provided [B]<code>[/B]String[B]</code>[/B] into several 
 * substrings, splitting it at the indicated break points.
 *
 * [B]@param[/B] s The [B]<code>[/B]String[B]<code>[/B] to be partitioned
 * [B]@param[/B] breakLocations the list of locations for the start of each
 * substring
 * [B]@return[/B] an array containing the partitions of the supplied [B] 
 * <code>[/B]String[B]</code>[/B]
 */[/I]
[B]public[/B] String[B][][/B] partitionString[B]([/B]String s, [B]int[/B] ... breakLocations[B]) {[/B]
 
  String [B][][/B] returnValue = [B]new[/B] String[B][[/B]breakLocations.length + [I]1[/I][B]][/B];
 
  [I]// Add the beginning and end positions of the string to the breakLocations[/I]
  [B]int[][/B] temp = breakLocations;
  breakLocations = [B]new int[[/B]temp.length + [I]2[/I][B]][/B];
  System.arraycopy[B]([/B]temp, [I]0[/I], breakLocations, [I]1[/I], temp.length[B])[/B];
  breakLocations[B][[/B][I]0[/I][B]][/B] = [I]0[/I];
  breakLocations[B][[/B]breakLocations.length - [I]1[/I][B]][/B] = s.length[B]()[/B];
 
  [B]for (int[/B] i = [I]0[/I]; [I]i[/I] < breakLocations.length - [I]1[/I]; [I]i[/I]++[B]) {[/B]
    returnValue[B][[/B]i[B]][/B] = s.substring[B]([/B]breakLocations[B][[/B]i[B]][/B], breakLocations[B][[/B]i + [I]1[/I][B]])[/B];
  [B]}[/B]
 
  [B]return[/B] returnValue;
[B]}[/B]

Then, at the point where you use the method, you simply do this:

String [B][][/B] myPartitions = partitionString[B]([/B]myString, [I]3[/I], [I]6[/I], [I]11[/I], [I]16[/I][B])[/B];

This would be the MOST clear way for the maintenance programmer to understand what that code was doing.

You could also write a variation that would use the length of each sub-string instead of the start positions, and compute the breakLocation values yourself.

- Adam
[ August 03, 2006: Message edited by: Adam Nace ]

[Andrew Mcmurray]

Cool thanks guys for your input

Andrew