Substring Extract between an xml string java

If you are always going to be retrieving data between the same XML tags, then you don't need to worry about parsing it into a data structure. You had the right idea. If speed is what you're after, just grab the string inbetween the markers you know will be there.

Your way, though, is wasting some cycles.

textToExtract.substring(textToExtract.indexOf("=\"unicode\">"),textToExtract.indexOf("</F_TEXT>")).replaceFirst("=\"unicode\">", "");

Let's break this down:

// loops through the array until "=\"unicode\">" is found
int startIndex = textToExtract.indexOf("=\"unicode\">");
// loops through the array again, until "</F_TEXT>" is found
int endIndex = textToExtract.indexOf("</F_TEXT>");
//loop through the array, copying the bytes to a new array to form a new String
String substr = textToExtract.substring(startIndex,endIndex);
//loop through the array to find and replace "=\"unicode\">" with nothing
String data = substr.replaceFirst("=\"unicode\">", "");

You're looping through the same array a lot.

Once you know where the start point is, there is no need to search from the beginning again. Instead, start looking from that start point. Then, once you have the start point and end point of your substring, you can simply get it.

// we know what precedes the substring we want
String anchor = "<F_TEXT Encoding=\"unicode\">";
// so we use it to get the start point, looping once, up to that point
int start = textToExtract.indexOf(anchor)+anchor.length();
// we know the end point won't be before the start point, so start where it left off
int end = start;
// count each character from that point until the next XML tag starts
while (textToExtract.charAt(end) != '<') { end++; }
// now we have what we need to simply get the substring
String data = textToExtract.substring(start,end);

This will yield around a 60% performance increase.

Edit: For the sake of completion, let's address regex

Regex is amazing, and a lot of fun in scripts, but very inefficient for something like this. If you can avoid regex, do so. I tend to use it only to be "quick and dirty" - quick in terms of coding time rather than execution time. Have a read of how regex engines work. It's really interesting, but you'll see why it's a last resort.

    /* this pattern will look for the XML tag.
    ** then, it will match [^>]+
    ** [...] will match a single character that matches SOMETHING inside the "character class."
    ** [^...] will match a single character that is NOT something inside the character class.
    ** [^>]+ will match as many characters as it can that do not match '>'
    ** putting this expression inside brackets tells the engine we want to capture it to be referenced later.
    ** '<' at the end just ensures we capture up until that point.
    */
    // create the pattern
    Pattern pattern = Pattern.compile("<F_TEXT Encoding=\"unicode\">([^>]+)<");
    // get a matcher for it
    Matcher matcher = pattern.matcher(textToExtract);
    // if we find a match
    if (matcher.find()) {
        // we can use group(1) to refer to our first capture group
        // group(0) will always return the full string matched, but we don't want the tags.
        String data= matcher.group(1);

    }