Checks if the given string is a numeric string that can be converted to a
long value with radix {@value #DEFAULT_RADIX}.

@param sStr
The string to check. May be <code>null</code>.
@return <code>true</code> if the value can be converted to a valid value
517057
public static boolean isInt (@Nullable final String sStr)
  {
    if (sStr != null)
      try
      {
        Integer.parseInt (sStr, DEFAULT_RADIX);
        return true;
      }
      catch (final NumberFormatException ex)
      {
        // fall through
      }
    return false;
  }
944948
public static boolean isValidJavaIdentifier(String str) {
    if (isNullOrEmpty(str)) {
      return false;
    }
    if (JAVA_KEYWORDS.contains(str)) {
      return false;
    }
    if (!Character.isJavaIdentifierStart(str.charAt(0))) {
      return false;
    }
    for (int i = 1; i < str.length(); i++) {
      if (!Character.isJavaIdentifierPart(str.charAt(i))) {
        return false;
      }
    }
    return true;
  }
607119
public static final boolean isValid(final String value) {
        if (value == null) {
            return true;
        }
        if (value.length() != 36) {
            return false;
        }
        try {
            UUID.fromString(value);
            return true;
        } catch (final RuntimeException ex) {
            return false;
        }
    }
1026951
@Nullable
  public static Short parseShortObj (@Nullable final String sStr)
  {
    return parseShortObj (sStr, DEFAULT_RADIX, null);
  }
447671
public static long string2long(String s, int radix)
        throws NumberFormatException {
        if (radix == 10) {
            return Long.parseLong(s, radix);
        } else {
            char[] cs = s.toCharArray();
            long limit = Long.MAX_VALUE / (radix/2);
            long n = 0;
            for (int i = 0; i < cs.length; i++) {
                int d = Character.digit(cs[i], radix);
                if (n < 0 ||
                    n > limit ||
                    n * radix > Long.MAX_VALUE - d)
                    throw new NumberFormatException();
                n = n * radix + d;
            }
            return n;
        }
    }
754707
@Nonnull
  private static String _saveConvert (final String sStr, final boolean bEscapeSpace, final boolean bEscapeUnicode)
  {
    final int nLen = sStr.length ();
    int nBufLen = nLen * 2;
    if (nBufLen < 0)
      nBufLen = Integer.MAX_VALUE;
    final StringBuilder aSB = new StringBuilder (nBufLen);

    for (int x = 0; x < nLen; x++)
    {
      final char aChar = sStr.charAt (x);
      // Handle common case first, selecting largest block that
      // avoids the specials below
      // 61 == '='
      if (aChar > 61 && aChar < 127)
      {
        if (aChar == '\\')
        {
          aSB.append ('\\').append ('\\');
          continue;
        }
        aSB.append (aChar);
        continue;
      }
      switch (aChar)
      {
        case ' ':
          if (x == 0 || bEscapeSpace)
            aSB.append ('\\');
          aSB.append (' ');
          break;
        case '\t':
          aSB.append ('\\').append ('t');
          break;
        case '\n':
          aSB.append ('\\').append ('n');
          break;
        case '\r':
          aSB.append ('\\').append ('r');
          break;
        case '\f':
          aSB.append ('\\').append ('f');
          break;
        case '=':
        case ':':
        case '#':
        case '!':
          aSB.append ('\\').append (aChar);
          break;
        default:
          if ((aChar < 0x0020 || aChar > 0x007e) && bEscapeUnicode)
          {
            aSB.append ('\\')
               .append ('u')
               .append (StringHelper.getHexChar ((aChar >> 12) & 0xF))
               .append (StringHelper.getHexChar ((aChar >> 8) & 0xF))
               .append (StringHelper.getHexChar ((aChar >> 4) & 0xF))
               .append (StringHelper.getHexChar (aChar & 0xF));
          }
          else
          {
            aSB.append (aChar);
          }
      }
    }
    return aSB.toString ();
  }
329135
public static boolean hasOnlyNum(String str) {

        if (isEmpty(str))
            return false;

        Pattern pattern = Pattern.compile("[0-9]*");
        return pattern.matcher(str).matches();
    }
1358693
function isNumeric(value) {
  if (_.isNumber(value)) {
    return true;
  }
  if (_.isString(value)) {
    if (!isFinite(value)) {
      return false;
    }
    // str is a finite number, but not all number strings should be numbers
    // If the string starts with 0, is more than 1 character, and does not have a period, it should stay a string
    // It could be an account number for example
    if (value[0] === '0' && value.length > 1 && value.indexOf('.') === -1) {
      return false;
    }

    return true;
  }
  return false;
}
194978
@Nullable
  public static Long parseLongObj (@Nullable final String sStr)
  {
    return parseLongObj (sStr, DEFAULT_RADIX, null);
  }
948053
public static boolean containNumber(String str) {
		for (int i = 0; i < str.length(); i++) {
		    if (Character.isDigit(str.charAt(i))) {
			return true;
		    }
		}		
		return false;
    }
1100743
public static boolean isAllDelimiter(byte[] sString)
    {
        int nLen = sString.length;
        int i = 0;

        while (i < nLen - 1 && (getUnsigned(sString[i]) == 161 || getUnsigned(sString[i]) == 163))
        {
            i += 2;
        }
        if (i < nLen)
            return false;
        return true;
    }
724961
@Nullable
  public static String extractStringValue (@Nullable final String sStr)
  {
    if (StringHelper.hasNoText (sStr) || sStr.length () < 2)
      return sStr;

    final char cFirst = sStr.charAt (0);
    if ((cFirst == '"' || cFirst == '\'') && StringHelper.getLastChar (sStr) == cFirst)
    {
      // Remove quotes around the string
      return _trimBy (sStr, 1, 1);
    }
    return sStr;
  }
256896
@Nullable
  public static Byte parseByteObj (@Nullable final String sStr)
  {
    return parseByteObj (sStr, DEFAULT_RADIX, null);
  }
972772
public static boolean isCNNumericString(String str , int sIdx, int eIdx)
    {
        for ( int i = sIdx; i < eIdx; i++ ) {
            if ( ! cnNumeric.containsKey(str.charAt(i)) ) {
                return false;
            }
        }
        return true;
    }
1131807
public static boolean isHexadecimal(String value) {

        if (value == null || value.length() == 0) {
            return false;
        }

        // validate string is hexadecimal value
        if (! HEX_REGEX_PATTERN.matcher(value).matches()) {
            return false;
        }

        return true;
    }
335374
public static boolean hasText(@Nullable CharSequence str) {
        if (isEmpty(str)) {
            return false;
        }

        int strLen = str.length();
        for (int i = 0; i < strLen; i++) {
            if (!Character.isWhitespace(str.charAt(i))) {
                return true;
            }
        }
        return false;
    }
494333
private static boolean isAsciiAlphaNum(String string) {
        for (int i = 0; i < string.length(); i++) {
            final char character = string.charAt(i);
            if (!(character >= 'a' && character <= 'z' ||
                    character >= 'A' && character <= 'Z' ||
                    character >= '0' && character <= '9')) {
                return false;
            }
        }

        return true;
    }