Java StringCharacterIterator.DONE属性代码示例

/**
 * addslashes() 函数在指定的预定义字符前添加反斜杠。 做转义处理后，写入数据库就不会因敏感字符（'之类）导致sql有问题。
 * 此处的转义处理内容是:在字符串中的单引号、双引号、反斜杠之前，都附加上反斜杠
 */
public static String addSlashes(String text) {
    if (text == null || text.equals("")) {
        return "";
    }
    StringBuffer sb = new StringBuffer(text.length() * 2);
    StringCharacterIterator iterator = new StringCharacterIterator(text);
    char character = iterator.current();
    while (character != StringCharacterIterator.DONE) {
        // DONE,字符型，当迭代器已到达文本末尾或开始处时返回的常量。
        switch (character) {
            case '\'': /* 单引号 */
            case '"': /* 双引号 */
            case '\\': /* 单斜杠 */
                sb.append("\\"); /* 单斜杠 */
            default:
                sb.append(character);
                break;
        }
        character = iterator.next();
    }
    return sb.toString();
}
 

private static List<String> findTokens(String data) {
    List<String> tokens = new ArrayList<String>();
    boolean inQuotes = false;
    StringBuilder currentToken = new StringBuilder();
    StringCharacterIterator i = new StringCharacterIterator(data);
    while (i.current() != StringCharacterIterator.DONE) {
        char c = i.current();
        if (c == '\'') {
            inQuotes = !inQuotes;
        }
        if (!inQuotes && (c == '.' || c == '[' || c == ']')) {
            if (currentToken.length() > 0) {
                tokens.add(currentToken.toString());
                currentToken.setLength(0);
            }
        } else {
            currentToken.append(c);
        }
        i.next();
    }
    tokens.add(currentToken.toString());
    return Collections.unmodifiableList(tokens);
}
 

private Object string() {
    buf.setLength(0);
    while (c != '"' && c != StringCharacterIterator.DONE) {
        if (c == '\\') {
            next();
            if (c == 'u') {
                add(unicode());
            } else {
                Object value = escapes.get(new Character(c));
                if (value != null) {
                    add(((Character) value).charValue());
                }
            }
        } else {
            add();
        }
    }
    // unterminated string will terminate automatically
    next();
    return buf.toString();
}
 

/**
 * 根据转义列表对字符串进行转义。.
 * 
 * @param source
 *            待转义的字符串
 * @param escapeCharMap
 *            转义列表
 * @return 转义后的字符串
 */
public static String escapeCharacter(String source, HashMap escapeCharMap) {
	if (source == null || source.length() == 0)
		return source;
	if (escapeCharMap.size() == 0)
		return source;
	StringBuffer sb = new StringBuffer();
	StringCharacterIterator sci = new StringCharacterIterator(source);
	for (char c = sci.first(); c != StringCharacterIterator.DONE; c = sci.next()) {
		String character = String.valueOf(c);
		if (escapeCharMap.containsKey(character))
			character = (String) escapeCharMap.get(character);
		sb.append(character);
	}
	return sb.toString();
}
 

public static String escapeJSON(String aText) {
    if (aText == null) {
        return null;
    }
    final StringBuilder result = new StringBuilder();
    StringCharacterIterator iterator = new StringCharacterIterator(aText);
    char character = iterator.current();
    while (character != StringCharacterIterator.DONE) {
        if (character == '\"') {
            result.append("\\\"");
        } else if (character == '\\') {
            result.append("\\\\");
        } else if (character == '/') {
            result.append("\\/");
        } else if (character == '\b') {
            result.append("\\b");
        } else if (character == '\f') {
            result.append("\\f");
        } else if (character == '\n') {
            result.append("\\n");
        } else if (character == '\r') {
            result.append("\\r");
        } else if (character == '\t') {
            result.append("\\t");
        } else {
            // the char is not a special one
            // add it to the result as is
            result.append(character);
        }
        character = iterator.next();
    }
    return result.toString();
}
 

private static String expandOverride(String pattern, String override) {

        if (override.indexOf('=') >= 0) {
            return override;
        }
        boolean inQuotes = false;
        char prevChar = ' ';
        StringBuilder result = new StringBuilder();

        StringCharacterIterator it = new StringCharacterIterator(pattern);

        for (char c = it.first(); c!= StringCharacterIterator.DONE; c = it.next()) {
            if ( c == QUOTE ) {
                inQuotes = !inQuotes;
                prevChar = c;
                continue;
            }
            if ( !inQuotes && c != prevChar ) {
                if (result.length() > 0) {
                    result.append(";");
                }
                result.append(c);
                result.append("=");
                result.append(override);
            }
            prevChar = c;
        }
        return result.toString();
    }
 

public static List<String> parseDelimitedList(String s) {
    List<String> result = new ArrayList<>();
    if (StringUtils.isNotEmpty(s)) {

        StringCharacterIterator iterator = new StringCharacterIterator(s);
        char c = iterator.first();

        StringBuilder strb = new StringBuilder();
        boolean insideExpression = false;

        while (c != StringCharacterIterator.DONE) {
            if (c == '{' || c == '$') {
                insideExpression = true;
            } else if (c == '}') {
                insideExpression = false;
            } else if (c == ',' && !insideExpression) {
                result.add(strb.toString().trim());
                strb.delete(0, strb.length());
            }

            if (c != ',' || (insideExpression)) {
                strb.append(c);
            }

            c = iterator.next();
        }

        if (strb.length() > 0) {
            result.add(strb.toString().trim());
        }

    }
    return result;
}
 

/**
   Escapes characters for text appearing as data in the 
   <a href='http://www.json.org/'>Javascript Object Notation</a>
   (JSON) data interchange format.
   
   <P>The following commonly used control characters are escaped :
   <table border='1' cellpadding='3' cellspacing='0'>
   <tr><th> Character </th><th> Escaped As </th></tr>
   <tr><td> " </td><td> \" </td></tr>
   <tr><td> \ </td><td> \\ </td></tr>
   <tr><td> / </td><td> \/ </td></tr>
   <tr><td> back space </td><td> \b </td></tr> 
   <tr><td> form feed </td><td> \f </td></tr>
   <tr><td> line feed </td><td> \n </td></tr>
   <tr><td> carriage return </td><td> \r </td></tr>
   <tr><td> tab </td><td> \t </td></tr>
   </table>
   
   <P>See <a href='http://www.ietf.org/rfc/rfc4627.txt'>RFC 4627</a> for more information.
  */
public static String forJSON(String aText) {
	final StringBuilder result = new StringBuilder();
	StringCharacterIterator iterator = new StringCharacterIterator(aText);
	char character = iterator.current();
	while (character != StringCharacterIterator.DONE) {
		if (character == '\"') {
			result.append("\\\"");
		} else if (character == '\\') {
			result.append("\\\\");
		} else if (character == '/') {
			result.append("\\/");
		} else if (character == '\b') {
			result.append("\\b");
		} else if (character == '\f') {
			result.append("\\f");
		} else if (character == '\n') {
			result.append("\\n");
		} else if (character == '\r') {
			result.append("\\r");
		} else if (character == '\t') {
			result.append("\\t");
		} else {
			// the char is not a special one
			// add it to the result as is
			result.append(character);
		}
		character = iterator.next();
	}
	return result.toString();
}
 

/**
 * This method attempts to read a multiplicity starting from the current
 * position in the SCI parameter. The position will be moved such that
 * calling next on the iterator results in getting the first non-numerical
 * character to follow the multiplicity.
 *
 * @param	aSCI	StringCharacterIterator to read from.
 * @return	int	the multiplicity.
 */
private int getMultiplicity(StringCharacterIterator aSCI) {
    int mp = 0;

    // If the current char is not a number, multiplicity is simply
    // '1'.
    if (!Character.isDigit(aSCI.current())) {
        mp = 1;
    } else {
        // The current char is the first of the number.
        String number = Character.toString(aSCI.current());

        // Fence-post.
        char next = aSCI.next();
        // Get all digits constructing the number.
        while ((next != StringCharacterIterator.DONE) && Character.isDigit(next)) {

            // Add it to the number.
            number += Character.toString(next);

            // Increment.
            next = aSCI.next();
        }

        // Convert the number into an int.
        mp = Integer.parseInt(number);
    }

    // Voila.
    return mp;
}
 

private Object read() {
    skipWhiteSpace();
    char ch = c;
    next();
    switch (ch) {
        case '"': token = string(); break;
        case '[': token = array(); break;
        case ']': token = MARK_ARRAY_END; break;
        case ',': token = MARK_COMMA; break;
        case '{': token = object(); break;
        case '}': token = MARK_OBJECT_END; break;
        case ':': token = MARK_COLON; break;
        case 't':
            next(); next(); next(); // assumed r-u-e
            token = Boolean.TRUE;
            break;
        case'f':
            next(); next(); next(); next(); // assumed a-l-s-e
            token = Boolean.FALSE;
            break;
        case 'n':
            next(); next(); next(); // assumed u-l-l
            token = null;
            break;
        case StringCharacterIterator.DONE:
            token = MARK_END_INPUT;
            break;
        default:
            if (Character.isDigit(ch) || ch == '-') {
                // Push this back on so it's part of the number
                c = it.previous();
                token = number();
            }
    }
    // System.out.println("token: " + token); // enable this line to see the token stream
    return token;
}
 

/**
 * Parses the given String as a list of comma separated entries, where an
 * entry can possibly be an expression that has comma's.
 * 
 * If somebody is smart enough to write a regex for this, please let us know.
 * 
 * @return the entries of the comma separated list, trimmed.
 */
protected List<String> parseCommaSeparatedList(String s) {
  List<String> result = new ArrayList<String>();
  if (s != null && !"".equals(s)) {

    StringCharacterIterator iterator = new StringCharacterIterator(s);
    char c = iterator.first();

    StringBuilder strb = new StringBuilder();
    boolean insideExpression = false;

    while (c != StringCharacterIterator.DONE) {
      if (c == '{' || c == '$') {
        insideExpression = true;
      } else if (c == '}') {
        insideExpression = false;
      } else if (c == ',' && !insideExpression) {
        result.add(strb.toString().trim());
        strb.delete(0, strb.length());
      }

      if (c != ',' || (insideExpression)) {
        strb.append(c);
      }

      c = iterator.next();
    }

    if (strb.length() > 0) {
      result.add(strb.toString().trim());
    }

  }
  return result;
}
 

/**
  * Escapes characters for text appearing as XML data by HTML tags.
  * 
  * <P>The following characters are replaced with corresponding character entities : 
  * <table border='1' cellpadding='3' cellspacing='0'>
  * <tr><th> Character </th><th> Encoding </th></tr>
  * <tr><td> < </td><td> &amp;lt; </td></tr>
  * <tr><td> > </td><td> &amp;gt; </td></tr>
  * <tr><td> & </td><td> &amp;amp; </td></tr>
  * <tr><td> " </td><td> &amp;quot;</td></tr>
  * <tr><td> ' </td><td> &amp;#039;</td></tr>
  * </table>
  * 
  * <P>Note that JSTL's {@code <c:out>} escapes the exact same set of 
  * characters as this method. <span class='highlight'>That is, {@code <c:out>}
  *  is good for escaping to produce valid XML, but not for producing safe HTML.</span>
  * see: http://www.javapractices.com/topic/TopicAction.do?Id=96
  */
public static String escapeCharFromXML(String text)
{
    if (null == text) {
        System.out.println("Error in StringUtil.escapeCharFromXML(), argument is null.");
        return NULL_STRING;
    }
    
    final StringBuilder result = new StringBuilder();
    final StringCharacterIterator iterator = new StringCharacterIterator(text);
    char character =  iterator.current();
    
    while (character != StringCharacterIterator.DONE ){
      if (character == '&') {
          
          // skip double (error) parsing: &lt; -> &amp;lt;
          int save = iterator.getIndex();
          String ampersand_tag = isAmpersandTag(text, save);
          
          if(ampersand_tag.length() > 0) {
              result.append(ampersand_tag);
              iterator.setIndex(save + ampersand_tag.length() - 1);
          } else {
              result.append("&amp;");
          }
      } else if (' ' != character && XMLTag.existsGlyph(character)) {
        result.append(XMLTag.getHTML(character));
      }
      else {
        //the char is not a special one
        //add it to the result as is
        result.append(character);
      }
      character = iterator.next();
    }
    return result.toString();
}
 

/** Doubles slashes before quotes. */
public static String escapeChars(String text){
    if (null == text) {
        System.out.println("Error in StringUtil.escapeChars(), argument is null.");
        return NULL_STRING;
    }

    if (text.equalsIgnoreCase("\\"))
        return "\\\\";

    StringBuilder result = new StringBuilder();
    StringCharacterIterator iterator = new StringCharacterIterator(text);
    char character =  iterator.current();
    while (character != StringCharacterIterator.DONE ){
      if (character == '\"') {
        result.append("\\\"");
      }
      else if (character == '\'') {
          result.append('\\');
          result.append('\'');
        //result.append("\\'");
      }
      else if (character == '\\') {
          result.append('\\');
          result.append('\\');
      }
      else {
        //the char is not a special one
        //add it to the result as is
        result.append(character);
      }
      character = iterator.next();
    }
    return result.toString();
}
 

/**
    * Makes a CSV-file-safe version of a given string.  This includes
    * escaping CR, LF, and double-quote characters with backslashes,
    * and quoting strings that contain whitespace.
    *
    * @param original The original, unsafe string.
    * @return The original string if it contained none of the special
    * characters mentioned above; an empty string if the original was
    * null; otherwise, a quoted version of the original string with
    * the necessary characters backslash-escaped.
    */
   public static String makeStringSafe(String original) {
if(original==null) {
    return "";
}


StringBuffer escaped = new StringBuffer(original.length());
StringCharacterIterator it = new StringCharacterIterator(original);
boolean escapedDiffersFromOriginal=false;
char ch;

escaped.append("\"");

do {
    ch=it.current();
    switch(ch) {
    case '\n':
	escaped.append("\\n");
	escapedDiffersFromOriginal=true;
	break;
	
    case '\r':
	escaped.append("\\r");
	escapedDiffersFromOriginal=true;
	break;
	
	    case '"':
	escaped.append("\\\"");
	escapedDiffersFromOriginal=true;
	break;

    case '\\':
	escaped.append("\\\\");
	escapedDiffersFromOriginal=true;
	break;

    case ' ':
    case '\f':
    case '\t':
    case ',':
	// Whitespace and commas don't need to be escaped
	// explicitly, but the whole string will need to be
	// quoted.
	escaped.append(ch);
	escapedDiffersFromOriginal=true;
	break;

    default:
	escaped.append(ch);
	break;
    }
} while( it.next() != StringCharacterIterator.DONE);

escaped.append("\"");

return (escapedDiffersFromOriginal ? escaped.toString() : original);
   }
 

/**
 * This method will read an element symbol and it's multiplicity from an
 * SCI.
 *
 * @param	aSCI	StringCharacterIterator to read from.
 * @return	Object[]	with the element behind index ELEMENT and the
 *						multiplicity behind index MULTIPLICITY.
 */
private Object[] getElement(StringCharacterIterator aSCI) {
    Object[] result = new Object[2];

    // Okay, we'll need to find out the element name.
    // It can consist of one or two letters, the second
    // being lowercase if present.
    String element = Character.toString(aSCI.current());
    int multiplicity = 1;

    // First of all, check whether there IS a next (the element
    // could well be the last in line, in which case multiplicity is 1
    // and we're done!
    char next = aSCI.next();
    if (next == StringCharacterIterator.DONE) {
        // We don't do anything else here.
    } else {
        // Check if the next char is a lowercase letter.
        if (Character.isLetter(next) && Character.isLowerCase(next)) {
            // Add the second char to the element String and
            // move the position one step further.
            element += Character.toString(next);
            next = aSCI.next();
        } else if (next == '<') {
            // It's the start of a modification tag.
            // Let's grab it and add it!
            element += this.isolateInnerPartString(aSCI, '<', '>', true);
        }

        // Now we can check multiplicity.
        // This is only necessary if the next char is a number, else
        // we'll just set it to '1'.
        if ((next != StringCharacterIterator.DONE) && Character.isDigit(next)) {
            multiplicity = this.getMultiplicity(aSCI);
        } else {
            // Just set to one.
            multiplicity = 1;
        }
    }

    // Voila.
    result[ELEMENT] = element;
    result[MULTIPLICITY] = Integer.valueOf(multiplicity);

    return result;
}