Example usage for java.lang Character getType

Introduction

In this page you can find the example usage for java.lang Character getType.

Prototype

public static int getType(int codePoint) 

Source Link

Document

Returns a value indicating a character's general category.

Usage

From source file:com.sjdf.platform.xss.StringUtils.java

/**
 * <p/>//w  w  w  .  ja v a 2s.c  o m
 * Splits a String by Character type as returned by
 * {@code java.lang.Character.getType(char)}. Groups of contiguous
 * characters of the same type are returned as complete tokens, with the
 * following exception: if {@code camelCase} is {@code true}, the character
 * of type {@code Character.UPPERCASE_LETTER}, if any, immediately preceding
 * a token of type {@code Character.LOWERCASE_LETTER} will belong to the
 * following token rather than to the preceding, if any,
 * {@code Character.UPPERCASE_LETTER} token.
 *
 * @param str       the String to split, may be {@code null}
 * @param camelCase whether to use so-called "camel-case" for letter types
 * @return an array of parsed Strings, {@code null} if null String input
 * @since 2.4
 */
private static String[] splitByCharacterType(String str, boolean camelCase) {
    if (str == null) {
        return new String[0];
    }
    if (str.length() == 0) {
        return EMPTY_STRING_ARRAY;
    }
    char[] c = str.toCharArray();
    List<String> list = new ArrayList<String>();
    int tokenStart = 0;
    int currentType = Character.getType(c[tokenStart]);
    for (int pos = tokenStart + 1; pos < c.length; pos++) {
        int type = Character.getType(c[pos]);
        if (type == currentType) {
            continue;
        }
        if (camelCase && type == Character.LOWERCASE_LETTER && currentType == Character.UPPERCASE_LETTER) {
            int newTokenStart = pos - 1;
            if (newTokenStart != tokenStart) {
                list.add(new String(c, tokenStart, newTokenStart - tokenStart));
                tokenStart = newTokenStart;
            }
        } else {
            list.add(new String(c, tokenStart, pos - tokenStart));
            tokenStart = pos;
        }
        currentType = type;
    }
    list.add(new String(c, tokenStart, c.length - tokenStart));
    return list.toArray(new String[list.size()]);
}

---

From source file:org.apache.commons.lang3.StringUtils.java

/**
 * <p>Splits a String by Character type as returned by
 * {@code java.lang.Character.getType(char)}. Groups of contiguous
 * characters of the same type are returned as complete tokens, with the
 * following exception: if {@code camelCase} is {@code true},
 * the character of type {@code Character.UPPERCASE_LETTER}, if any,
 * immediately preceding a token of type {@code Character.LOWERCASE_LETTER}
 * will belong to the following token rather than to the preceding, if any,
 * {@code Character.UPPERCASE_LETTER} token.
 * @param str the String to split, may be {@code null}
 * @param camelCase whether to use so-called "camel-case" for letter types
 * @return an array of parsed Strings, {@code null} if null String input
 * @since 2.4/* w ww .  j a va2s. c o m*/
 */
private static String[] splitByCharacterType(String str, boolean camelCase) {
    if (str == null) {
        return null;
    }
    if (str.length() == 0) {
        return ArrayUtils.EMPTY_STRING_ARRAY;
    }
    char[] c = str.toCharArray();
    List<String> list = new ArrayList<String>();
    int tokenStart = 0;
    int currentType = Character.getType(c[tokenStart]);
    for (int pos = tokenStart + 1; pos < c.length; pos++) {
        int type = Character.getType(c[pos]);
        if (type == currentType) {
            continue;
        }
        if (camelCase && type == Character.LOWERCASE_LETTER && currentType == Character.UPPERCASE_LETTER) {
            int newTokenStart = pos - 1;
            if (newTokenStart != tokenStart) {
                list.add(new String(c, tokenStart, newTokenStart - tokenStart));
                tokenStart = newTokenStart;
            }
        } else {
            list.add(new String(c, tokenStart, pos - tokenStart));
            tokenStart = pos;
        }
        currentType = type;
    }
    list.add(new String(c, tokenStart, c.length - tokenStart));
    return list.toArray(new String[list.size()]);
}

---

From source file:com.rdm.common.util.StringUtils.java

/**
 * <p>Splits a String by Character type as returned by
 * {@code java.lang.Character.getType(char)}. Groups of contiguous
 * characters of the same type are returned as complete tokens, with the
 * following exception: if {@code camelCase} is {@code true},
 * the character of type {@code Character.UPPERCASE_LETTER}, if any,
 * immediately preceding a token of type {@code Character.LOWERCASE_LETTER}
 * will belong to the following token rather than to the preceding, if any,
 * {@code Character.UPPERCASE_LETTER} token.
 * @param str the String to split, may be {@code null}
 * @param camelCase whether to use so-called "camel-case" for letter types
 * @return an array of parsed Strings, {@code null} if null String input
 * @since 2.4/*  w  w  w .j a  v a  2s  .co  m*/
 */
private static String[] splitByCharacterType(final String str, final boolean camelCase) {
    if (str == null) {
        return null;
    }
    if (str.isEmpty()) {
        return ArrayUtils.EMPTY_STRING_ARRAY;
    }
    final char[] c = str.toCharArray();
    final List<String> list = new ArrayList<String>();
    int tokenStart = 0;
    int currentType = Character.getType(c[tokenStart]);
    for (int pos = tokenStart + 1; pos < c.length; pos++) {
        final int type = Character.getType(c[pos]);
        if (type == currentType) {
            continue;
        }
        if (camelCase && type == Character.LOWERCASE_LETTER && currentType == Character.UPPERCASE_LETTER) {
            final int newTokenStart = pos - 1;
            if (newTokenStart != tokenStart) {
                list.add(new String(c, tokenStart, newTokenStart - tokenStart));
                tokenStart = newTokenStart;
            }
        } else {
            list.add(new String(c, tokenStart, pos - tokenStart));
            tokenStart = pos;
        }
        currentType = type;
    }
    list.add(new String(c, tokenStart, c.length - tokenStart));
    return list.toArray(new String[list.size()]);
}

---

From source file:bfile.util.StringUtils.java

/**
 * <p>Splits a String by Character type as returned by
 * {@code java.lang.Character.getType(char)}. Groups of contiguous
 * characters of the same type are returned as complete tokens, with the
 * following exception: if {@code camelCase} is {@code true},
 * the character of type {@code Character.UPPERCASE_LETTER}, if any,
 * immediately preceding a token of type {@code Character.LOWERCASE_LETTER}
 * will belong to the following token rather than to the preceding, if any,
 * {@code Character.UPPERCASE_LETTER} token.
 * @param str the String to split, may be {@code null}
 * @param camelCase whether to use so-called "camel-case" for letter types
 * @return an array of parsed Strings, {@code null} if null String input
 * @since 2.4/*  w  ww .  j  av a2s  . c o m*/
 */
private static String[] splitByCharacterType(final String str, final boolean camelCase) {
    if (str == null) {
        return null;
    }
    if (str.isEmpty()) {
        return ArrayUtils.EMPTY_STRING_ARRAY;
    }
    final char[] c = str.toCharArray();
    final List<String> list = new ArrayList<>();
    int tokenStart = 0;
    int currentType = Character.getType(c[tokenStart]);
    for (int pos = tokenStart + 1; pos < c.length; pos++) {
        final int type = Character.getType(c[pos]);
        if (type == currentType) {
            continue;
        }
        if (camelCase && type == Character.LOWERCASE_LETTER && currentType == Character.UPPERCASE_LETTER) {
            final int newTokenStart = pos - 1;
            if (newTokenStart != tokenStart) {
                list.add(new String(c, tokenStart, newTokenStart - tokenStart));
                tokenStart = newTokenStart;
            }
        } else {
            list.add(new String(c, tokenStart, pos - tokenStart));
            tokenStart = pos;
        }
        currentType = type;
    }
    list.add(new String(c, tokenStart, c.length - tokenStart));
    return list.toArray(new String[list.size()]);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• »