Java string matching expression String Array

Question

I am using Java, i need your opinion on how to write better code for the following task.

I have following String value

String testStr = "INCLUDES(ABC) EXCLUDES(ABC) EXCLUDES(ABC) INCLUDES(ABC) INCLUDES(ABC)"

I want to manipulate Strings and want to combine all INCLUDES statements into one INCLUDES and the result should be similar to the following:

INCLUDES(ABC,ABC, ABC) EXCLUDES(ABC, ABC)

Answer 1

i would break the initial string into new strings using this class: http://docs.oracle.com/javase/6/docs/api/java/util/StringTokenizer.html and put them in an array

start a new string, and then use the tokenizer to break out the part within the parentheses (you can set it to use ( and ) as delimiters) and loop through the array and concatenate them into the new string.

be aware though that any wrongly placed spaces (like INCLUDES( abc )) will mess it up

Answer 2

This seems like a reasonable approach:

1. Split the testStr using the StringUtils.split method; use " " or null as the token.
2. Create a Map<String, List<String>> . I will refer to that as theMap

3. For each string in the returned array perform the following:

   1. Split the string using "()" as the token.
   2. The returned array should have 2 elements. The first element (index 0) is key for theMap and the second element (index 1) is the value to add to the list.

Once you are done with the array returned from splitting testStr , build a new string by using the key value in theMap and appending the elements from the associated list into a string.

Apache StringUtils

Answer 3

I wrote a piece of code for this issue but i don't know if it's good or not

• according to your format ,you can split testStr by using " " ,the output will be like this: INCLUDES(ABC)

• check if this string contain INCLUDES or EXCLUDES

• then split it by using ( )

Like this :

    String testStr = "INCLUDES(ABC) EXCLUDES(C) EXCLUDES(ABC) INCLUDES(AC) INCLUDES(AB)";
    String s[] = testStr.split(" ");
    String INCLUDES = "INCLUDES( ";
    String EXCLUDES = "EXCLUDES ( ";
    for (int i = 0; i < s.length; i++) {
        if (s[i].contains("INCLUDES")) {
            INCLUDES += (s[i].substring(s[i].indexOf("(") + 1, s[i].indexOf(")"))) + "  ";
        }

        else if (s[i].contains("EXCLUDES")) {
            EXCLUDES += (s[i].substring(s[i].indexOf("(") + 1, s[i].indexOf(")"))) + "  ";
        }
    }
    INCLUDES = INCLUDES + ")";
    EXCLUDES = EXCLUDES + ")";
    System.out.println(INCLUDES);
    System.out.println(EXCLUDES);

Answer 4

I have wrote down small utility result as following

if text = "EXCLUDES(ABC) EXCLUDES(ABC) INCLUDES(BMG) INCLUDES(EFG) INCLUDES(IJK)";

output = EXCLUDES(ABC) EXCLUDES(ABC) INCLUDES(BMG & EFG & IJK)

Following is my java codeas following please take a look and if any one can improve it please feel free.

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.sun.xml.internal.ws.util.StringUtils;

/**
 * Created by IntelliJ IDEA.
 * User: fkhan
 * Date: Aug 31, 2012
 * Time: 1:36:45 PM
 * To change this template use File | Settings | File Templates.
 */


public class TestClass {


    public static void main(String args[]) throws Exception {

        //String text = "INCLUDES(ABC) EXCLUDES(ABC) EXCLUDES(ABC) INCLUDES(EFG) INCLUDES(IJK)";
        String text = "EXCLUDES(ABC) EXCLUDES(ABC) INCLUDES(BMG) INCLUDES(EFG) INCLUDES(IJK)";
        List<String> matchedList = findMatchPhrase("INCLUDES", text);
        String query = combinePhrase(text, "INCLUDES", matchedList);
        System.out.println(query);


    }

    /**
     * This method takes query combine and & multiple phrases
     * @param expression
     * @param keyword
     * @param matchedItemList
     * @return
     */
    private static String combinePhrase(String expression, String keyword, List<String> matchedItemList) {

        //if only one phrase found return value
        if(matchedItemList.isEmpty() || matchedItemList.size() ==1){
            return expression;
        }

        //do not remove first match
        String matchedItem = null;
        for (int index = 1; index < matchedItemList.size(); index++) {

            matchedItem = matchedItemList.get(index);

            //remove match items from string other then first match
            expression = expression.replace(matchedItem, "");
        }

        StringBuffer textBuffer = new StringBuffer(expression);

        //combine other matched strings in first matched item
        StringBuffer combineStrBuf = new StringBuffer();
        if (matchedItemList.size() > 1) {

            for (int index = 1; index < matchedItemList.size(); index++) {
                String str = matchedItemList.get(index);
                combineStrBuf.append((parseValue(keyword, str)));
                combineStrBuf.append(" & ");

            }
            combineStrBuf.delete(combineStrBuf.lastIndexOf(" & "), combineStrBuf.length());
        }

        // Inject created phrase into first phrase
        //append in existing phrase
        return injectInPhrase(keyword, textBuffer, combineStrBuf.toString());
    }

    /**
     *
     * @param keyword
     * @param textBuffer
     * @param injectStr
     */
    private static String injectInPhrase(String keyword, StringBuffer textBuffer, String injectStr) {
        Matcher matcher = getMatcher(textBuffer.toString());
        while (matcher.find()) {

            String subStr = matcher.group();
            if (subStr.startsWith(keyword)) {
                textBuffer.insert(matcher.end()-1, " & ".concat(injectStr));
                break;
            }

        }

       return textBuffer.toString();
    }

    /**
     * @param expression
     * @param keyword
     * @return
     */
    private static String parseValue(String keyword, String expression) {

        String parsStr = "";
        if (expression.indexOf(keyword) > -1) {
            parsStr = expression.replace(keyword, "").replace("(", "").replace(")", "");
        }

        return parsStr;
    }


    /**
     * This method creates matcher object
     * and return for further processing
     * @param expression
     * @return
     */
    private static Matcher getMatcher(String expression){
        String patternString = "(\\w+)\\((.*?)\\)";
        Pattern pattern = Pattern.compile(patternString);
        return pattern.matcher(expression);
    }
    /**
     * This method find find matched items by keyword
     * and return as list
     * @param keyword
     * @param expression
     * @return
     */
    private static List<String> findMatchPhrase(String keyword, String expression) {
        List<String> matchList = new ArrayList<String>(3);

        keyword = StringUtils.capitalize(keyword);
        Matcher matcher = getMatcher(expression);

        while (matcher.find()) {

            String subStr = matcher.group();
            if (subStr.startsWith(keyword)) {
                matchList.add(subStr);
            }
        }

        return matchList;
    }



}