char类型
---- 或 许 在C 语 言 中，最 常 被 滥 用 的 基 本 数 据 类 型 就 是char 类型。 这 一 类 型 常 被 滥 用， 部 分 原 因 是 因为 它 被 定 义 为8 位， 而 在 最 近 的25 年 里，8 个 位 也 就 是 计 算 机 内 存 中， 最 小 的 数据 存 储 单 元。 我 们 把 后 者(8 位 是 计 算 机内 存 中 最 小 的 数 据 存 储 单 元) 和 将ASCII 字符 集 定 义 为7 位 的 情 况 联 系 在 一 起， 就可 以 看 到，char 类 型 俨 然 已 是 一 个 非 常方 便 的“ 通 用 的” 数 据 类 型。 而 且 在C 语言 中， 一 个 指 向char 型 变 量 的 指 针 也 成了 通 用 指 针 类 型， 因 为 所 有 能 够 被 指引 为char 型 的 数 据， 都 可 通 过 计 算， 被 指引 成 为 其 它 类 型 的 数 据。
---- C 语 言 中，char 类 型数 据 的 利 用 和 滥 用， 引 来 了 各 个 编 译工 具 之 间 的 不 兼 容， 因 而ASNI 标 准C 语 言曾 在 两 个 方 面 作 出 过 特 别 改 动： 通 用的 指 针 类 型 被 重 新 定 义 为void 型， 因 此需 要 开 发 者 最 终 对 其 给 出 精 确 的 声明； 字 符 型 数 据 的 值 被 认 为 是 带 符 号的， 它 决 定 了 在 数 值 计 算 中， 字 符 将 被进 行 怎 样 的 处 理。 接 下 来， 在80 年 代 中期， 工 程 师 及 用 户 认 识 到，8 个bit 不 足 以描 述 世 界 上 的 所 有 字 符。 然 而 不 幸 的是， 到 了 那 时，C 语 言 的 某 些 特 性 是 如此 的 根 深 蒂 固， 以 至 于 人 们 不 愿 意， 或许 甚 至 是 不 可 能 改 变 对char 型 数 据 的 定义。 时 光 如 梭， 转 眼 就 到 了90 年 代， 人们 开 始 了Java 的 早 期 探 索。 许 多 的 原 则都 被 制 定 了 出 来， 其 中 一 条 就 是，Java 语言 中 的 字 符 应 该 被 定 义 成16 位。 这 一 决策 支 持 了Unicode 标 准 的 利 用( 该 标 准 描 述了 许 多 语 言 的 各 种 不 同 字 符)， 然 而，它 也 为 许 多 问 题 的 出 现 设 置 了 舞 台，这 些 问 题 只 有 留 到 现 在 才 能 改 正。
究竟什么是字符？
---- 众 所 周 知， 一 个字 符(character) 就 是 一 个 字 母(letter)， 一 串 字母 组 成 一 个 单 词， 一 组 单 词 组 成 句 子，以 此 类 推。 然 而， 事 实 上， 在 计 算 机中， 在 屏 幕 上 描 述 的 字 符( 被 称 为 字 符的 图 符)， 和 为 这 个 字 符 指 定 的 数 值( 被称 为 代 码 值)， 并 不 是 直 接 对 应 的。
---- 在ASCII 中， 定 义 了96 个 可 印 刷 的 字 符， 就 可 以 用 来 书 写 英语。 这 与 定 义 了2 万 多 个 图 符 还 不 足 以表 述 其 所 有 文 字 的 中 文 相 比， 简 直 是天 差 地 别。 从 早 期 的 摩 尔 斯 码 和 波 多码 开 始， 英 语 整 体 的 简 单 性( 较 少 的 图符， 按 统 计 频 率 出 现) 就 使 其 成 为 了 数字 化 时 代 的 一 门 通 用 语 言。 但 是 随 着更 多 的 人 进 入 到 数 字 化 时 代， 随 着 非英 语 国 家 更 多 地 使 用 计 算 机， 越 来 越多 的 人 们 遂 渐 不 能 容 忍 计 算 机 只 能 用ASCII 码 和 只 能 表 述 英 语。 这 极 大 地 增 加 了计 算 机 能 够 理 解 的“ 字 符” 的 数 量。 由此， 人 们 意 识 到， 计 算 机 所 用 的 字 符 编码 位 数 必 须 翻 倍。
---- 当 受 人 尊 敬 的7 位ASCII 码 被 合 并 成 为8 位 的 被 称 为ISO latin-1( 或ISO 8859_1，ISO 表 示 国 际 标 准 化 组 织) 字 符 编 码之 后， 可 利 用 的 字 符 数 量 翻 了 一 倍。 正如 你 可 能 从 这 一 编 码 的 名 字 中 想 到 的一 样， 这 个 标 准 保 证 了 在 计 算 机 上， 许多 的 欧 洲 国 家 可 以 描 述 它 们 的 语 言。然 而， 仅 仅 是 标 准 的 确 立， 还 不 能 意 味着 标 准 的 利 用。 那 时， 许 多 的 计 算 机 产商 为 了 某 些 利 益， 已 经 开 始 利 用 了8 位字 符 中 的 其 它128 个“ 字 符”。 目 前 还 能看 到 的 利 用 这 些 额 外 字 符 的 例 子 有IBM 的 个 人 计 算 机(PC)， 和 曾 一 度 最 为 流 行的 计 算 机 终 端，DEC 公 司 的VT-100。 后 者 在终 端 仿 真 软 件 上 继 续 存 在。
---- 究 竟 何 时 停 止 八位 字 符 的 使 用， 这 一 问 题 将 会 在 以 后的 数 十 年 内 一 直 争 论 下 去， 但 是 何 时提 出 这 一 问 题 却 可 以 做 出 回 答。 我 认为， 从1984 年 引 入Macintosh 计 算 机 时 起， 这一 问 题 就 已 开 始 提 出。Macintosh 为 主 流 计算 机 引 入 了 两 个 革 命 性 的 概 念： 存 储于RAM 中 的 字 符 字 体； 和 可 以 描 述 所 有 语言 所 用 字 符 的 世 界 文 字 体 系(WorldScript)。当 然， 这 其 实 也 只 是Xerox 公 司 所 做 所 为的 一 个 翻 版， 在 它 的 蒲 公 英(Dandelion) 系 列机 器 上， 就 以Star 字 处 理 系 统 的 形 式， 利用 了 这 些 技 术。 然 而， 是Macintosh 把 这 些新 的 字 符 集 和 字 体 带 给 了 还 在 利 用“ 哑” 终 端 的 用 户。 一 旦 有 人 开 了 头， 利用 不 同 字 体 的 做 法 就 无 法 被 终 断 ─ ─ 因 为 许 许 多 多 的 人 们 对 其 爱 不 释 手。到80 年 代 后 期， 为 了 合 理 而 标 准 地 使 用这 些 字 符， 一 个 名 为Unicode 协 会(Unicode Consortium) 的 组 织 应 运 而 生， 并 于1990 年， 发布 了 它 的 第 一 个Unicode 规 范。 然 而 不 幸 的是， 在80 年 代 甚 至 在 进 入90 年 代 之 后， 字符 集 的 数 量 在 成 倍 的 增 长， 在 那 时， 几乎 正 在 从 事 新 字 符 编 码 的 所 有 工 程师， 都 认 为 刚 刚 上 步 的Unicode 标 准 不 会 长久， 因 而， 他 们 为 各 种 文 字， 创 建 了 与他 人 各 不 相 同 的 编 码。 然 而， 即 使 是 在Unicode 不 被 广 泛 采 纳 的 情 况 下， 那 种 认 为 只有128 个 或 最 多256 个 字 符 能 被 采 用 的 观 念已 不 复 存 在。 在Macintosh 之 后， 对 不 同 字体 的 支 持 已 成 为 字 处 理 系 统 中 不 可 缺少 的 功 能。 八 位 字 符 正 在 消 褪， 遂 渐 消亡。
Java和Unicode
---- Java 的 基 本 的char 类型 被 定 义 成 无 符 号 的16 位， 它 是Java 中 唯一 的 一 个 无 符 号 类 型。 使 用16 位 字 符 的原 因 是 要 让Java 能 够 支 持 任 何Unicode 字 符，由 此 使 得Java 适 用 于 描 述 或 显 示 任 何 被Unicode 支 持 的 语 言。 但 是， 能 够 支 持 某 种 语 言的 字 符 串 显 示 和 能 够 打 印 某 种 语 言 的字 符 串 常 常 是 两 个 不 同 的 问 题。 由 于Oak（Java 最 初 的 代 号） 开 发 组 的 主 要 环 境 是Unix 系 统 和 某 些 源 于Unix 的 系 统， 所 以 对 开发 人 员 来 讲， 最 为 方 便 实 用 的 字 符 集仍 然 是ISO Latin-1。 相 应 地， 这 一 开 发 组 所带 有 的Unix 遗 传 性， 导 致 了Java 的I/O 系 统 在很 大 程 度 上 以Unix 的 流 概 念 为 模 型， 而在Unix 系 统 中， 每 一 种I/O 设 备 都 可 以 用 一串8 比 特 的 流 来 表 示。 这 种 在I/O 系 统 方面 取 模 于Unix 的 做 法， 使 得Java 语 言 拥 有16 位 的Java 字 符， 而 却 只 有8 位 的 输 入 设备， 这 多 少 给Java 带 来 了 些 遗 憾。 因 此 在任 何 一 处Java 字 符 串 按8 位 来 读 入 或 写 出的 地 方， 都 有 一 小 段 程 序 代 码， 被 称为“ 劈(hack)”， 来 将8 位 的 字 符 映 射 成 为16 位Unicode， 或 将16 位 的Unicode 劈 成8 位 字 符。
---- 在1.0 版 本 的Java 开发 套 件(JDK) 中， 输 入 劈(input hack) 在DataInputStrean 类 中， 而 输 出 劈(output hack) 则 是 整 个 的PrintStream 类。( 实 际 上， 在Java 的alpha 2 版 本 中， 有 着一 个 名 为TextInputStream 的 输 入 类， 但 在 正 式发 布 的 时 候， 这 个 类 被DataInputStream 劈 所 取代。) 这 也 为 初 学Java 的 开 发 人 员 带 来 了一 些 麻 烦， 因 为 他 们 每 每 急 不 可 耐 地在Java 中 搜 索 与C 语 言 中 的getc() 函 数 相 应的 函 数。 请 参 看 下 面 的Java 1.0 程 序：
import java.io.*;
public class bogus {
public static void main(String args[]) {
FileInputStream fis;
DataInputStream dis;
char c;
try {
fis = new FileInputStream("data.txt");
dis = new DataInputStream(fis);
while (true) {
c = dis.readChar();
System.out.print(c);
System.out.flush();
if (c == '/n') break;
}
fis.close();
} catch (Exception e) { }
System.exit(0);
}
}
---- 初 略 一 看， 这 一程 序 应 该 完 成 的 功 能 是 打 开 一 个 文件， 每 次 读 取 并 输 出 一 个 字 符， 并 在 读完 一 行 字 符 串 之 后 退 出。 然 而 实 际 上，运 行 这 一 程 序， 你 所 能 得 到 的 输 出 结果 只 能 得 到 一 堆 没 用 的 垃 圾。 而 你 不能 正 确 输 出data.txt 文 件 的 原 因 是，readChar 函 数 读 入 的 是16 位 的Unicode 字 符， 而System.out.print 却 将 其 当 作 八 位 的ISO latin-1 字 符 输 出。 然而， 如 果 你 修 改 了 上 面 的 程 序， 利 用 了DataInputStream 的readLine 函 数， 那 么 程 序 就 会 正 常 运 转。因 为readLine 的 代 码 是 按 符 合Unicode 规 范 的、名 为“ 修 订 的UTF-8” 的 格 式 读 入 的。(UTF-8 是Unicode 规 定 的， 在8 位 输 入 流 中 表 示Unicode 字 符 的 格 式。) 所 以， 在Java 1.0 中，Java 字 符串 是 由16 位 的Unicode 字 符 组 成 的， 但 是，只 有 一 个 对 照 表 可 以 将ISO Latin-1 字 符 映射 为Unicode。 幸 运 的 是，Unicode 定 义 的“0” 页 面 编 码 ─ ─ 也 就 是 那256 个 高8 位 全 为0 的 字 符 ─ ─ 完 全 和ISO Latin-1 字 符 集 一 一对 应。 因 此， 将 二 者 进 行 映 射 对 照 是 十分 容 易 的， 而 且 如 果 你 使 用 的 仅 仅 是ISO Latin-1 字 符 文 件， 那 么， 当 你 利 用Java 类，将 这 些 文 件 读 出 并 进 行 各 种 操 作， 然后 重 新 写 入 到 一 个 文 件 中， 在 这 一 整个 过 程 中， 都 不 会 出 现 问 题。
---- 有 两 种 情 况 可 能会 使 输 入 编 码 转 换 失 败： 并 不 是 所 有的 平 台 都 以“ 修 订 的UTF-8” 格 式 存 储 他们 的 多 文 种 文 件； 另 外， 这 些 平 台 上 的应 用 程 序 并 不 可 能 判 断 这 种 格 式 中 的字 符 是 不 是 非 拉 丁 字 符。 因 此， 在 此 问题 上，Java 的 实 现 是 不 完 整 的， 而 且， 在后 来 的 版 本 中， 想 要 提 供 所 需 的 支 持也 是 很 困 难 的。
Java 1.1 和Unicode
---- Java 1.1 版 本 引 入 了一 套 全 新 的， 名 为Readers 和Writers 的 接 口 来处 理 字 符。 我 将 前 文 所 述 的bogus 类 另 取名 为cool 类。 这 个cool 类 利 用InputStreamReader 类而 不 是DataInputStream 来 处 理 文 件。 请 注 意，InputStreamReader 是 新 的Reader 类 的 子 类， 而 且System.out 现 在是 一 个PrintWriter 对 象， 而PrintWriter 是Writer 类的 一 个 子 类。 下 面 是 这 个 例 子 的 代 码：
import java.io.*;
public class cool {
public static void main(String args[]) {
FileInputStream fis;
InputStreamReader irs;
char c;
try {
fis = new FileInputStream("data.txt");
irs = new InputStreamReader(fis);
System.out.println("Using encoding : "+irs.getEncoding());
while (true) {
c = (char) irs.read();
System.out.print(c);
System.out.flush();
if (c == '/n') break;
}
fis.close();
} catch (Exception e) { }
System.exit(0);
}
}
---- 这 个 例 子 和 前 一个 例 子 的 主 要 差 别 在 于 此 处 利 用 了InputStreamReader 类 而 前 一 个 例 子 用 的 是DataInputStream 类。 另外， 这 个 例 子 较 前 一 个 例 子 还 增 加 了一 行 程 序， 它 输 出InputStreamReader 类 所 用 的编 码 方 式。
---- 关 键 的 一 点 是，原 有 的 一 些 代 码( 这 些 代 码 存 在 于DataInputStream 类 的getChar 方 法 之 内， 没 有 文 件 说 明 并 不能 从 表 面 上 看 到) 已 经 被 删 除( 更 确 切 地说， 是 它 的 应 用 倍 受 抨 击； 在 将 来 的 版本 中 将 被 删 除)。 在Java 1.1 版 本 中， 进 行转 换 的 机 制 现 已 被 封 装 到Reader 类 中。 这种 封 装 提 供 了 一 种 在 内 部 使 用Unicode 的情 况 下， 通 过Java 类 库 来 支 持 各 种 非 拉丁 语 字 符 的 方 法。
---- 当 然， 和 最 初 的子 系 统 设 计 一 样， 存 在 着 一 些 与“ 读” 类 对 相 应 的 类 来 完 成 写“ 写”。 例 如，OutputStreamWriter 类 可 以 被 用 来 向 输 出 流 中 写 入 字 符串， 而BufferedWriter 可 为 数 据 的 写 增 加 一 层缓 冲。
商业上的肉瘤还是真正的进步?
---- 设 计Reader 和Writer 类有 一 个 玄 虚 的 目 标， 就 是 希 望 提 供 一种 标 准 方 法， 使 得 以 前 各 种 机 器 所 使用 的 字 符( 不 论 是Macintosh 的 希 腊 文， 还 是Windows 的 西 里 尔 语) 都 可 以 和Unicode 进 行 方 便 地转 换。 这 也 意 味 着， 当 从 一 个 平 台 向 另一 个 平 台 移 植 的 时 候， 处 理 字 符 串 的Java 类 就 不 必 再 做 任 何 改 变。 现 在， 既 然 转换 代 码 已 被 封 装 了， 那 么 要 讨 论 的 问题 就 是 那 些 编 码 意 味 着 什 么。
---- 在 构 思 本 文 的 时候， 我 想 到 了 一 个Xerox 执 行 官( 其 实 是 在Xerox 公 司 成 立 之 前， 当 时 的Xerox 公 司 名 为Haloid 公 司) 所 说 过 的 一 段 名 言， 他 主 要 说 复印 机 是 多 余 的， 因 为 一 个 秘 书 可 以 非常 方 便 地 将 复 印 纸 放 入 到 打 字 机 中，并 在 她 创 建 原 件 的 时 候， 得 到 一 份 复印 件。 当 然， 这 种 看 法 是 缺 乏 先 见 之 明的， 复 印 机 给 那 些 接 收 文 件 的 人 带 的好 处 远 远 多 于 那 些 创 建 文 件 的 人。JavaSoft 的 设 计 人 员 在 设 计 字 符 编 码 和 解 码 类方 面， 同 样 地 表 现 出 对 系 统 的 该 部 分缺 乏 足 够 的 先 见 之 明。
---- 在Haloid 公 司， 执 行官 员 主 要 关 注 的 是 复 印 件 的 产 生 过程， 而 不 去 考 虑 那 些 已 有 复 印 件 的 人的 方 便 情 况。 同 样 地， 在Java 中， 这 些 类主 要 关 注 的 是 将Unicode 字 符 转 换 为 本 地的 下 层 平 台( 也 就 是 那 个 可 以 运 行Java 虚拟 处 理 机 的 平 台) 能 够 理 解 的 字 符 形式。InputStringReader 类 的 典 型( 而 且 最 为 容 易的) 应 用 就 如 上 例 所 示， 只 要 在 字 节 流的 周 围 实 例 化 一 个 读 入 对 象(reader) 即可。 对 于 磁 盘 文 件， 其 处 理 过 程 就 是 将流 引 入 到 名 为FileReader 的 类 中。 典 型 情 况下， 当 该 类 被 实 例 化 的 时 候， 它 将 会 为其 所 在 的 平 台 设 置 缺 省 的 编 码 器。 在Windows 和Unix 环 境 下， 可 能 设 置 的 编 码 器 是“8859_1” ─ ─ 或 是 读 入ISO Latin-1 文 件， 并 将 其 转 换为Unicode 的 编 码 器。 然 而， 正 如 复 印 机 的应 用 一 样， 在 字 符 转 换 方 面， 还 需 要 另一 种 应 用 功 能， 也 就 是 从 其 它 平 台 上读 取 字 符， 将 其 转 换 为Unicode， 然 后 再 将Unicode 转 换 为 本 地 平 台 的 字 符。 在 后 面 的 文章 中， 我 会 让 大 家 看 到 在 现 在 的Java 设计 中， 完 全 没 有 这 一 功 能( 即 多 平 台 转换 的 功 能)。
---- 除 了“8859_1” 之外， 还 有 其 它 的 编 码 器 ─ ─ 那 些 在JIS( 日 文) 字 符 和Unicode 之 间 进 行 转 换， 在 汉字 和Unicode 之 间 进 行 转 换 等 等 的 编 码 器。然 而， 看 一 看 与JDK 一 起 发 布 的 文 献( 同样 可 以 从JavaSoft 的Web 站 点 得 到)， 你 根 本就 不 可 能 找 到 有 关 其 它 编 码 器 的 记载。 而 且 没 有 明 确 的API 可 以 使 你 列 举 出可 用 到 的 编 码 器。 唯 一 可 以 真 正 了 解可 用 到 的 编 码 器 的 办 法 是 阅 读InputStreamReader 的 源 程 序 代 码。 而 不 幸 的 是， 阅 读 这 些代 码 的 感 觉， 就 如 让 你 去 打 开 一 个 新的 瘤 子 一 样。
---- 在InputStreamReader 的 源文 件 中， 完 成 转 换 功 能 的 代 码 被 封 装在Sun 专 有 的 名 为sun.io.ByteToCharConverter 的 类中。 与 所 有 的Sun 类 一 样， 有 关 这 个 类 的源 代 码 在JDK 中 不 能 得 到， 在 文 献 中 也 没有 记 载。 因 此， 这 个 类 实 际 上 干 什 么 简直 就 是 一 团 密。 所 幸 的 是， 我 们 能 够 从Sun 那 里 得 到 整 个JDK 的 源 代 码， 并 通 过 它 来看 这 个 类 都 在 做 什 么。InputStreamReader 有 一个 构 造 函 数， 它 以 一 个 字 符 串 为 名， 来指 明 采 用 什 么 编 码 器。 在Sun 的 实 现 中，这 个 字 符 串 被 粘 贴 到“sun.io.ByteToCharXXX” 的模 板 中， 并 将 这 个 模 板 中 的“XXX” 部 分以 你 传 给 构 造 函 数 的 字 符 串 替 代。 接着 查 看 压 缩 在classes.zip 文 件 中 的 类， 其中， 你 可 以 识 别 几 个 名 字 如ByteToChar8859_1，ByteToCharCP1255 之 类 的 编 码 器。 同 样， 由 于 这 几 个 类 都是Sun 的 类， 因 此 它 们 没 有 文 献 记 载。 然而， 你 可 以 在JavaSoft 的Web 站 点 上 找 到 以Internationalization Specification( 国 际 化 规 范) 形 式 出 现 的 一 些旧 文 献。 在 这 些 文 献 中， 有 一 页 描 述 了Sun 所 支 持 的 大 多 数( 如 果 不 是 全 部 的 话) 编码 器。 这 一 页 的 连 接 点 可 以 在 本 文 的资 源 部 分 找 到。 前 文 我 提 到 的 那 个 问题， 也 就 预 示 着， 这 样 的 一 种 体 系 结 构不 允 许 你 去 增 加 你 自 已 的 转 换 器。
---- 我 认 为 这 种 设 计有 缺 陷 主 要 有 以 下 两 个 方 面 的 原 因：除 了 基 本 的 本 地 平 台 字 符 到Unicode 字 符的 转 换 外， 这 种 设 计 没 有 提 出 统 一 的Java 平 台 需 要 支 持 任 何 转 换 器 的 要 求； 而且 没 有 什 么 方 法 来 列 举 它 所 支 持 的 转换 器。 这 意 味 着， 编 写 这 些 代 码 的 人 心中 已 理 所 当 然 地 认 为， 存 在 于 某 个 平台 上 的 数 据 文 件， 就 是 在 这 个 平 台 上创 建 的 文 件。 然 而， 就 目 前 来 看， 你 想读 的、 存 在 于 异 构 硬 件 上 的、 与Internet 相关 的 文 件， 在 很 多 情 况 下 是 并 不 是 创建 于 本 地 平 台 的 文 件， 因 而 需 要 特 别的 编 码 器。 这 种 需 求 导 致 了 这 一 系 统的 最 终 问 题。
---- 现 在， 让 我 们 假设， 在 你 的Java 应 用 程 序 中， 你 想 要 读( 或 进 行 分 析) 的 文 件 来 自 于 非 本 地 平 台 ─ ─ 我 们 设 想 它 来 自 于 一 个Commodore-64 平台。Commodore 利 用 它 自 已 修 订 过 的ASCII 字 符集， 因 而 为 了 读 出， 并 且 将Commodore-64 文 件转 换 为Unicode， 我 必 须 利 用 一 个 特 别 的，能 够 理 解Commodore 字 符 格 式 的ByteToChar 子 类。尽 管Reader 类 的 设 计 能 够 允 许 你 做 到 这点， 但 是 在 这 一 设 计 的JDK 实 现 中， 字 符转 换 所 需 要 的 类 是Sun 私 有 的sun.io 包 的 一部 分。 因 而， 我 必 须 只 能 用 这 个 没 有 文献 描 述 的 接 口。 而 且， 为 了 让 我 的 转 换器 工 作， 我 必 须 将 它 装 到sun.io 包 中。 就如Xerox 例 子 中 所 看 到 的 一 样， 这 一 系 统的 大 多 数 客 户 都 是 很 有 编 程 水 准 的 用户， 他 们 支 持 利 用 以 前 系 统 遗 留 下 来的 数 据。 这 些 用 户 被 迫 绕 过 这 个 特 殊的 瘤 子。 然 而， 即 使 能 够 处 理 这 些 数 据也 算 是 一 个 好 消 息 了， 在 很 大 程 度 上，我 们 已 经 取 得 了 一 些 进 展。
总结
---- Java， 与C 语 言 不 一样， 明 确 地 要 求char 型 变 量 的 值 能 够 被当 作Unicode 字 符 处 理。 它 将 字 符 的 数 值 与它 们 的 图 符 结 合 了 起 来。 这 一 观 念， 尽管 简 单， 但 是 那 些 具 有 丰 富 经 验 的 程序 员 常 常 不 能 够 完 全 适 应。 对 于 这 些程 序 员 来 说， 编 写 在 非 英 语 字 符 串 环境 下 运 行 的 程 序， 这 还 是 头 一 次 遇 到。另 外， 将 世 界 上 的 各 种 语 言 编 篡 成 典，还 需 要 做 很 多 的 事 件， 这 一 工 作 的 结果 就 是Unicode 字 符 标 准。 在Unicode 的 主 页上， 读 者 可 以 得 到 更 多 有 关Unicode 以 及Unicode 字 符 与 编 码 值 的 对 应 信 息。
---- 最 后， 因 为 语 言和 字 符 串 的 结 合 情 况 在Java 1.1 中 已 更 为清 楚 了， 所 以Java 程 序 员 被 迫 考 虑 使 用其 它 的 方 法， 来 在 他 们 运 行 的 平 台 上描 述 字 符。 这 种 全 球 化 的 设 计， 表 示 着人 们 在 利 用 各 自 最 适 合 的 语 言 来 使 用计 算 机 这 一 方 面， 取 得 了 积 极 进 展。
来源:http://www.qhd.com.cn/qgwl/java/i71.htm
658
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
