从字符串中解析重复组

Question

I'm currently taking in a string which is being dividing

20004=1~^20005=0~^773=~^665=~^453=3~^448=0A~!447=D~!452=1~!~^448=0A~!447=D~!452=17~!~^448=81~!447=D~!452=7~!~^11=1116744Pq2Q~^70=15040024-1~^793=MNL-?--1~^467=37878024-1~^60=20110617-05:57:31~^75=20110616~^768=1~^769=20110616-19:17:00~!770=1~!~^55=7800950~^48=AEP~^22=~^454=0~^460=5~^167=TCKR~^

The makeup of the string is such that ~^ divides attributes and ~. marks groups. Groups have an attribute preceding them which tells the number of repeating groups such like

453=3~^448=0A~!447=D~!452=1~!~^448=0A~!447=D~!452=17~!~^448=81~!447=D~!452=7~!~^

Where tag 453 denotes that there are 3 groups.

I was using a parse such as this:

    public Map<Integer, Object> parse(Object target)
{
    String[] elements = ((String) target).split(elementDilimiter);

    Map<Integer, Object> targetFields = new LinkedHashMap<Integer, Object>();

    for(int i=0; i<elements.length; i++)
    {
        String[] attributes = elements[i].split(attributeDelimiter);


        if(attributes.length != 2 || attributes[0].length() == 0 || attributes[1].length() == 0)
        {
            /*throw new ParsingException("Malformed element: " + element + ", expected: tag=value");*/
            continue;
        }
            targetFields.put(Integer.valueOf(attributes[0]), attributes[1]);
    }
    return targetFields;
}

Element delimiter = ~^ and Attribute delimiter = "="

So after the line:

String[] elements = ((String) target).split(elementDilimiter);

The Values are split as follows

453=3, 448=0A~!447=D~!452=1~!, 448=0A~!447=D~!452=17~!, 448=81~!447=D~!452=7~!,

These are then split on equals and placed within a map using the tagNo to return a the revelant object.

However when the groups get to:

String[] attributes = element.split(attributeDelimiter);

The groups go no further due to:

attributes.length != 2

But Ideally I would like my implementation to be able to grab the tag 453 realise there is 3 repeating groups, repeating groups go into a parser which will split them delimited on ~. and placed within a sub map.

Now I will be honest when I think of implementation my head starts to spin.

Is there a simple eligant solution around this or is it basic start from scratch.

EDIT

Is 453 defined to always be the identifier for the number of groups? yes the tag before the groups merely tells me how many groups there will be. I have no control of the incoming string or it's format it will take the form as above.

What do your groups represent - I ask this one because I would have thought attributes are together as part of groups, but in your method you split on attributes but not groups and you split on elements before attributes? I split the elements so that they can be separated as 453=3 etc however then this group business came in. So now I must rewrite to accomodate them too. This is in essence my problem before hand I had lovely tag values that mapped to a object and could be accessed simply via:

targetFields.get(TagNumber);

Now I will need to rewrite to enable accessibility to the groups!

I hope this cleared things a bit

Answer 1

Use String.split in two steps. First split the groups. The after split the attributes for each group.

It will solve your problem.

Answer 2

This code will parse out the groups/subgroups. You can replace the system.print statements with your map building. You may want to rethink the format, however, because it could be a lot clearer if you used a format that naturally supports nesting like XML

@Test
public void testname() throws Exception {
    parseText("453=3~^448=0A~!447=D~!452=1~!~^448=0A~!447=D~!452=17~!~^448=81~!447=D~!452=7~!~^");
}

private int subgroupLength = 0;

public void parseText(String text) {
    for (String group : text.split("~\\^")) {
        System.out.println("Group");
        parseGroup(group);
    }
}

public void parseGroup(String group) {
    for (String attribute : group.split("~!"))
        parseAttribute(attribute);
}

public void parseAttribute(String attribute) {
    String[] split = attribute.split("=");
    if (split.length != 2)
        return;

    if (split[0].equals("453")) {
        System.out.println("\tSubgroup length " + split[1]);
        subgroupLength = Integer.parseInt(split[1]);
    } else if (subgroupLength > 0) {
        subgroupLength--;
        System.out.println("\t\t" + split[0] + " = " + split[1]);
    } else
        System.out.println("\t" + split[0] + " = " + split[1]);
}