Parse String to array of Strings while treating quoted values as single element : String Parser « Data Type « Java

Home
Java
1.2D Graphics GUI
2.3D
3.Advanced Graphics
4.Ant
5.Apache Common
6.Chart
7.Class
8.Collections Data Structure
9.Data Type
10.Database SQL JDBC
11.Design Pattern
12.Development Class
13.EJB3
14.Email
15.Event
16.File Input Output
17.Game
18.Generics
19.GWT
20.Hibernate
21.I18N
22.J2EE
23.J2ME
24.JavaFX
25.JDK 6
26.JDK 7
27.JNDI LDAP
28.JPA
29.JSP
30.JSTL
31.Language Basics
32.Network Protocol
33.PDF RTF
34.Reflection
35.Regular Expressions
36.Scripting
37.Security
38.Servlets
39.Spring
40.Swing Components
41.Swing JFC
42.SWT JFace Eclipse
43.Threads
44.Tiny Application
45.Velocity
46.Web Services SOA
47.XML
Java » Data Type » String Parser 




Parse String to array of Strings while treating quoted values as single element
      
/*
 * Copyright (c) 2003 - 2007 OpenSubsystems s.r.o. Slovak Republic. All rights reserved.
 
 * Project: OpenSubsystems
 
 * $Id: StringUtils.java,v 1.14 2007/02/20 04:08:10 bastafidli Exp $
 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License. 
 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 */

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.StringTokenizer;

/**
 * Utility methods for String manipulation.
 
 @version $Id: StringUtils.java,v 1.14 2007/02/20 04:08:10 bastafidli Exp $
 @author Peter Satury
 * @code.reviewer Miro Halas
 * @code.reviewed 1.11 2006/04/29 00:24:18 jlegeny
 */
public final class StringUtils {
  // Constants ////////////////////////////////////////////////////////////////

  /**
   * Constant for assigning
   */
  public static final String EMPTY_STRING = "";

  /**
   * Constant for assigning
   */
  public static final String COMMA_STRING = ",";

  /**
   * Keep the original case of the string;
   */
  public static final int CASE_ORIGINAL = 0;

  /**
   * Convert the string to upper case.
   */
  public static final int CASE_TOUPPER = 1;

  /**
   * Convert the string to lower case.
   */
  public static final int CASE_TOLOWER = 2;

  // Constructors /////////////////////////////////////////////////////////////

  /**
   * Private constructor since this class cannot be instantiated
   */
  private StringUtils() {
    // Do nothing
  }

  // Public methods ///////////////////////////////////////////////////////////

  /**
   * Count number of occurences of lookup in text.
   
   @param text -
   *          text to search in for occurences of lookup
   @param lookup -
   *          character to count
   @return int - number of occurences of lookup in text.
   */
  public static int count(String text, char lookup) {
    int iCount = 0;

    if (text != null) {
      int iIndex = text.indexOf(lookup);

      while (iIndex != -1) {
        iCount++;
        iIndex = text.indexOf(lookup, iIndex + 1);
      }
    }

    return iCount;
  }

  /**
   * Parse textual representation of fraction to a floating point number
   
   @param textToParse -
   *          in the form "any_text whole_part quotient/divisor any_text"
   @param defaultValue -
   *          if the test is unparsable, what default value to return
   @param bIgnoreRest -
   *          if true, this will ignore the rest of the string (any_other_text)
   *          after the fraction, if false then the whole string is considered
   @return double - number coresponding to the fraction
   */
  public static double parseFraction(String textToParse, double defaultValue, boolean bIgnoreRest) {
    double parsed = defaultValue;
    int iLength;
    int iIndex;
    int iIndexStart;
    int iIndexEnd;
    int iNumber;

    // lets use "xxxxxxx 123 456 / 789 yyyyy" as example or
    // lets use "xxxxxxx 123 / 789 yyyyy" as example

    iIndexStart = 0;
    iLength = textToParse.length();
    if (bIgnoreRest) {
      // Skip while not number
      while ((iIndexStart < iLength&& (!Character.isDigit(textToParse.charAt(iIndexStart)))) {
        iIndexStart++;
      }
      // We skiped "xxxxxxx", iIndexStart is at "123 456 / 789 yyyyy"
    }

    // We should be at first digit
    if (iIndexStart < iLength) {
      // Find end of the number
      iIndex = iIndexStart;
      while ((iIndex < iLength&& (Character.isDigit(textToParse.charAt(iIndex)))) {
        iIndex++;
      }
      iIndexEnd = iIndex;
      // We skiped "123", iIndexStart is at "123 456 / 789 yyyyy"
      // iIndexEnd is at " 456 / 789 yyyyy"

      if (iIndexStart != iIndexEnd) {
        // There was at least some digits
        iNumber = Integer.parseInt(textToParse.substring(iIndexStart, iIndexEnd));
        // iNumber is 123

        // There was at least one digit, now is it whole part or quotient?
        // Skip spaces
        while ((iIndex < iLength)
            && ((textToParse.charAt(iIndex== ' '|| (textToParse.charAt(iIndex== '-'))) {
          iIndex++;
        }
        // We skiped "123", iIndex is at "456 / 789 yyyyy"

        // Now we have stopped because of 2 things, we either reached end of
        // string or we have found something other than space, if it is /
        // then it was qoutient, if it is digit, then it was whole part
        if (iIndex == iLength) {
          // it was a whole part and we are done
          parsed = iNumber;
        else {
          int iQuotient = 0;
          int iDivisor = Integer.MAX_VALUE;

          if (Character.isDigit(textToParse.charAt(iIndex))) {
            int iWholePart = 0;

            // it was a whole part and we continue to look for the quotient
            iWholePart = iNumber;

            // Find end of the number
            iIndexStart = iIndex; // Remember start
            while ((iIndex < iLength&& (Character.isDigit(textToParse.charAt(iIndex)))) {
              iIndex++;
            }
            iIndexEnd = iIndex;
            // We skiped "456", iStartIndex is at "456 / 789 yyyyy"
            // And iIndexEnd is at " / 789 yyyyy"

            iQuotient = Integer.parseInt(textToParse.substring(iIndexStart, iIndexEnd));
            // iQuotient is 456

            // Skip spaces
            while ((iIndex < iLength&& (textToParse.charAt(iIndex== ' ')) {
              iIndex++;
            }
            // And iIndex is at "/ 789 yyyyy"

            if (textToParse.charAt(iIndex== '/') {
              // It was a quotient and we continue to look for divisor

              iIndexStart = iIndex + 1;
              while ((iIndexStart < iLength&& (textToParse.charAt(iIndexStart== ' ')) {
                iIndexStart++;
              }
              // And iIndexStart is at "789 yyyyy"

              // We should be at next digit
              if (iIndexStart < iLength) {
                // Find end of the number
                iIndex = iIndexStart;
                while ((iIndex < iLength&& (Character.isDigit(textToParse.charAt(iIndex)))) {
                  iIndex++;
                }
                iIndexEnd = iIndex;
                // We skiped "789", iStartIndex is at "789 yyyyy"
                // And iIndexEnd is at " yyyyy"

                if (iIndexStart != iIndexEnd) {
                  iDivisor = Integer.parseInt(textToParse.substring(iIndexStart, iIndexEnd));
                  // iDivisor is 789
                  if (iDivisor != 0) {
                    if (iIndexEnd == iLength) {
                      // And we are at the end of the string
                      parsed = ((double) (iWholePart))
                          (((doubleiQuotient((doubleiDivisor));
                    else {
                      if (bIgnoreRest) {
                        // And we can ignore what is after
                        parsed = ((double) (iWholePart))
                            (((doubleiQuotient((doubleiDivisor));
                      else {
                        // there was something else we don't know what so
                        // return the default value
                      }
                    }
                  }
                else {
                  // The divisor is missing, return default value
                }
              else {
                // The divisor is missing, return default value
              }
            else {
              // The divisor is missing, return default value
            }
          else {
            if (textToParse.charAt(iIndex== '/') {
              // And iIndex is at "/ 456 yyyyy"

              // It was a quotient and we continue to look for divisor
              iQuotient = iNumber;
              // iQuotient is 123

              iIndexStart = iIndex + 1;
              while ((iIndexStart < iLength&& (textToParse.charAt(iIndexStart== ' ')) {
                iIndexStart++;
              }
              // And iIndexStart is at "456 yyyyy"

              // We should be at next digit
              if (iIndexStart < iLength) {
                // Find end of the number
                iIndex = iIndexStart;
                while ((iIndex < iLength&& (Character.isDigit(textToParse.charAt(iIndex)))) {
                  iIndex++;
                }
                iIndexEnd = iIndex;
                // We skipped "456", iIndexStart is at "456 yyyyy"
                // iIndexEnd is at " yyyyy"

                if (iIndexStart != iIndexEnd) {
                  iDivisor = Integer.parseInt(textToParse.substring(iIndexStart, iIndexEnd));
                  // iDivisor is 456

                  if (iDivisor != 0) {
                    if (iIndexEnd == iLength) {
                      // And we are at the end of the string
                      parsed = ((doubleiQuotient((doubleiDivisor);
                    else {
                      if (bIgnoreRest) {
                        // And we can ignore what is after
                        parsed = ((doubleiQuotient((doubleiDivisor);
                      else {
                        // there was something else we don't know what so
                        // return the default value
                      }
                    }
                  }
                else {
                  // The divisor is missing, return default value
                }
              else {
                // The divisor is missing, return default value
              }
            else {
              // It was a whole part and there is something else
              if (bIgnoreRest) {
                // and we are done
                parsed = iNumber;
              else {
                // there was something else we don't know what so
                // return the default value
              }
            }
          }
        }
      }
    }

    return parsed;
  }

  /**
   * Parse String to array of Strings while treating quoted values as single
   * element.
   
   @param strParse -
   *          String to parse
   @param strDel -
   *          String deliminer
   @param bAllowSingleQuote -
   *          single qoutes such as ' can be used to group value
   @param bAllowDoubleQuote -
   *          double quote such as " can be used to group value
   @return String[] - parsed list
   @throws OSSInvalidDataException -
   *           error during parsing
   */
  public static String[] parseQuotedStringToStringArray(String strParse, String strDel,
      boolean bAllowSingleQuote, boolean bAllowDoubleQuotethrows Exception {
    String[] arrayStrings;

    if (strParse == null) {
      arrayStrings = null;
    else {
      List lstElements = new ArrayList();
      int iCurrentIndex = 0;
      int iNextIndex;
      int iDelLength = strDel.length();
      int iParseLength = strParse.length();

      while (iCurrentIndex < iParseLength) {
        if ((bAllowSingleQuote&& (strParse.charAt(iCurrentIndex== '\'')) {
          // Find next single quote and treat the things in the middle as
          // single element
          iNextIndex = strParse.indexOf('\'', iCurrentIndex + 1);
          if (iNextIndex == -1) {
            throw new Exception("Incorrect input. " + strParse
                " No single quote following the one" " at location " + iCurrentIndex);
          }
          lstElements.add(strParse.substring(iCurrentIndex + 1, iNextIndex));
          iCurrentIndex = iNextIndex + 1;
          if (strParse.substring(iCurrentIndex).startsWith(strDel)) {
            iCurrentIndex += iDelLength;
          }
        else if ((bAllowDoubleQuote&& (strParse.charAt(iCurrentIndex== '"')) {
          // Find next double quote and treat the things in the middle as
          // single element
          iNextIndex = strParse.indexOf('"', iCurrentIndex + 1);
          if (iNextIndex == -1) {
            throw new Exception("Incorrect input. " + strParse
                " No double quote following the one" " at location " + iCurrentIndex);
          }
          lstElements.add(strParse.substring(iCurrentIndex + 1, iNextIndex));
          iCurrentIndex = iNextIndex + 1;
          if (strParse.substring(iCurrentIndex).startsWith(strDel)) {
            iCurrentIndex += iDelLength;
          }
        else {
          // Find next separator and treat the things in the middle as
          // single element
          iNextIndex = strParse.indexOf(strDel, iCurrentIndex);
          if (iNextIndex == -1) {
            // No other delimiter found so take the rest of the string
            lstElements.add(strParse.substring(iCurrentIndex));
            iCurrentIndex = iParseLength;
          else {
            lstElements.add(strParse.substring(iCurrentIndex, iNextIndex));
            iCurrentIndex = iNextIndex + iDelLength;
          }
        }
      }
      arrayStrings = (String[]) lstElements.toArray(new String[lstElements.size()]);
    }

    return arrayStrings;
  }

  /**
   * Parse String to array of integers.
   
   @param strParse -
   *          String to parse
   @param strDel -
   *          String deliminer
   @return int[] - parsed list
   @throws OSSException -
   *           error during parsing
   */
  public static int[] parseStringToIntArray(String strParse, String strDelthrows Exception {
    int[] arrayInts;
    try {
      if (strParse == null) {
        arrayInts = null;
      else {
        // TODO: Performance: Memory vs speed, here we allocate list and then
        // another array, how about just counting the number of elements
        // and then allocating array and parsing directly to array without
        // the extra list and copying from list to array?
        List lstInts = parseStringToList(strParse, strDel);

        if (lstInts == null || lstInts.size() 1) {
          arrayInts = null;
        else {
          Iterator items;
          int iCount;

          arrayInts = new int[lstInts.size()];
          for (iCount = 0, items = lstInts.iterator(); items.hasNext();) {
            arrayInts[iCount++= Integer.parseInt(((Stringitems.next()).trim());
          }
        }
      }
    catch (NumberFormatException eExc) {
      throw new RuntimeException("Problems with parsing String to array of int.", eExc);
    }
    return arrayInts;
  }

  /**
   * Parse String to array of Integers.
   
   @param strParse -
   *          String to parse
   @param strDel -
   *          String deliminer
   @return Integer[] - parsed list
   @throws OSSException -
   *           error during parsing
   */
  public static Integer[] parseStringToIntegerArray(String strParse, String strDel)
      throws Exception {
    Integer[] arrayInts;
    try {
      if (strParse == null) {
        arrayInts = null;
      else {
        // TODO: Performance: Memory vs speed, here we allocate list and then
        // another array, how about just counting the number of elements
        // and then allocating array and parsing directly to array without
        // the extra list and copying from list to array?
        List strInts = parseStringToList(strParse, strDel);

        if (strInts == null || strInts.size() 1) {
          arrayInts = null;
        else {
          arrayInts = new Integer[strInts.size()];
          for (int iCount = 0; iCount < strInts.size(); iCount++) {
            arrayInts[iCount= Integer.valueOf((StringstrInts.get(iCount));
          }
        }
      }
    catch (NumberFormatException eExc) {
      throw new RuntimeException("Problems with parsing String to array of int.", eExc);
    }
    return arrayInts;
  }

  /**
   * Parse String to array of Strings.
   
   @param strParse -
   *          String to parse
   @param strDel -
   *          String deliminer
   @return String[] - parsed list
   */
  public static String[] parseStringToStringArray(String strParse, String strDel) {
    String[] arrayStrings;

    if (strParse == null) {
      arrayStrings = null;
    else {
      // TODO: Performance: Memory vs speed, here we allocate list and then
      // another array, how about just counting the number of elements
      // and then allocating array and parsing directly to array without
      // the extra list and copying from list to array?
      List lstStrings = parseStringToList(strParse, strDel);

      if ((lstStrings == null|| (lstStrings.isEmpty())) {
        arrayStrings = null;
      else {
        arrayStrings = (String[]) lstStrings.toArray(new String[lstStrings.size()]);
      }
    }

    return arrayStrings;
  }

  /**
   * Parse array of integers to String.
   
   @param arrParse -
   *          int array to parse
   @param strDel -
   *          String deliminer
   @return String - parsed array
   */
  public static String parseIntArrayToString(int[] arrParse, String strDel) {
    StringBuffer strbInts = new StringBuffer();
    if ((arrParse != null&& (arrParse.length > 0)) {
      for (int iCount = 0; iCount < arrParse.length; iCount++) {
        if (iCount > 0) {
          strbInts.append(strDel);
        }
        strbInts.append(arrParse[iCount]);
      }
    }
    return strbInts.toString();
  }

  /**
   * Parse collection of objects to String by calling toString on each element.
   
   @param colObjects -
   *          collection of data objects to parse
   @param strDel -
   *          String deliminer
   @return String - parsed array
   */
  public static String parseCollectionToString(Collection colObjects, String strDel) {
    StringBuffer strbInts = new StringBuffer();
    if ((colObjects != null&& (!colObjects.isEmpty())) {
      for (Iterator items = colObjects.iterator(); items.hasNext();) {
        if (strbInts.length() 0) {
          strbInts.append(strDel);
        }
        strbInts.append(items.next().toString());
      }
    }
    return strbInts.toString();
  }

  /**
   * Parse String to List.
   
   @param strParse -
   *          String to parse
   @param strDel -
   *          String deliminer
   @return List - parsed list of items in the string delimtied by delimiter
   */
  public static List parseStringToList(String strParse, String strDel) {
    return (ListparseStringToCollection(strParse, strDel, false, CASE_ORIGINAL, null);
  }

  /**
   * Parse String to ANY collection you specify and trim each item.
   
   @param strParse -
   *          String to parse
   @param strDel -
   *          String deliminer
   @param container -
   *          if specified then it will be filled with items (it WILL NOT be
   *          emptied first). If this is null, the default collection will be
   *          allocated. This allows you here to pass list or set so this method
   *          is more flexible.
   @param bTrim -
   *          should it be trimmed or not
   @param iConvertCase -
   *          how to convert the case of the string - one of the CASE_XXX
   *          costants
   @return Collection - parsed collection, if container was specified, the
   *         same object will be returned. If it was not specified default
   *         object will be returned. If strParse was not null, then this will
   *         be not null.
   */
  public static Collection parseStringToCollection(String strParse, String strDel, boolean bTrim,
      int iConvertCase, Collection container) {
    Collection colReturn;

    if (strParse == null || strParse.length() 1) {
      if (container != null) {
        colReturn = container;
      else {
        colReturn = null;
      }
    else {
      // TODO: Performance: StringTokenizer is considered to be slow
      // because it creates lots of objects internally, consider replacing
      // this with String.indexOf(delimiter)
      StringTokenizer strTokParse = new StringTokenizer(strParse, strDel);
      String strTemp;

      if (container == null) {
        // This has to be List since parseStringToList requires it
        colReturn = new ArrayList();
      else {
        container.clear();
        colReturn = container;
      }

      if (strParse.startsWith(strDel)) {
        // If the string starts with the delimiter, tokenizer would skip it
        // but we have to have empty element in front
        colReturn.add("");
      }

      while (strTokParse.hasMoreTokens()) {
        strTemp = (StringstrTokParse.nextToken();
        if (bTrim) {
          strTemp = strTemp.trim();
        }
        switch (iConvertCase) {
        case (CASE_ORIGINAL){
          // do nothing
          break;
        }
        case (CASE_TOUPPER){
          strTemp = strTemp.toUpperCase();
          break;
        }
        case (CASE_TOLOWER){
          strTemp = strTemp.toLowerCase();
          break;
        }
        default{
          assert false "Incorrect case specification.";
        }
        }
        colReturn.add(strTemp);
      }
    }
    return colReturn;
  }

  /**
   * Method to limit String length for display and add '...' to the end
   
   @param limitLength -
   *          limit of length
   @param strValue -
   *          String to limit
   @return String - limited String
   */
  public static String limitStringLength(int limitLength, String strValue) {
    StringBuffer sbReturn = new StringBuffer();

    if ((limitLength > 0&& (strValue.length() > limitLength)) {
      // If limit length is lower then 5 we will do just exact substring
      if (limitLength < 5) {
        sbReturn.append(strValue.substring(0, limitLength));
      }
      // If limit length is lower then 15 and higher then 4 we will
      // return substring of (limit - 3) and '...'
      else if (limitLength < 15) {
        sbReturn.append(strValue.substring(0, limitLength - 3));
        sbReturn.append("...");
      }
      // If limit length is higher then 15 we will try to find
      // some space ' ' near before limit and cut string there
      else {
        // if we will not find ' ' near before limit
        // we will return substring of (limit - 3) and '...'
        if ((strValue.indexOf(" ", limitLength - 12(limitLength - 4))
            || (strValue.indexOf(" ", limitLength - 120)) {
          sbReturn.append(strValue.substring(0, limitLength - 3));
          sbReturn.append("...");
        }
        // if we will find ' ' near before limit
        // we will return substring until ' ' and ' ...'
        else {
          sbReturn.append(strValue.substring(0, strValue.indexOf(" ", limitLength - 12)));
          sbReturn.append(" ...");
        }
      }
    else {
      sbReturn.append(strValue);
    }

    return sbReturn.toString();
  }

  /**
   * Method to remove comma from start and from end of the string for examples
   * to use it as parameter to SQL IN operator
   
   @param strToRemoveFrom -
   *          String to remove comma from
   @return String - string with removed commas from the start and end of the
   *         string
   */
  public static String removeComma(String strToRemoveFrom) {

    // we have to remove comma from start and from end of the string
    // because then it can be used for SQL IN operator
    if (strToRemoveFrom.length() 2) {
      strToRemoveFrom = strToRemoveFrom.substring(1, strToRemoveFrom.length() 1);
    else {
      strToRemoveFrom = "";
    }

    return strToRemoveFrom;
  }

  /**
   * Concat all the specified strings to a single one
   
   @param strings -
   *          strings to concat, all null and empty ones will be ignored
   @param separator -
   *          separator to put in between the string elements
   @param quote -
   *          quote string to put around string elements, if null nothing will
   *          be put around them
   @return String with concatenated inputs
   */
  public static String concat(String[] strings, String separator, String quote) {
    StringBuffer output = new StringBuffer();

    if (strings != null) {
      int iIndex;
      boolean bSeparator;
      boolean bQuote;

      bSeparator = (separator != null&& (separator.length() 0);
      bQuote = (quote != null&& (quote.length() 0);
      for (iIndex = 0; iIndex < strings.length; iIndex++) {
        if ((strings[iIndex!= null&& (strings[iIndex].length() 0)) {
          if ((output.length() 0&& (bSeparator)) {
            output.append(separator);
          }
          if (bQuote) {
            output.append(quote);
          }
          output.append(strings[iIndex]);
          if (bQuote) {
            output.append(quote);
          }
        }
      }
    }

    return output.toString();
  }

  /**
   * Test if any element in the container contains given string.
   
   @param container -
   *          container of which elements will be searched to see if they
   *          contains given text
   @param strSearch -
   *          text to search in the elements of specified container
   @return boolean - true if any of the elements in container contains given
   *         text
   */
  public static boolean isContained(Collection container, String strSearch) {
    boolean bReturn = false;

    if ((container != null&& (!container.isEmpty())) {
      for (Iterator itrElements = container.iterator()(itrElements.hasNext() && (!bReturn));) {
        if (((StringitrElements.next()).indexOf(strSearch!= -1) {
          bReturn = true;
        }
      }
    }

    return bReturn;
  }

  /**
   * Test if given string contains any element in the container.
   
   @param container -
   *          container of which elements will be searched to see if they are
   *          contained within given text
   @param strSearch -
   *          text to search in for the elements of specified container
   @return boolean - true if the search text contains any of the elements in
   *         container
   */
  public static boolean contains(Collection container, String strSearch) {
    boolean bReturn = false;

    if ((container != null&& (!container.isEmpty())) {
      for (Iterator itrElements = container.iterator()(itrElements.hasNext() && (!bReturn));) {
        if (strSearch.indexOf((StringitrElements.next()) != -1) {
          bReturn = true;
        }
      }
    }

    return bReturn;
  }

  /**
   * Method return boolean result if particular substring is contained within
   * the list of substrings separated by a separator.
   
   @param strSearchIn -
   *          string of all substrings separated by separator to search in
   @param strSearchFor -
   *          string that will be search for
   @param strSeparator -
   *          item separator
   @return boolean - true if it contains the ID, false otherwise
   */
  public static boolean containsInSeparatedString(String strSearchIn, String strSearchFor,
      String strSeparator) {
    boolean bReturn = false;

    StringBuffer sbInputString = new StringBuffer();
    StringBuffer sbSearchString = new StringBuffer();

    if (strSearchIn.length() 0) {
      // add separator at the beginning and end of the input string
      sbInputString.append(strSeparator);
      sbInputString.append(strSearchIn);
      sbInputString.append(strSeparator);

      // add separator at the beginning and end of the search string
      sbSearchString.append(strSeparator);
      sbSearchString.append(strSearchFor);
      sbSearchString.append(strSeparator);

      // search for particular ID
      if (sbInputString.indexOf(sbSearchString.toString()) != -1) {
        bReturn = true;
      }
    }

    return bReturn;
  }
}

   
    
    
    
    
    
  














Related examples in the same category
1.Parse Comma Delimited List
2.Parse Fraction
3.Parse a method signature or method call signature
4.Parse basic types
5.Decodes a String with Numeric Character References
6.Returns true if the argument contains a number
7.Normalize a SQL identifer, up-casing if , and handling of (SQL 2003, section 5.2).
8.Convert a String to an int, returning zero if the conversion fails.
9.Parsing primitives from String's without creating any objects
10.Checks whether the String a valid Java number.
11.Check whether the given String has actual text.
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.