Java UCharacter.toLowerCase方法代码示例

import com.ibm.icu.lang.UCharacter; //导入方法依赖的package包/类
public String transform(final String value) {
    if (value == null) {
        return null;
    }

    switch (mode) {
    case UPPER_CASE:
        return UCharacter.toUpperCase(value);
    case LOWER_CASE:
        return UCharacter.toLowerCase(value);
    case CAPITALIZE_SENTENCES:
        return UCharacter.toTitleCase(value, BreakIterator.getSentenceInstance());
    case CAPITALIZE_WORDS:
        return capitalizeWordsByDictionaries(value);
    default:
        throw new UnsupportedOperationException("Unsupported mode: " + mode);
    }
}
 

import com.ibm.icu.lang.UCharacter; //导入方法依赖的package包/类
@Override
public void addSourceTargetSet(UnicodeSet inputFilter, UnicodeSet sourceSet, UnicodeSet targetSet) {
    synchronized (this) {
        if (sourceTargetUtility == null) {
            sourceTargetUtility = new SourceTargetUtility(new Transform<String,String>() {
                @Override
                public String transform(String source) {
                    return UCharacter.toLowerCase(locale, source);
                }
            });
        }
    }
    sourceTargetUtility.addSourceTargetSet(this, inputFilter, sourceSet, targetSet);
}
 

import com.ibm.icu.lang.UCharacter; //导入方法依赖的package包/类
/**
 * @param val
 *            string to be handled
 * @param option
 *            to upper case or to lower case
 * @return
 */
private String handleCase( String val, char option, ULocale locale )
{
	if ( option == '<' )
		return UCharacter.toLowerCase( locale, val );
	else if ( option == '>' )
		return UCharacter.toUpperCase( locale, val );
	else
		return val;

}
 

import com.ibm.icu.lang.UCharacter; //导入方法依赖的package包/类
/**
 * @param val
 *            string to be handled
 * @param option
 *            to upper case or to lower case
 * @return
 */
private String handleCase( String val, char option )
{
	if ( option == '<' )
		return UCharacter.toLowerCase( locale, val );
	else if ( option == '>' )
		return UCharacter.toUpperCase( locale, val );
	else
		return val;

}
 

import com.ibm.icu.lang.UCharacter; //导入方法依赖的package包/类
/**
 * Converts the characters in this string to lowercase, using the specified
 * Locale.
 * 
 * @param locale
 *            the Locale to use.
 * @return a new string containing the lowercase characters equivalent to
 *         the characters in this string.
 */
public String toLowerCase(Locale locale) {
    String result = UCharacter.toLowerCase(locale, this);
    
    // Must return self if chars unchanged
    if (count != result.count) {
        return result;
    }
    for (int i = 0; i < count; ++i) {
        if (value[offset + i] != result.value[result.offset + i]) {
            return result;
        }
    }
    return this;
}
 

import com.ibm.icu.lang.UCharacter; //导入方法依赖的package包/类
/**
 * Parse a pattern string starting at offset pos.  Keywords are
 * matched case-insensitively.  Spaces may be skipped and may be
 * optional or required.  Integer values may be parsed, and if
 * they are, they will be returned in the given array.  If
 * successful, the offset of the next non-space character is
 * returned.  On failure, -1 is returned.
 * @param pattern must only contain lowercase characters, which
 * will match their uppercase equivalents as well.  A space
 * character matches one or more required spaces.  A '~' character
 * matches zero or more optional spaces.  A '#' character matches
 * an integer and stores it in parsedInts, which the caller must
 * ensure has enough capacity.
 * @param parsedInts array to receive parsed integers.  Caller
 * must ensure that parsedInts.length is >= the number of '#'
 * signs in 'pattern'.
 * @return the position after the last character parsed, or -1 if
 * the parse failed
 */
@SuppressWarnings("fallthrough")
public static int parsePattern(String rule, int pos, int limit,
        String pattern, int[] parsedInts) {
    // TODO Update this to handle surrogates
    int[] p = new int[1];
    int intCount = 0; // number of integers parsed
    for (int i=0; i<pattern.length(); ++i) {
        char cpat = pattern.charAt(i);
        char c;
        switch (cpat) {
        case ' ':
            if (pos >= limit) {
                return -1;
            }
            c = rule.charAt(pos++);
            if (!PatternProps.isWhiteSpace(c)) {
                return -1;
            }
            // FALL THROUGH to skipWhitespace
        case '~':
            pos = PatternProps.skipWhiteSpace(rule, pos);
            break;
        case '#':
            p[0] = pos;
            parsedInts[intCount++] = parseInteger(rule, p, limit);
            if (p[0] == pos) {
                // Syntax error; failed to parse integer
                return -1;
            }
            pos = p[0];
            break;
        default:
            if (pos >= limit) {
                return -1;
            }
            c = (char) UCharacter.toLowerCase(rule.charAt(pos++));
            if (c != cpat) {
                return -1;
            }
            break;
        }
    }
    return pos;
}
 

import com.ibm.icu.lang.UCharacter; //导入方法依赖的package包/类
@Override
public String normalize(final String input) {
  return UCharacter.toLowerCase(locale().asIcuLocale(), input);
}
 

import com.ibm.icu.lang.UCharacter; //导入方法依赖的package包/类
/**
 * Returns the lower case equivalent for the specified code point if it is
 * an upper case letter. Otherwise, the specified code point is returned
 * unchanged.
 * 
 * @param codePoint
 *            the code point to check.
 * @return if {@code codePoint} is an upper case character then its lower
 *         case counterpart, otherwise just {@code codePoint}.
 */
public static int toLowerCase(int codePoint) {
    return UCharacter.toLowerCase(codePoint);
}
 

import com.ibm.icu.lang.UCharacter; //导入方法依赖的package包/类
/**
 * Answers the lower case equivalent for the character when the character is
 * an upper case letter, otherwise answers the character.
 * 
 * @param codePoint
 *            the character, including supplementary characters
 * @return if codePoint is not a lower case character then its lower case
 *         counterpart, otherwise just codePoint
 */
public static int toLowerCase(int codePoint) {
    return UCharacter.toLowerCase(codePoint);
}