Example usage for java.lang Character CONTROL

Introduction

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

Prototype

byte CONTROL

To view the source code for java.lang Character CONTROL.

Click Source Link

Document

General category "Cc" in the Unicode specification.

Usage

From source file:Main.java

public static void main(String[] args) {
    for (char ch = Character.MIN_VALUE; ch < Character.MAX_VALUE; ch++) {
        if (Character.CONTROL == Character.getType(ch)) {
            String s = String.format("\\u%04x", (int) ch);
            System.out.println(s);
        }/*from ww w  .  j  a  v a  2 s .  co m*/
    }
}

---

From source file:Main.java

public static void main(String[] args) throws java.io.IOException {
    char c = 'a';

    System.out.println("Character = " + (int) c);
    System.out.println("Defined = " + Character.isDefined(c));
    System.out.println("Digit = " + Character.isDigit(c));
    System.out.println("Ignorable = " + Character.isIdentifierIgnorable(c));
    System.out.println("ISO control = " + Character.isISOControl(c));
    System.out.println("Java identifier part = " + Character.isJavaIdentifierPart(c));
    System.out.println("Java identifier start = " + Character.isJavaIdentifierStart(c));
    System.out.println("Letter = " + Character.isLetter(c));
    System.out.println("Letter or digit = " + Character.isLetterOrDigit(c));
    System.out.println("Lowercase = " + Character.isLowerCase(c));
    System.out.println("Space = " + Character.isSpaceChar(c));
    System.out.println("Titlecase = " + Character.isTitleCase(c));
    System.out.println("Unicode identifier part = " + Character.isUnicodeIdentifierPart(c));
    System.out.println("Unicode identifier start = " + Character.isUnicodeIdentifierStart(c));
    System.out.println("Uppercase = " + Character.isUpperCase(c));
    System.out.println("White space = " + Character.isWhitespace(c));

    byte[] types = { Character.COMBINING_SPACING_MARK, Character.CONNECTOR_PUNCTUATION, Character.CONTROL,
            Character.CURRENCY_SYMBOL, Character.DASH_PUNCTUATION, Character.DECIMAL_DIGIT_NUMBER,
            Character.ENCLOSING_MARK, Character.END_PUNCTUATION, Character.FORMAT, Character.LETTER_NUMBER,
            Character.LINE_SEPARATOR, Character.LOWERCASE_LETTER, Character.MATH_SYMBOL,
            Character.MODIFIER_SYMBOL, Character.NON_SPACING_MARK, Character.OTHER_LETTER,
            Character.OTHER_NUMBER, Character.OTHER_PUNCTUATION, Character.OTHER_SYMBOL,
            Character.PARAGRAPH_SEPARATOR, Character.PRIVATE_USE, Character.SPACE_SEPARATOR,
            Character.START_PUNCTUATION, Character.SURROGATE, Character.TITLECASE_LETTER, Character.UNASSIGNED,
            Character.UPPERCASE_LETTER };

    String[] typeNames = { "Combining spacing mark", "Connector punctuation", "Control", "Currency symbol",
            "Dash punctuation", "Decimal digit number", "Enclosing mark", "End punctuation", "Format",
            "Letter number", "Line separator", "Lowercase letter", "Math symbol", "Modifier symbol",
            "Non spacing mark", "Other letter", "Other number", "Other punctuation", "Other symbol",
            "Paragraph separator", "Private use", "Space separator", "Start punctuation", "Surrogate",
            "Titlecase letter", "Unassigned", "Uppercase letter" };

    int type = Character.getType(c);

    for (int i = 0; i < types.length; i++)
        if (type == types[i]) {
            System.out.println("Type name = " + typeNames[i]);
            break;
        }/*www. j  a v  a  2  s  . c o  m*/

    System.out.println("Unicode block = " + Character.UnicodeBlock.of(c));
}

---

From source file:Classify.java

public static void main(String[] args) throws java.io.IOException {
    char c = '\u0beb'; // Tamil digit.

    System.out.println("Character = " + (int) c);
    System.out.println("Defined = " + Character.isDefined(c));
    System.out.println("Digit = " + Character.isDigit(c));
    System.out.println("Ignorable = " + Character.isIdentifierIgnorable(c));
    System.out.println("ISO control = " + Character.isISOControl(c));
    System.out.println("Java identifier part = " + Character.isJavaIdentifierPart(c));
    System.out.println("Java identifier start = " + Character.isJavaIdentifierStart(c));
    System.out.println("Letter = " + Character.isLetter(c));
    System.out.println("Letter or digit = " + Character.isLetterOrDigit(c));
    System.out.println("Lowercase = " + Character.isLowerCase(c));
    System.out.println("Space = " + Character.isSpaceChar(c));
    System.out.println("Titlecase = " + Character.isTitleCase(c));
    System.out.println("Unicode identifier part = " + Character.isUnicodeIdentifierPart(c));
    System.out.println("Unicode identifier start = " + Character.isUnicodeIdentifierStart(c));
    System.out.println("Uppercase = " + Character.isUpperCase(c));
    System.out.println("White space = " + Character.isWhitespace(c));

    byte[] types = { Character.COMBINING_SPACING_MARK, Character.CONNECTOR_PUNCTUATION, Character.CONTROL,
            Character.CURRENCY_SYMBOL, Character.DASH_PUNCTUATION, Character.DECIMAL_DIGIT_NUMBER,
            Character.ENCLOSING_MARK, Character.END_PUNCTUATION, Character.FORMAT, Character.LETTER_NUMBER,
            Character.LINE_SEPARATOR, Character.LOWERCASE_LETTER, Character.MATH_SYMBOL,
            Character.MODIFIER_SYMBOL, Character.NON_SPACING_MARK, Character.OTHER_LETTER,
            Character.OTHER_NUMBER, Character.OTHER_PUNCTUATION, Character.OTHER_SYMBOL,
            Character.PARAGRAPH_SEPARATOR, Character.PRIVATE_USE, Character.SPACE_SEPARATOR,
            Character.START_PUNCTUATION, Character.SURROGATE, Character.TITLECASE_LETTER, Character.UNASSIGNED,
            Character.UPPERCASE_LETTER };

    String[] typeNames = { "Combining spacing mark", "Connector punctuation", "Control", "Currency symbol",
            "Dash punctuation", "Decimal digit number", "Enclosing mark", "End punctuation", "Format",
            "Letter number", "Line separator", "Lowercase letter", "Math symbol", "Modifier symbol",
            "Non spacing mark", "Other letter", "Other number", "Other punctuation", "Other symbol",
            "Paragraph separator", "Private use", "Space separator", "Start punctuation", "Surrogate",
            "Titlecase letter", "Unassigned", "Uppercase letter" };

    int type = Character.getType(c);

    for (int i = 0; i < types.length; i++)
        if (type == types[i]) {
            System.out.println("Type name = " + typeNames[i]);
            break;
        }/* ww  w  .  j a  v  a 2  s  . c  o  m*/

    System.out.println("Unicode block = " + Character.UnicodeBlock.of(c));
}

---

From source file:Main.java

public static String removeUnprintableCharacters(String str) {

    int len = str.length();
    StringBuffer buf = new StringBuffer();
    try {/*from ww  w.  ja va  2s  . c o  m*/
        for (int i = 0; i < len; i++) {
            String rep = "";
            char cp = str.charAt(i);// the code point
            // Replace invisible control characters and unused code points
            switch (Character.getType(cp)) {
            case Character.CONTROL: // \p{Cc}
            case Character.FORMAT: // \p{Cf}
            case Character.PRIVATE_USE: // \p{Co}
            case Character.SURROGATE: // \p{Cs}
            case Character.UNASSIGNED: // \p{Cn}
                buf = buf.append(rep);
                break;
            default:
                char[] chars = Character.toChars(cp);
                buf = buf.append(chars);
                break;
            }
        }
    } catch (NullPointerException e) {
        e.printStackTrace();
        System.err.println("Confused: " + e);
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
        System.err.println("Confused: " + e);
    } catch (IndexOutOfBoundsException e) {
        e.printStackTrace();
        System.err.println("Confused: " + e);
    } catch (Exception e) {
        e.printStackTrace();
        System.err.println("Confused: " + e);
    }

    return buf.toString();
}

---

From source file:de.fau.cs.osr.utils.StringUtils.java

public static String escHtml(String text, boolean forAttribute) {
    // StringEscapeUtils.escapeHtml(in) does not escape '\'' but a lot of 
    // other stuff that doesn't need escaping.

    if (text == null)
        return "";

    int n = text.length();
    StringBuilder sb = new StringBuilder(n * 4 / 3);
    for (int i = 0; i < n; i++) {
        char ch = text.charAt(i);
        switch (ch) {
        case ' ':
        case '\n':
        case '\t':
            sb.append(ch);/*  w w  w . j  a va  2s. c  o  m*/
            break;
        case '<':
            sb.append("&lt;");
            break;
        case '>':
            sb.append(forAttribute ? "&gt;" : ">");
            break;
        case '&':
            sb.append("&amp;");
            break;
        case '\'':
            // &apos; cannot safely be used, see wikipedia
            sb.append("&#39;");
            break;
        case '"':
            sb.append(forAttribute ? "&quot;" : "\"");
            break;
        default:
            if ((ch >= 0 && ch < 0x20) || (ch == 0xFE)) {
                hexCharRef(sb, ch);
                break;
            } else if (Character.isHighSurrogate(ch)) {
                ++i;
                if (i < n) {
                    char ch2 = text.charAt(i);
                    if (Character.isLowSurrogate(ch2)) {
                        int codePoint = Character.toCodePoint(ch, ch2);
                        switch (Character.getType(codePoint)) {
                        case Character.CONTROL:
                        case Character.PRIVATE_USE:
                        case Character.UNASSIGNED:
                            hexCharRef(sb, codePoint);
                            break;

                        default:
                            sb.append(ch);
                            sb.append(ch2);
                            break;
                        }

                        continue;
                    }
                }
            } else if (!Character.isLowSurrogate(ch)) {
                sb.append(ch);
                continue;
            }

            // No low surrogate followed or only low surrogate
            throw new IllegalArgumentException("String contains isolated surrogates!");
        }
    }

    return sb.toString();
}

---

From source file:ru.caffeineim.protocols.icq.tool.Dumper.java

/**
 * This method filters all non-displayable characters and replace them
 * with a '.' in the resulting String.//from ww w  . j  a v a 2  s  .c o m
 *
 * @param array The receive byte array.
 * @return The representation of all displayable characters.
 */
private static String stringTranslation(byte[] array) {
    String ent = new String(array);
    String res = new String();

    for (int i = 0; i < ent.length(); i++) {
        if (Character.getType(ent.charAt(i)) == Character.CONTROL)
            res += ".";
        else
            res += ent.charAt(i);
    }

    return res;
}

---

From source file:ome.services.blitz.test.utests.FilePathRestrictionsTest.java

/**
 * Test that two complex sets of rules combined as expected.
 * (On a rainy day this test could be broken up into several smaller tests.)
 *///ww w .  ja v a  2 s .  c om
@Test
public void testCombineRules() {
    /* these variables define the X set of rules to combine */

    final SetMultimap<Integer, Integer> transformationMatrixX = HashMultimap.create();
    final Set<String> unsafePrefixesX = new HashSet<String>();
    final Set<String> unsafeSuffixesX = new HashSet<String>();
    final Set<String> unsafeNamesX = new HashSet<String>();
    final Set<Character> safeCharactersX = new HashSet<Character>();

    /* these variables define the Y set of rules to combine */

    final SetMultimap<Integer, Integer> transformationMatrixY = HashMultimap.create();
    final Set<String> unsafePrefixesY = new HashSet<String>();
    final Set<String> unsafeSuffixesY = new HashSet<String>();
    final Set<String> unsafeNamesY = new HashSet<String>();
    final Set<Character> safeCharactersY = new HashSet<Character>();

    /* these variables define the expected result of combining X and Y */

    final SetMultimap<Integer, Integer> transformationMatrixXY = HashMultimap.create();
    final Set<String> unsafePrefixesXY = new HashSet<String>();
    final Set<String> unsafeSuffixesXY = new HashSet<String>();
    final Set<String> unsafeNamesXY = new HashSet<String>();
    final Set<Character> safeCharactersXY = new HashSet<Character>();

    /* automatically map control characters to the safe characters;
     * we will remove and replace any that are to be tested specially */

    for (int codePoint = 0; codePoint < 0x100; codePoint++) {
        if (Character.getType(codePoint) == Character.CONTROL) {
            transformationMatrixXY.put(codePoint, 65);
        }
    }

    /* choose four control characters and remove them from the transformation matrix */

    final Iterator<Integer> controlCodePointIterator = transformationMatrixXY.keySet().iterator();
    final int controlCharacterP = controlCodePointIterator.next();
    final int controlCharacterQ = controlCodePointIterator.next();
    final int controlCharacterR = controlCodePointIterator.next();
    final int controlCharacterS = controlCodePointIterator.next();

    transformationMatrixXY.removeAll(controlCharacterP);
    transformationMatrixXY.removeAll(controlCharacterQ);
    transformationMatrixXY.removeAll(controlCharacterR);
    transformationMatrixXY.removeAll(controlCharacterS);

    /* set up test case for combining control character mappings */

    transformationMatrixX.put(controlCharacterP, 65);
    transformationMatrixX.put(controlCharacterP, 67);
    transformationMatrixX.put(controlCharacterQ, 65);
    transformationMatrixX.put(controlCharacterQ, 66);
    transformationMatrixX.put(controlCharacterR, 66);

    transformationMatrixY.put(controlCharacterQ, 66);
    transformationMatrixY.put(controlCharacterR, 66);
    transformationMatrixY.put(controlCharacterS, 68);

    transformationMatrixXY.put(controlCharacterP, 65);
    transformationMatrixXY.put(controlCharacterP, 67);
    transformationMatrixXY.put(controlCharacterQ, 66);
    transformationMatrixXY.put(controlCharacterR, 66);
    transformationMatrixXY.put(controlCharacterS, 68);

    /* choose four non-control characters and remove them from the transformation matrix */

    int[] normalCodePoints = new int[4];
    int index = 0;
    int codePoint = 0;
    while (index < normalCodePoints.length) {
        if (Character.getType(codePoint) != Character.CONTROL) {
            normalCodePoints[index++] = codePoint;
            transformationMatrixXY.removeAll(codePoint);
        }
        codePoint++;
    }
    int normalCharacterP = normalCodePoints[0];
    int normalCharacterQ = normalCodePoints[1];
    int normalCharacterR = normalCodePoints[2];
    int normalCharacterS = normalCodePoints[3];

    /* set up test case for combining non-control character mappings */

    transformationMatrixX.put(normalCharacterP, 65);
    transformationMatrixX.put(normalCharacterP, 67);
    transformationMatrixX.put(normalCharacterQ, 65);
    transformationMatrixX.put(normalCharacterQ, 66);
    transformationMatrixX.put(normalCharacterR, 66);

    transformationMatrixY.put(normalCharacterQ, 66);
    transformationMatrixY.put(normalCharacterR, 66);
    transformationMatrixY.put(normalCharacterS, 68);

    transformationMatrixXY.put(normalCharacterP, 65);
    transformationMatrixXY.put(normalCharacterP, 67);
    transformationMatrixXY.put(normalCharacterQ, 66);
    transformationMatrixXY.put(normalCharacterR, 66);
    transformationMatrixXY.put(normalCharacterS, 68);

    /* set up test cases for combining proscribed strings */

    unsafePrefixesX.add("XP");
    unsafePrefixesX.add("YP");

    unsafePrefixesY.add("YP");
    unsafePrefixesY.add("ZP");

    unsafePrefixesXY.add("XP");
    unsafePrefixesXY.add("YP");
    unsafePrefixesXY.add("ZP");

    unsafeSuffixesX.add("XS");
    unsafeSuffixesX.add("YS");

    unsafeSuffixesY.add("YS");
    unsafeSuffixesY.add("ZS");

    unsafeSuffixesXY.add("XS");
    unsafeSuffixesXY.add("YS");
    unsafeSuffixesXY.add("ZS");

    unsafeNamesX.add("XN");
    unsafeNamesX.add("YN");

    unsafeNamesY.add("YN");
    unsafeNamesY.add("ZN");

    unsafeNamesXY.add("XN");
    unsafeNamesXY.add("YN");
    unsafeNamesXY.add("ZN");

    /* set up test case for combining safe characters */

    safeCharactersX.add('A');
    safeCharactersX.add('B');

    safeCharactersY.add('A');

    safeCharactersXY.add('A');

    /* perform the combination */

    final FilePathRestrictions rulesX = new FilePathRestrictions(transformationMatrixX, unsafePrefixesX,
            unsafeSuffixesX, unsafeNamesX, safeCharactersX);
    final FilePathRestrictions rulesY = new FilePathRestrictions(transformationMatrixY, unsafePrefixesY,
            unsafeSuffixesY, unsafeNamesY, safeCharactersY);
    final FilePathRestrictions rulesXY = FilePathRestrictions.combineFilePathRestrictions(rulesX, rulesY);

    /* test that the combination is as expected in all respects */

    Assert.assertTrue(CollectionUtils.isEqualCollection(rulesXY.safeCharacters, safeCharactersXY));
    Assert.assertTrue(CollectionUtils.isEqualCollection(rulesXY.unsafePrefixes, unsafePrefixesXY));
    Assert.assertTrue(CollectionUtils.isEqualCollection(rulesXY.unsafeSuffixes, unsafeSuffixesXY));
    Assert.assertTrue(CollectionUtils.isEqualCollection(rulesXY.unsafeNames, unsafeNamesXY));
    assertEqualMultimaps(rulesXY.transformationMatrix, transformationMatrixXY);

    /* given a mapping choice, prefer the safe character */

    Assert.assertEquals((int) rulesXY.transformationMap.get(controlCharacterP), 65);
    Assert.assertEquals((int) rulesXY.transformationMap.get(normalCharacterP), 65);
}

---

From source file:gov.va.vinci.leo.ae.ExampleWhitespaceTokenizer.java

/**
 * Given a character c return the type definition from the
 * list of public static type definitions in this class.
 *
 * @param c/*from  w w w  . j  av a2s  .co  m*/
 * @return type definition for the character c
 */
private static int characterType(char c) {
    switch (Character.getType(c)) {
    //letters
    case Character.UPPERCASE_LETTER:
    case Character.LOWERCASE_LETTER:
    case Character.TITLECASE_LETTER:
    case Character.MODIFIER_LETTER:
    case Character.OTHER_LETTER:
    case Character.NON_SPACING_MARK:
    case Character.ENCLOSING_MARK:
    case Character.COMBINING_SPACING_MARK:
    case Character.PRIVATE_USE:
    case Character.SURROGATE:
    case Character.MODIFIER_SYMBOL:
        return TK_LETTER;
    //numbers
    case Character.DECIMAL_DIGIT_NUMBER:
    case Character.LETTER_NUMBER:
    case Character.OTHER_NUMBER:
        return TK_NUMBER;
    //Regular Whitespace
    case Character.SPACE_SEPARATOR:
        return TK_WHITESPACE;
    //Punctuation
    case Character.DASH_PUNCTUATION:
    case Character.START_PUNCTUATION:
    case Character.END_PUNCTUATION:
    case Character.OTHER_PUNCTUATION:
        return TK_PUNCTUATION;
    //Simple NewLine
    case Character.LINE_SEPARATOR:
    case Character.PARAGRAPH_SEPARATOR:
        return TK_NEWLINE;
    //Other types of "control" characters
    case Character.CONTROL:
        if (c == '\n' || c == '\r')
            return TK_NEWLINE;
        if (Character.isWhitespace(c)) //Tab char is a "Control" character
            return TK_WHITESPACE;
        return TK_CONTROL;
    default:
        if (Character.isWhitespace(c)) {
            return TK_WHITESPACE;
        } //if
        return TK_UNKNOWN;
    }//switch
}

---

From source file:ome.services.blitz.test.utests.FilePathRestrictionsTest.java

/**
 * Test that transformation matrices are transitively closed upon combination.
 *//*  w w  w . ja  v  a2  s. c  o  m*/
@Test
public void testTransitiveTransformationClosure() {
    final SetMultimap<Integer, Integer> transformationMatrixX = HashMultimap.create();
    final SetMultimap<Integer, Integer> transformationMatrixY = HashMultimap.create();
    final SetMultimap<Integer, Integer> transformationMatrixZ = HashMultimap.create();
    final SetMultimap<Integer, Integer> transformationMatrixXYZ = HashMultimap.create();

    for (int codePoint = 0; codePoint < 0x100; codePoint++) {
        if (Character.getType(codePoint) == Character.CONTROL) {
            transformationMatrixXYZ.put(codePoint, 90);
        }
    }

    /*
     * 65  66
     *       
     *      67   68
     *          
     *      70   69
     */

    transformationMatrixX.put(65, 66);
    transformationMatrixX.put(65, 67);

    transformationMatrixY.put(66, 67);
    transformationMatrixY.put(66, 68);

    transformationMatrixZ.put(67, 70);
    transformationMatrixZ.put(68, 69);

    transformationMatrixXYZ.put(65, 69);
    transformationMatrixXYZ.put(65, 70);
    transformationMatrixXYZ.put(66, 69);
    transformationMatrixXYZ.put(66, 70);
    transformationMatrixXYZ.put(67, 70);
    transformationMatrixXYZ.put(68, 69);

    final Set<Character> safeCharacters = ImmutableSet.of('Z');

    final FilePathRestrictions rulesX = new FilePathRestrictions(transformationMatrixX, null, null, null,
            safeCharacters);
    final FilePathRestrictions rulesY = new FilePathRestrictions(transformationMatrixY, null, null, null,
            safeCharacters);
    final FilePathRestrictions rulesZ = new FilePathRestrictions(transformationMatrixZ, null, null, null,
            safeCharacters);

    final FilePathRestrictions rulesXYZ = FilePathRestrictions.combineFilePathRestrictions(rulesX, rulesY,
            rulesZ);
    assertEqualMultimaps(rulesXYZ.transformationMatrix, transformationMatrixXYZ);

    final FilePathRestrictions rulesZYX = FilePathRestrictions.combineFilePathRestrictions(rulesZ, rulesY,
            rulesX);
    assertEqualMultimaps(rulesZYX.transformationMatrix, transformationMatrixXYZ);
}

---

From source file:org.opendatakit.services.preferences.fragments.ServerSettingsFragment.java

/**
 * Disallows carriage returns from user entry
 *
 * @return/*  w w w  .  jav a2 s.c om*/
 */
private InputFilter getReturnFilter() {
    InputFilter returnFilter = new InputFilter() {
        public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart,
                int dend) {
            for (int i = start; i < end; i++) {
                if (Character.getType((source.charAt(i))) == Character.CONTROL) {
                    return "";
                }
            }
            return null;
        }
    };
    return returnFilter;
}

---

• «
• 1
• 2
• »