Take the input character and normalize based on this normalizer instance.

@param currentChar
@return char (normalized based on settings)
324331
public char normalize(char currentChar) {
        if (NORMALIZE_UPPER == getNormalization()) {
            return toUpper(currentChar);
        }
        if (NORMALIZE_LOWER == getNormalization()) {
            return toLower(currentChar);
        }
        return currentChar;
    }
713101
private char stringChar() throws JsonParserException {
    int c = advanceChar();
    if (c == -1)
      throw createParseException(null, "String was not terminated before end of input", true);
    if (c < 32)
      throw createParseException(null,
          "Strings may not contain control characters: 0x" + Integer.toString(c, 16), false);
    return (char)c;
  }
942660
public static String normalize(CharSequence src, Form form) {
      switch (form) {
        case NFD: return normalizeNFD(src.toString());
        case NFC: return normalizeNFC(src.toString());
        case NFKD: return normalizeNFKD(src.toString());
        case NFKC: return normalizeNFKC(src.toString());
        default:
          throw new AssertionError("unknown Form: " + form);
      }
    }
263809
public char getChar( String key, char defaultValue )
        throws MissingResourceException
    {
        try
        {
            return getChar( key );
        }
        catch( MissingResourceException mre )
        {
            return defaultValue;
        }
    }
593715
public char parseChar(String name) {
        String property = getProperties().getProperty(name);
        if (property.length() != 1) {
            throw new IllegalArgumentException(name + " property is't char");
        }
        return property.charAt(0);
    }
775024
protected char getCurrentCharacter(int current, char[] cc, PdfChunk[] ck) {
    	if (ck == null) {
    		return cc[current];
    	}
    	return (char)ck[Math.min(current, ck.length - 1)].getUnicodeEquivalent(cc[current]);
    }
838850
@SuppressWarnings("SameParameterValue")
    public TextCharacter withCharacter(char character) {
        if(this.character == character) {
            return this;
        }
        return new TextCharacter(character, foregroundColor, backgroundColor, modifiers);
    }
128988
public Charset getCharset(Charset defaultCharset) {
        String contentType = getHeader(HttpHeaders.NAME_CONTENT_TYPE);
        if (contentType == null) {
            return defaultCharset;
        }
        String[] items = contentType.split(";");
        for (String item : items) {
            item = item.trim();
            if (item.isEmpty()) {
                continue;
            }
            int idx = item.indexOf('=');
            if (idx < 0) {
                continue;
            }
            String key = item.substring(0, idx).trim();
            if (key.equalsIgnoreCase("charset")) {
                try {
                    return Charset.forName(item.substring(idx + 1).trim());
                } catch (IllegalCharsetNameException | UnsupportedCharsetException e) {
                    return defaultCharset;
                }
            }
        }
        return defaultCharset;
    }
309069
protected function getCurrentChar()
    {
        $c = substr($this->data, $this->p, 1);

        if ($c === "\n") {
            ++$this->line;
            $this->col = 1;
        } else {
            ++$this->col;
        }

        return $c;
    }
1058578
public Charset charset(Charset defaultValue) {
        return charset != null ? Charset.forName(charset) : defaultValue;
    }
1310348
public static String normalize(final String token) {
    String normalizedToken = "";

    char currentCharacter;
    int prevCharType = -1;
    char charType = '~';
    boolean addedStar = false;
    for (int i = 0; i < token.length(); i++) {

      currentCharacter = token.charAt(i);
      if (currentCharacter >= 'A' && currentCharacter <= 'Z') {
        charType = 'X';
      } else if (currentCharacter >= 'a' && currentCharacter <= 'z') {
        charType = 'x';
      } else if (currentCharacter >= '0' && currentCharacter <= '9') {
        charType = 'd';
      } else {
        charType = currentCharacter;
      }

      if (charType == prevCharType) {
        if (!addedStar) {
          normalizedToken += "*";
          addedStar = true;
        }
      } else {
        addedStar = false;
        normalizedToken += charType;
      }
      prevCharType = charType;
    }
    return normalizedToken;
  }
990188
private String normalise(String str) {
		str = str.replaceAll("\\s+", " ");
		str = tc.toSimp(str);
		str = ChineseTrans.toHalfWidth(str);
		return str;
	}
32404
public String normalize(CharSequence src) {
        if(src instanceof String) {
            // Fastpath: Do not construct a new String if the src is a String
            // and is already normalized.
            int spanLength=spanQuickCheckYes(src);
            if(spanLength==src.length()) {
                return (String)src;
            }
            StringBuilder sb=new StringBuilder(src.length()).append(src, 0, spanLength);
            return normalizeSecondAndAppend(sb, src.subSequence(spanLength, src.length())).toString();
        }
        return normalize(src, new StringBuilder(src.length())).toString();
    }
837530
@Override
    protected final char nextGoodChar() {
        char c = nextChar();
        if (c > ' ' || c == 0) return c; // 0 表示buffer结尾了
        for (;;) {
            c = nextChar();
            if (c > ' ' || c == 0) return c;
        }
    }
605364
public static String normalizeCharset(String s) {
        String n = CHARSETS.get(s);
        return (n == null) ? s : n;
    }
116886
public static Character readCharacter(String value, Character defaultValue) {
		if (!StringUtils.hasText(value)) return defaultValue;
		
		return Character.valueOf((char)Integer.parseInt(value));
	}
457271
@Ensures({
    "!allowEOF ? result >= 0 : result >= -1"
  })
  protected int readChar(boolean allowEOF) throws IOException {
    int c = reader.read();
    if (c != -1) {
      ++currentOffset;
    } else {
      if (!allowEOF) {
        throw new IOException();
      }
    }
    return c;
  }