[ 转 ]Java 面 试 题 集 (1-50) 下 面 的 内 容 是 对 网 上 原 有 的 Java 面 试 题 集 及 答 案 进 行 了 全 面 修 订 之 后 给 出 的 负 责 任 的 题 目 和 答 案, 原 来 的 题 目 中 有 很 多 重 复 题 目 和 无 价 值 的 题 目, 还 有 不 少 的 参 考 答 案 也 是 错 误 的, 修 改 后 的 Java 面 试 题 集 参 照 了 JDK 最 新 版 本, 去 掉 了 EJB 2.x 等 无 用 内 容, 补 充 了 数 据 结 构 和 算 法 相 关 的 题 目 经 典 面 试 编 程 题 大 型 网 站 技 术 架 构 操 作 系 统 数 据 库 软 件 测 试 设 计 模 式 UML 等 内 容, 同 时 还 对 很 多 知 识 点 进 行 了 深 入 的 剖 析, 例 如 hashcode 方 法 的 设 计 垃 圾 收 集 的 堆 和 代 Java 新 的 并 发 编 程 NIO.2 等, 相 信 对 准 备 入 职 的 Java 程 序 员 一 定 有 所 裨 益 Java 程 序 员 面 试 题 集 (1-50) 一 Java 基 础 部 分 1 面 向 对 象 的 特 征 有 哪 些 方 面? 答 : 面 向 对 象 的 特 征 主 要 有 以 下 几 个 方 面 : 1) 抽 象 : 抽 象 是 将 一 类 对 象 的 共 同 特 征 总 结 出 来 构 造 类 的 过 程, 包 括 数 据 抽 象 和 行 为 抽 象 两 方 面 抽 象 只 关 注 对 象 有 哪 些 属 性 和 行 为, 并 不 关 注 这 些 行 为 的 细 节 是 什 么 2) 继 承 : 继 承 是 从 已 有 类 得 到 继 承 信 息 创 建 新 类 的 过 程 提 供 继 承 信 息 的 类 被 称 为 父 类 ( 超 类 基 类 ); 得 到 继 承 信 息 的 类 被 称 为 子 类 ( 派 生 类 ) 继 承 让 变 化 中 的 软 件 系 统 有 了 一 定 的 延 续 性, 同 时 继 承 也 是 封 装 程 序 中 可 变 因
素 的 重 要 手 段 ( 如 果 不 能 理 解 请 阅 读 阎 宏 博 士 的 Java 与 模 式 或 设 计 模 式 精 解 中 关 于 桥 梁 模 式 的 部 分 ) 3) 封 装 : 通 常 认 为 封 装 是 把 数 据 和 操 作 数 据 的 方 法 绑 定 起 来, 对 数 据 的 访 问 只 能 通 过 已 定 义 的 接 口 面 向 对 象 的 本 质 就 是 将 现 实 世 界 描 绘 成 一 系 列 完 全 自 治 封 闭 的 对 象 我 们 在 类 中 编 写 的 方 法 就 是 对 实 现 细 节 的 一 种 封 装 ; 我 们 编 写 一 个 类 就 是 对 数 据 和 数 据 操 作 的 封 装 可 以 说, 封 装 就 是 隐 藏 一 切 可 隐 藏 的 东 西, 只 向 外 界 提 供 最 简 单 的 编 程 接 口 ( 可 以 想 想 普 通 洗 衣 机 和 全 自 动 洗 衣 机 的 差 别, 明 显 全 自 动 洗 衣 机 封 装 更 好 因 此 操 作 起 来 更 简 单 ; 我 们 现 在 使 用 的 智 能 手 机 也 是 封 装 得 足 够 好 的, 因 为 几 个 按 键 就 搞 定 了 所 有 的 事 情 ) 4) 多 态 性 : 多 态 性 是 指 允 许 不 同 子 类 型 的 对 象 对 同 一 消 息 作 出 不 同 的 响 应 简 单 的 说 就 是 用 同 样 的 对 象 引 用 调 用 同 样 的 方 法 但 是 做 了 不 同 的 事 情 多 态 性 分 为 编 译 时 的 多 态 性 和 运 行 时 的 多 态 性 如 果 将 对 象 的 方 法 视 为 对 象 向 外 界 提 供 的 服 务, 那 么 运 行 时 的 多 态 性 可 以 解 释 为 : 当 A 系 统 访 问 B 系 统 提 供 的 服 务 时,B 系 统 有 多 种 提 供 服 务 的 方 式, 但 一 切 对 A 系 统 来 说 都 是 透 明 的 ( 就 像 电 动 剃 须 刀 是 A 系 统, 它 的 供 电 系 统 是 B 系 统,B 系 统 可 以 使 用 电 池 供 电 或 者 用 交 流 电, 甚 至 还 有 可 能 是 太 阳 能,A 系 统 只 会 通 过 B 类 对 象 调 用 供 电 的 方 法, 但 并 不 知 道 供 电 系 统 的 底 层 实 现 是 什 么, 究 竟 通 过 何 种 方 式 获 得 了 动 力 ) 方 法 重 载 (overload) 实 现 的 是 编 译 时 的 多 态 性 ( 也 称 为 前 绑 定 ), 而 方 法 重 写 (override) 实 现 的 是 运 行 时 的 多 态 性 ( 也 称 为 后 绑 定 ) 运 行 时 的 多 态 是 面 向 对 象 最 精 髓 的 东 西, 要 实 现 多 态 需 要 做 两 件 事 :1. 方 法 重 写 ( 子 类 继 承 父 类 并 重 写 父 类 中 已 有 的 或 抽 象 的 方 法 );2. 对 象 造 型 ( 用 父 类 型 引 用 引 用 子 类 型 对 象, 这 样 同 样 的 引 用 调 用 同 样 的 方 法 就 会 根 据 子 类 对 象 的 不 同 而 表 现 出 不 同 的 行 为 ) 2 访 问 修 饰 符 public,private,protected, 以 及 不 写 ( 默 认 ) 时 的 区 别?
答 : 区 别 如 下 : 作 用 域 当 前 类 同 包 子 类 其 他 public protected default private 类 的 成 员 不 写 访 问 修 饰 时 默 认 为 default 默 认 对 于 同 一 个 包 中 的 其 他 类 相 当 于 公 开 (public), 对 于 不 是 同 一 个 包 中 的 其 他 类 相 当 于 私 有 (private) 受 保 护 (protected) 对 子 类 相 当 于 公 开, 对 不 是 同 一 包 中 的 没 有 父 子 关 系 的 类 相 当 于 私 有 3 String 是 最 基 本 的 数 据 类 型 吗? 答 : 不 是 Java 中 的 基 本 数 据 类 型 只 有 8 个 :byte short int long float double char boolean; 除 了 基 本 类 型 (primitive type) 和 枚 举 类 型 (enumeration type), 剩 下 的 都 是 引 用 类 型 (reference type) 4 float f=3.4; 是 否 正 确? 答 : 不 正 确 3.4 是 双 精 度 数, 将 双 精 (double) 度 型 赋 值 给 浮 点 型 (float) 属 于
下 转 型 (down-casting, 也 称 为 窄 化 ) 会 造 成 精 度 损 失, 因 此 需 要 强 制 类 型 转 换 float f =(float)3.4; 或 者 写 成 float f =3.4F; 5 short s1 = 1; s1 = s1 + 1; 有 错 吗?short s1 = 1; s1 += 1; 有 错 吗? 答 : 对 于 short s1 = 1; s1 = s1 + 1; 由 于 1 是 int 类 型, 因 此 s1+1 运 算 结 果 也 是 int 型, 需 要 强 制 转 换 类 型 才 能 赋 值 给 short 型 而 short s1 = 1; s1 += 1; 可 以 正 确 编 译, 因 为 s1+= 1; 相 当 于 s1 = (short)(s1 + 1); 其 中 有 隐 含 的 强 制 类 型 转 换 6 Java 有 没 有 goto? 答 :goto 是 Java 中 的 保 留 字, 在 目 前 版 本 的 Java 中 没 有 使 用 ( 根 据 James Gosling(Java 之 父 ) 编 写 的 The Java Programming Language 一 书 的 附 录 中 给 出 了 一 个 Java 关 键 字 列 表, 其 中 有 goto 和 const, 但 是 这 两 个 是 目 前 无 法 使 用 的 关 键 字, 因 此 有 些 地 方 将 其 称 之 为 保 留 字, 其 实 保 留 字 这 个 词 应 该 有 更 广 泛 的 意 义, 因 为 熟 悉 C 语 言 的 程 序 员 都 知 道, 在 系 统 类 库 中 使 用 过 的 有 特 殊 意 义 的 单 词 或 单 词 的 组 合 都 被 视 为 保 留 字 ) 7 int 和 Integer 有 什 么 区 别? 答 :Java 是 一 个 近 乎 纯 洁 的 面 向 对 象 编 程 语 言, 但 是 为 了 编 程 的 方 便 还 是 引 入 不 是 对 象 的 基 本 数 据 类 型, 但 是 为 了 能 够 将 这 些 基 本 数 据 类 型 当 成 对 象 操 作,Java 为 每 一 个 基 本 数 据 类 型 都 引 入 了 对 应 的 包 装 类 型 (wrapper
class),int 的 包 装 类 就 是 Integer, 从 JDK 1.5 开 始 引 入 了 自 动 装 箱 / 拆 箱 机 制, 使 得 二 者 可 以 相 互 转 换 Java 为 每 个 原 始 类 型 提 供 了 包 装 类 型 : 原 始 类 型 : boolean,char,byte,short,int,long,float,double 包 装 类 型 :Boolean,Character,Byte,Short,Integer,Long,Float,Double package com.lovo; public class AutoUnboxingTest { public static void main(string[] args) { Integer a = new Integer(3); Integer b = 3; 箱 成 Integer 类 型 int c = 3; System.out.println(a == b); 用 同 一 对 象 System.out.println(a == c); 类 型 再 和 c 比 较 // 将 3 自 动 装 // false 两 个 引 用 没 有 引 // true a 自 动 拆 箱 成 int 补 充 : 最 近 还 遇 到 一 个 面 试 题, 也 是 和 自 动 装 箱 和 拆 箱 相 关 的, 代 码 如 下 所 示 : public class Test03 { public static void main(string[] args) { Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150; System.out.println(f1 == f2); System.out.println(f3 == f4);
如 果 不 明 就 里 很 容 易 认 为 两 个 输 出 要 么 都 是 true 要 么 都 是 false 首 先 需 要 注 意 的 是 f1 f2 f3 f4 四 个 变 量 都 是 Integer 对 象, 所 以 下 面 的 == 运 算 比 较 的 不 是 值 而 是 引 用 装 箱 的 本 质 是 什 么 呢? 当 我 们 给 一 个 Integer 对 象 赋 一 个 int 值 的 时 候, 会 调 用 Integer 类 的 静 态 方 法 valueof, 如 果 看 看 valueof 的 源 代 码 就 知 道 发 生 了 什 么 public static Integer valueof(int i) { if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); IntegerCache 是 Integer 的 内 部 类, 其 代 码 如 下 所 示 : /** * Cache to support the object identity semantics of autoboxing for values between * -128 and 127 (inclusive) as required by JLS. * * The cache is initialized on first usage. The size of the cache * may be controlled by the {@code -XX:AutoBoxCacheMax=<size> option. * During VM initialization, java.lang.integer.integercache.high property * may be set and saved in the private system properties in the * sun.misc.vm class. */ private static class IntegerCache { static final int low = -128; static final int high; static final Integer cache[];
static { // high value may be configured by property int h = 127; String integercachehighpropvalue = sun.misc.vm.getsavedproperty("java.lang.integer.integercache.high"); if (integercachehighpropvalue!= null) { try { int i = parseint(integercachehighpropvalue); i = Math.max(i, 127); // Maximum array size is Integer.MAX_VALUE h = Math.min(i, Integer.MAX_VALUE - (-low) -1); catch( NumberFormatException nfe) { // If the property cannot be parsed into an int, ignore it. high = h; cache = new Integer[(high - low) + 1]; int j = low; for(int k = 0; k < cache.length; k++) cache[k] = new Integer(j++); // range [-128, 127] must be interned (JLS7 5.1.7) assert IntegerCache.high >= 127; private IntegerCache() { 简 单 的 说, 如 果 字 面 量 的 值 在 -128 到 127 之 间, 那 new 么 不 新 会 的 Integer 对 象, 而 是 直 接 引 用 常 量 池 中 的 Integer 对 象, 所 以 上 面 的 面 试 题 中 f1==f2 的 结 果 是 true, 而 f3==f4 的 结 果 是 false 越 是 貌 似 简 单 的 面 试 题 其 中 的 玄 机 就 越 多, 需 要 面 试 者 有 相 当 深 厚 的 功 力 8 & 和 && 的 区 别?
答 :& 运 算 符 有 两 种 用 法 :(1) 按 位 与 ;(2) 逻 辑 与 && 运 算 符 是 短 路 与 运 算 逻 辑 与 跟 短 路 与 的 差 别 是 非 常 巨 大 的, 虽 然 二 者 都 要 求 运 算 符 左 右 两 端 的 布 尔 值 都 是 true 整 个 表 达 式 的 值 才 是 true && 之 所 以 称 为 短 路 运 算 是 因 为, 如 果 && 左 边 的 表 达 式 的 值 是 false, 右 边 的 表 达 式 会 被 直 接 短 路 掉, 不 会 进 行 运 算 很 多 时 候 我 们 可 能 都 需 要 用 && 而 不 是 &, 例 如 在 验 证 用 户 登 录 时 判 定 用 户 名 不 是 null 而 且 不 是 空 字 符 串, 应 当 写 为 :username!= null &&!username.equals( ), 二 者 的 顺 序 不 能 交 换, 更 不 能 用 & 运 算 符, 因 为 第 一 个 条 件 如 果 不 成 立, 根 本 不 能 进 行 字 符 串 的 equals 比 较, 否 则 会 产 生 NullPointerException 异 常 注 意 : 逻 辑 或 运 算 符 ( ) 和 短 路 或 运 算 符 ( ) 的 差 别 也 是 如 此 补 充 : 如 果 你 熟 悉 JavaScript, 那 你 可 能 更 能 感 受 到 短 路 运 算 的 强 大, 想 成 为 JavaScript 的 高 手 就 先 从 玩 转 短 路 运 算 开 始 吧 9 解 释 内 存 中 的 栈 (stack) 堆 (heap) 和 静 态 存 储 区 的 用 法 答 : 通 常 我 们 定 义 一 个 基 本 数 据 类 型 的 变 量, 一 个 对 象 的 引 用, 还 有 就 是 函 数 调 用 的 现 场 保 存 都 使 用 内 存 中 的 栈 空 间 ; 而 通 过 new 关 键 字 和 构 造 器 创 建 的 对 象 放 在 堆 空 间 ; 程 序 中 的 字 面 量 (literal) 如 直 接 书 写 的 100 hello 和 常 量 都 是 放 在 静 态 存 储 区 中 栈 空 间 操 作 最 快 但 是 也 很 小, 通 常 大 量 的 对 象 都 是 放 在 堆 空 间, 整 个 内 存 包 括 硬 盘 上 的 虚 拟 内 存 都 可 以 被 当 成 堆 空 间 来 使 用 String str = new String( hello ); 上 面 的 语 句 中 str 放 在 栈 上, 用 new 创 建 出 来 的 字 符 串 对 象 放 在 堆 上, 而 hello 这 个 字 面 量 放 在 静 态 存 储 区
补 充 : 较 新 版 本 的 Java 中 使 用 了 一 项 叫 逃 逸 分 析 的 技 术, 可 以 将 一 些 局 部 对 象 放 在 栈 上 以 提 升 对 象 的 操 作 性 能 10 Math.round(11.5) 等 于 多 少? Math.round(-11.5) 等 于 多 少? 答 :Math.round(11.5) 的 返 回 值 是 12,Math.round(-11.5) 的 返 回 值 是 -11 四 舍 五 入 的 原 理 是 在 参 数 上 加 0.5 然 后 进 行 下 取 整 11 swtich 是 否 能 作 用 在 byte 上, 是 否 能 作 用 在 long 上, 是 否 能 作 用 在 String 上? 答 : 早 期 的 JDK 中,switch(expr) 中,expr 可 以 是 byte short char int 从 1.5 版 开,Java 始 中 引 入 了 枚 举 类 型 (enum),expr 也 可 以 是 枚 举, 从 JDK 1.7 版 开 始, 还 可 以 是 字 符 串 (String) 长 整 型 (long) 是 不 可 以 的 12 用 最 有 效 率 的 方 法 计 算 2 乘 以 8? 答 : 2 << 3( 左 移 3 位 相 当 于 乘 以 2 的 3 次 方, 右 移 3 位 相 当 于 除 以 2 的 3 补 充 : 我 们 为 编 写 的 类 重 写 hashcode 方 法 时, 可 能 会 看 到 如 下 所 示 的 代 码, 其 实 我 们 不 太 理 解 为 什 么 要 使 用 这 样 的 乘 法 运 算 来 产 生 哈 希 码 ( 散 列 码 ), 而 且 为 什 么 这 个 数 是 个 素 数, 为 什 么 通 常 选 择 31 这 个 数? 前 两 个 问 题 的 答 案 你 可 以 自 己 百 度 一 下, 选 择 31 是 因 为 可 以 用 移 位 和 减 法 运 算 来 代 替 乘 法, 从 而 得 到 更 好 的 性 能 说 到 这 里 你 可 能 已 经 想 到 了 :31 * num <==> (num
<< 5) num, 左 移 5 位 相 当 于 乘 以 2 的 5 次 方 (32) 再 减 去 自 身 就 相 当 于 乘 以 31 现 在 的 VM 都 能 自 动 完 成 这 个 优 化 package com.loonstudio; public class PhoneNumber { private int areacode; private String prefix; private String linenumber; @Override public int hashcode() { final int prime = 31; int result = 1; result = prime * result + areacode; result = prime * result + ((linenumber == null)? 0 : linenumber.hashcode()); result = prime * result + ((prefix == null)? 0 : prefix.hashcode()); return result; @Override public boolean equals(object obj) { if (this == obj) return true; if (obj == null) return false; if (getclass()!= obj.getclass()) return false; PhoneNumber other = (PhoneNumber) obj; if (areacode!= other.areacode) return false; if (linenumber == null) { if (other.linenumber!= null) return false; else if (!linenumber.equals(other.linenumber)) return false;
if (prefix == null) { if (other.prefix!= null) return false; else if (!prefix.equals(other.prefix)) return false; return true; 13 数 组 有 没 有 length() 方 法?String 有 没 有 length() 方 法? 答 : 数 组 没 有 length() 方 法, 有 length 的 属 性 String 有 length() 方 法 JavaScript 中, 获 得 字 符 串 的 长 度 是 通 过 length 属 性 得 到 的, 这 一 点 容 易 和 Java 混 淆 14 在 Java 中, 如 何 跳 出 当 前 的 多 重 嵌 套 循 环? 答 : 在 最 外 层 循 环 前 加 一 个 标 记 如 A, 然 后 用 break A; 可 以 跳 出 多 重 循 环 (Java 中 支 持 带 标 签 的 break 和 continue 语 句, 作 用 有 点 类 似 于 C 和 C++ 中 的 goto 语 句, 但 是 就 像 要 避 免 使 用 goto 一 样, 应 该 避 免 使 用 带 标 签 的 break 和 continue, 因 为 它 不 会 让 你 的 程 序 变 得 更 优 雅, 很 多 时 候 甚 至 有 相 反 的 作 用, 所 以 这 种 语 法 其 实 不 知 道 更 好 ) 15 构 造 器 (constructor) 是 否 可 被 重 写 (override)? 答 : 构 造 器 不 能 被 继 承, 因 此 不 能 被 重 写, 但 可 以 被 重 载
16 两 个 对 象 值 相 同 (x.equals(y) == true), 但 却 可 有 不 同 的 hash code, 这 句 话 对 不 对? 答 : 不 对, 如 果 两 个 对 象 x 和 y 满 足 x.equals(y) == true, 它 们 的 哈 希 码 (hash code) 应 当 相 同 Java 对 于 eqauls 方 法 和 hashcode 方 法 是 这 样 规 定 的 : (1) 如 果 两 个 对 象 相 (equals 同 方 法 返 回 true), 那 么 它 们 的 hashcode 值 一 定 要 相 同 ;(2) 如 果 两 个 对 象 hashcode 的 相 同, 它 们 并 不 一 定 相 同 当 然, 你 未 必 要 按 照 要 求 去 做, 但 是 如 果 你 违 背 了 上 述 原 则 就 会 发 现 在 使 用 容 器 时, 相 同 的 对 象 可 以 出 现 在 Set 集 合 中, 同 时 增 加 新 元 素 的 效 率 会 大 大 下 降 ( 对 于 使 用 哈 希 存 储 的 系 统, 如 果 哈 希 码 频 繁 的 冲 突 将 会 造 成 存 取 性 能 急 剧 下 降 ) 补 充 : 关 于 equals 和 hashcode 方 法, 很 多 Java 程 序 都 知 道, 但 很 多 人 也 就 是 仅 仅 知 道 而 已, 在 Joshua Bloch 的 大 作 Effective Java ( 很 多 软 件 公 司, Effective Java Java 编 程 思 想 以 及 重 构 : 改 善 既 有 代 码 质 量 是 Java 程 序 员 必 看 书 籍, 如 果 你 还 没 看 过, 那 就 赶 紧 去 亚 马 逊 买 一 本 吧 ) 中 是 这 样 介 绍 equals 方 法 的 : 首 先 equals 方 法 必 须 满 足 自 反 性 (x.equals(x) 必 须 返 回 true) 对 称 性 (x.equals(y) 返 回 true 时,y.equals(x) 也 必 须 返 回 true) 传 递 性 (x.equals(y) 和 y.equals(z) 都 返 回 true 时,x.equals(z) 也 必 须 返 回 true) 和 一 致 性 ( 当 x 和 y 引 用 的 对 象 信 息 没 有 被 修 改 时, 多 次 调 用 x.equals(y) 应 该 得 到 同 样 的 返 回 值 ), 而 且 对 于 任 何 非 null 值 的 引 用 x,x.equals(null) 必 须 返 回 false 实 现 高 质 量 的 equals 方 法 的 诀 窍 包 括 :1. 是 否 为 这 个 对 象 的 引 用 ;2. 的 类 型 ;3. 配 ;4. 性 ;5. 使 用 == 操 作 符 检 查 参 数 instanceof 使 用 操 作 符 检 查 参 数 是 否 为 正 确 对 于 类 中 的 关 键 属 性, 检 查 参 数 传 入 对 象 的 属 性 是 否 与 之 相 匹 编 equals 写 完 方 法 后, 问 自 己 它 是 否 满 足 对 称 性 传 递 性 一 致 equals 重 写 时 总 是 要 重 写 hashcode;6. 不 要 将 equals 方 法 参 数 中 的 Object 对 象 替 换 为 其 他 的 类 型, 在 重 写 时 不 要 忘 掉 @Override 注 解 17 是 否 可 以 继 承 String 类?
答 :String 类 是 final 类, 不 可 以 被 继 承 补 充 : 继 承 String 本 身 就 是 一 个 错 误 的 行 为, 对 String 类 型 最 好 的 重 用 方 式 是 关 联 (HAS-A) 而 不 是 继 承 (IS-A) 18 当 一 个 对 象 被 当 作 参 数 传 递 到 一 个 方 法 后, 此 方 法 可 改 变 这 个 对 象 的 属 性, 并 可 返 回 变 化 后 的 结 果, 那 么 这 里 到 底 是 值 传 递 还 是 引 用 传 递? 答 : 是 值 传 递 Java 编 程 语 言 只 有 值 传 递 参 数 当 一 个 对 象 实 例 作 为 一 个 参 数 被 传 递 到 方 法 中 时, 参 数 的 值 就 是 对 该 对 象 的 引 用 对 象 的 属 性 可 以 在 被 调 用 过 程 中 被 改 变, 但 对 象 的 引 用 是 永 远 不 会 改 变 的 C++ 和 C# 中 可 以 通 过 传 引 用 或 传 输 出 参 数 来 改 变 传 入 的 参 数 的 值 补 充 :Java 中 没 有 传 引 用 实 在 是 非 常 的 不 方 便, 这 一 点 在 Java 8 中 仍 然 没 有 得 到 改 进, 正 是 如 此 在 Java 编 写 的 代 码 中 才 会 出 现 大 量 的 Wrapper 类 ( 将 需 要 通 过 方 法 调 用 修 改 的 引 用 置 于 一 个 Wrapper 类 中, 再 将 Wrapper 对 象 传 入 方 法 ), 这 样 的 做 法 只 会 让 代 码 变 得 臃 肿, 尤 其 是 让 从 C 和 C++ 转 型 为 Java 程 序 员 的 开 发 者 无 法 容 忍 19 String 和 StringBuilder StringBuffer 的 区 别? 答 :Java 平 台 提 供 了 两 种 类 型 的 字 符 串 :String 和 StringBuffer / StringBuilder, 它 们 可 以 储 存 和 操 作 字 符 串 其 中 String 是 只 读 字 符 串, 也 就 意 味 着 String 引 用 的 字 符 串 内 容 是 不 能 被 改 变 的 而 StringBuffer 和 StringBuilder 类 表 示 的 字 符 串 对 象 可 以 直 接 进 行 修 改 StringBuilder 是 JDK 1.5 中 引 入 的, 它 和 StringBuffer 的 方 法 完 全 相 同, 区 别 在 于 它 是 在 单 线 程 环 境 下 使 用 的, 因
为 它 的 所 有 方 面 都 没 有 被 synchronized 修 饰, 因 此 它 的 效 率 也 比 StringBuffer 略 高 补 充 1: 有 一 个 面 试 题 问 : 有 没 有 哪 种 情 况 用 + 做 字 符 串 连 接 比 调 用 StringBuffer / StringBuilder 对 象 的 append 方 法 性 能 更 好? 如 果 连 接 后 得 到 的 字 符 串 在 静 态 存 储 区 中 是 早 已 存 在 的, 那 么 用 + 做 字 符 串 连 接 是 优 于 StringBuffer / StringBuilder 的 append 方 法 的 补 充 2: 下 面 也 是 一 个 面 试 题, 问 程 序 的 输 出, 看 看 自 己 能 不 能 说 出 正 确 答 案 package com.lovo; public class StringEqualTest { public static void main(string[] args) { String a = "Programming"; String b = new String("Programming"); String c = "Program" + "ming"; System.out.println(a == b); System.out.println(a == c); System.out.println(a.equals(b)); System.out.println(a.equals(c)); System.out.println(a.intern() == b.intern()); 20 重 载 (Overload) 和 重 写 (Override) 的 区 别 重 载 的 方 法 能 否 根 据 返 回 类 型 进 行 区 分? 答 : 方 法 的 重 载 和 重 写 都 是 实 现 多 态 的 方 式, 区 别 在 于 前 者 实 现 的 是 编 译 时 的 多 态 性, 而 后 者 实 现 的 是 运 行 时 的 多 态 性 重 载 发 生 在 一 个 类 中, 同 名 的 方 法 如 果 有 不 同 的 参 数 列 表 ( 参 数 类 型 不 同 参 数 个 数 不 同 或 者 二 者 都 不 同 )
则 视 为 重 载 ; 重 写 发 生 在 子 类 与 父 类 之 间, 重 写 要 求 子 类 被 重 写 方 法 与 父 类 被 重 写 方 法 有 相 同 的 返 回 类 型, 比 父 类 被 重 写 方 法 更 好 访 问, 不 能 比 父 类 被 重 写 方 法 声 明 更 多 的 异 常 ( 里 氏 代 换 原 则 ) 重 载 对 返 回 类 型 没 有 特 殊 的 要 求 补 充 : 华 为 的 面 试 题 中 曾 经 问 过 这 样 一 个 问 题 : 为 什 么 不 能 根 据 返 回 类 型 来 区 分 重 载, 说 出 你 的 答 案 吧! 21 描 述 一 下 JVM 加 载 class 文 件 的 原 理 机 制? 答 :JVM 中 类 的 装 载 是 由 类 加 载 器 (ClassLoader) 和 它 的 子 类 来 实 现 的,Java 中 的 类 加 载 器 是 一 个 重 要 的 Java 运 行 时 系 统 组 件, 它 负 责 在 运 行 时 查 找 和 装 入 类 文 件 中 的 类 补 充 : 1. 由 Java 于 的 跨 平 台 性, 经 过 编 译 的 Java 源 程 序 并 不 是 一 个 可 执 行 程 序, 而 是 一 个 或 多 个 类 文 件 当 Java 程 序 需 要 使 用 某 个 类 时,JVM 会 确 保 这 个 类 已 经 被 加 载 连 接 ( 验 证 准 备 和 解 析 ) 和 初 始 化 类 的 加 载 是 指 把 类.class 的 文 件 中 的 数 据 读 入 到 内 存 中, 通 常 是 创 建 一 个 字 节 数 组 读 入.class 文 件, 然 后 产 生 与 所 加 载 类 对 应 的 Class 对 象 加 载 完 成 后,Class 对 象 还 不 完 整, 所 以 此 时 的 类 还 不 可 用 当 类 被 加 载 后 就 进 入 连 接 阶 段, 这 一 阶 段 包 括 验 证 准 备 ( 为 静 态 变 量 分 配 内 存 并 设 置 默 认 的 初 始 值 ) 和 解 析 ( 将 符 号 引 用 替 换 为 直 接 引 用 ) 三 个 步 骤 最 后 JVM 对 类 进 行 初 始 化, 包 括 :1 如 果 类 存 在 直 接 的 父 类 并 且 这 个 类 还 没 有 被 初 始 化, 那 么 就 先 初 始 化 父 类 ;2 如 果 类 中 存 在 初 始 化 语 句, 就 依 次 执 行 这 些 初 始 化 语 句
2. 类 的 加 载 是 由 类 加 载 器 完 成 的, 类 加 载 器 包 括 : 根 加 载 (BootStrap) 器 扩 展 加 载 器 (Extension) 系 统 加 载 器 (System) 和 用 户 自 定 义 类 加 载 器 (java.lang.classloader 的 子 类 ) 从 JDK 1.2 开 始, 类 加 载 过 程 采 取 了 父 亲 委 托 机 制 (PDM) PDM 更 好 的 保 证 了 Java 平 台 的 安 全 性, 在 该 机 制 中,JVM 自 带 的 Bootstrap 是 根 加 载 器, 其 他 的 加 载 器 都 有 且 仅 有 一 个 父 类 加 载 器 类 的 加 载 首 先 请 求 父 类 加 载 器 加 载, 父 类 加 载 器 无 能 为 力 时 才 由 其 子 类 加 载 器 自 行 加 载 JVM 不 会 向 Java 程 序 提 供 对 Bootstrap 的 引 用 下 面 是 关 于 几 个 类 加 载 器 的 说 明 : a)bootstrap: 一 般 用 本 地 代 码 实 现, 负 责 加 载 JVM 基 础 核 心 类 库 (rt.jar); b)extension: 从 java.ext.dirs 系 统 属 性 所 指 定 的 目 录 中 加 载 类 库, 它 的 父 加 载 器 是 Bootstrap; c)system: 又 叫 应 用 类 加 载 器, 其 父 类 是 Extension 它 是 应 用 最 广 泛 的 类 加 载 器 它 从 环 境 变 量 classpath 或 者 系 统 属 性 java.class.path 所 指 定 的 目 录 中 记 载 类, 是 用 户 自 定 义 加 载 器 的 默 认 父 加 载 器 22 char 型 变 量 中 能 不 能 存 贮 一 个 中 文 汉 字? 为 什 么? 答 :char 类 型 可 以 存 储 一 个 中 文 汉 字, 因 为 Java 中 使 用 的 编 码 是 Unicode( 不 选 择 任 何 特 定 的 编 码, 直 接 使 用 字 符 在 字 符 集 中 的 编 号, 这 是 统 一 的 唯 一 方 法 ), 一 个 char 类 型 占 2 个 字 节 (16bit), 所 以 放 一 个 中 文 是 没 问 题 的 补 充 : 使 用 Unicode 意 味 着 字 符 在 JVM 内 部 和 外 部 有 不 同 的 表 现 形 式, 在 JVM 内 部 都 是 Unicode, 当 这 个 字 符 被 从 JVM 内 部 转 移 到 外 部 时 ( 例 如 存 入 文 件 系
统 中 ), 需 要 进 行 编 码 转 换 所 以 Java 中 有 字 节 流 和 字 符 流, 以 及 在 字 符 流 和 字 节 流 之 间 进 行 转 换 的 转 换 流, 如 InputStreamReader 和 OutputStreamReader, 这 两 个 类 是 字 节 流 和 字 符 流 之 间 的 适 配 器 类, 承 担 了 编 码 转 换 的 任 务 ; 对 于 C 程 序 员 来 说, 要 完 成 这 样 的 编 码 转 换 恐 怕 要 依 赖 于 union( 联 合 体 / 共 用 体 ) 共 享 内 存 的 特 征 来 实 现 了 23 抽 象 类 (abstract class) 和 接 口 (interface) 有 什 么 异 同? 答 : 抽 象 类 和 接 口 都 不 能 够 实 例 化, 但 可 以 定 义 抽 象 类 和 接 口 类 型 的 引 用 一 个 类 如 果 继 承 了 某 个 抽 象 类 或 者 实 现 了 某 个 接 口 都 需 要 对 其 中 的 抽 象 方 法 全 部 进 行 实 现, 否 则 该 类 仍 然 需 要 被 声 明 为 抽 象 类 接 口 比 抽 象 类 更 加 抽 象, 因 为 抽 象 类 中 可 以 定 义 构 造 器, 可 以 有 抽 象 方 法 和 具 体 方 法, 而 接 口 中 不 能 定 义 构 造 器 而 且 其 中 的 方 法 全 部 都 是 抽 象 方 法 抽 象 类 中 的 成 员 可 以 是 private 默 认 protected public 的, 而 接 口 中 的 成 员 全 都 是 public 的 抽 象 类 中 可 以 定 义 成 员 变 量, 而 接 口 中 定 义 的 成 员 变 量 实 际 上 都 是 常 量 有 抽 象 方 法 的 类 必 须 被 声 明 为 抽 象 类, 而 抽 象 类 未 必 要 有 抽 象 方 法 24 静 态 嵌 套 类 (Static Nested Class) 和 内 部 类 (Inner Class) 的 不 同? 答 :Static Nested Class 是 被 声 明 为 静 态 (static) 的 内 部 类, 它 可 以 不 依 赖 于 外 部 类 实 例 被 实 例 化 而 通 常 的 内 部 类 需 要 在 外 部 类 实 例 化 后 才 能 实 例 化, 其 语 法 看 起 来 挺 诡 异 的, 如 下 所 示 package com.lovo; /** * 扑 克 类 ( 一 副 扑 克 )
* @author 骆 昊 * */ public class Poker { private static String[] suites = {" 黑 桃 ", " 红 桃 ", " 草 花 ", " 方 块 "; private static int[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13; private Card[] cards; /** * 构 造 器 * */ public Poker() { cards = new Card[52]; for(int i = 0; i < suites.length; i++) { for(int j = 0; j < faces.length; j++) { cards[i * 13 + j] = new Card(suites[i], faces[j]); /** * 洗 牌 ( 随 机 乱 序 ) * */ public void shuffle() { for(int i = 0, len = cards.length; i < len; i++) { int index = (int) (Math.random() * len); Card temp = cards[index]; cards[index] = cards[i]; cards[i] = temp; /** * 发 牌 * @param index 发 牌 的 位 置 * */ public Card deal(int index) { return cards[index];
/** * 卡 片 类 ( 一 张 扑 克 ) * [ 内 部 类 ] * @author 骆 昊 * */ public class Card { private String suite; private int face; // 花 色 // 点 数 public Card(String suite, int face) { this.suite = suite; this.face = face; @Override public String tostring() { String facestr = ""; switch(face) { case 1: facestr = "A"; break; case 11: facestr = "J"; break; case 12: facestr = "Q"; break; case 13: facestr = "K"; break; default: facestr = String.valueOf(face); return suite + facestr; 测 试 类 : package com.lovo; class PokerTest { public static void main(string[] args) { Poker poker = new Poker(); poker.shuffle(); Poker.Card c1 = poker.deal(0); // 洗 牌 // 发 第 一 张 牌
Card // 对 于 非 静 态 内 部 类 Poker 对 // 象 才 能 只 创 有 建 通 Card 过 其 对 外 象 部 类 Poker.Card c2 = poker.new Card(" 红 心 ", 1); // 自 System.out.println(c1); // 洗 牌 后 的 第 一 张 System.out.println(c2); // 打 印 : 红 A心 25 Java 中 会 存 在 内 存 泄 漏 吗, 请 简 单 描 述 答 : 理 论 上 Java 因 为 有 垃 圾 回 收 机 制 (GC) 不 会 存 在 内 存 泄 露 问 题 ( 这 也 是 Java 被 广 泛 使 用 于 服 务 器 端 编 程 的 一 个 重 要 原 因 ); 然 而 在 实 际 开 发 中, 可 能 会 存 在 无 用 但 可 达 的 对 象, 这 些 对 象 不 能 被 GC 回 收 也 会 发 生 内 存 泄 露 一 个 例 子 就 是 Hibernate 的 Session( 一 级 缓 存 ) 中 的 对 象 属 于 持 久 态, 垃 圾 回 收 器 是 不 会 回 收 这 些 对 象 的, 然 而 这 些 对 象 中 可 能 存 在 无 用 的 垃 圾 对 象 下 面 的 例 子 也 展 示 了 Java 中 发 生 内 存 泄 露 的 情 况 : package com.lovo; import java.util.arrays; import java.util.emptystackexception; public class MyStack<T> { private T[] elements; private int size = 0; private static final int INIT_CAPACITY = 16; public MyStack() { elements = (T[]) new Object[INIT_CAPACITY]; public void push(t elem) { ensurecapacity(); elements[size++] = elem; public T pop() { if(size == 0) throw new EmptyStackException();
1); return elements[--size]; private void ensurecapacity() { if(elements.length == size) { elements = Arrays.copyOf(elements, 2 * size + 上 面 的 代 码 实 现 了 一 个 栈 ( 先 进 后 出 (FILO)) 结 构, 乍 看 之 下 似 乎 没 有 什 么 明 显 的 问 题, 它 甚 至 可 以 通 过 你 编 写 的 各 种 单 元 测 试 然 而 其 中 的 pop 方 法 却 存 在 内 存 泄 露 的 问 题, 当 我 们 用 pop 方 法 弹 出 栈 中 的 对 象 时, 该 对 象 不 会 被 当 作 垃 圾 回 收, 即 使 使 用 栈 的 程 序 不 再 引 用 这 些 对 象, 因 为 栈 内 部 维 护 着 对 这 些 对 象 的 过 期 引 用 (obsolete reference) 在 支 持 垃 圾 回 收 的 语 言 中, 内 存 泄 露 是 很 隐 蔽 的, 这 种 内 存 泄 露 其 实 就 是 无 意 识 的 对 象 保 持 如 果 一 个 对 象 引 用 被 无 意 识 的 保 留 起 来 了, 那 么 垃 圾 回 收 器 不 会 处 理 这 个 对 象, 也 不 会 处 理 该 对 象 引 用 的 其 他 对 象, 即 使 这 样 的 对 象 只 有 少 数 几 个, 也 可 能 会 导 致 很 多 的 对 象 被 排 除 在 垃 圾 回 收 之 外, 从 而 对 性 能 造 成 重 大 影 响, 极 端 情 况 下 会 引 发 Disk Paging( 物 理 内 存 与 硬 盘 的 虚 拟 内 存 交 换 数 据 ), 甚 至 造 成 OutOfMemoryError 26 抽 象 的 (abstract) 方 法 是 否 可 同 时 是 静 态 的 (static), 是 否 可 同 时 是 本 地 方 法 (native), 是 否 可 同 时 被 synchronized 修 饰? 答 : 都 不 能 抽 象 方 法 需 要 子 类 重 写, 而 静 态 的 方 法 是 无 法 被 重 写 的, 因 此 二 者 是 矛 盾 的 本 地 方 法 是 由 本 地 代 码 ( 如 C 代 码 ) 实 现 的 方 法, 而 抽 象 方 法 是 没 有 实 现 的, 也 是 矛 盾 的 synchronized 和 方 法 的 实 现 细 节 有 关, 抽 象
方 法 不 涉 及 实 现 细 节, 因 此 也 是 相 互 矛 盾 的 27 静 态 变 量 和 实 例 变 量 的 区 别? 答 : 静 态 变 量 是 被 static 修 饰 符 修 饰 的 变 量, 也 称 为 类 变 量, 它 属 于 类, 不 属 于 类 的 任 何 一 个 对 象, 一 个 类 不 管 创 建 多 少 个 对 象, 静 态 变 量 在 内 存 中 有 且 仅 有 一 个 拷 贝 ; 实 例 变 量 必 须 依 存 于 某 一 实 例, 需 要 先 创 建 对 象 然 后 通 过 对 象 才 能 访 问 到 它 静 态 变 量 可 以 实 现 让 多 个 对 象 共 享 内 存 在 Java 开 发 中, 上 下 文 类 和 工 具 类 中 通 常 会 有 大 量 的 静 态 成 员 28 是 否 可 以 从 一 个 静 态 (static) 方 法 内 部 发 出 对 非 静 态 (non-static) 方 法 的 调 用? 答 : 不 可 以, 静 态 方 法 只 能 访 问 静 态 成 员, 因 为 非 静 态 方 法 的 调 用 要 先 创 建 对 象, 因 此 在 调 用 静 态 方 法 时 可 能 对 象 并 没 有 被 初 始 化 29 如 何 实 现 对 象 克 隆? 答 : 有 两 种 方 式 : 1. 实 现 Cloneable 接 口 并 重 写 Object 类 中 的 clone() 方 法 ; 2. 实 Serializable 现 接 口, 通 过 对 象 的 序 列 化 和 反 序 列 化 实 现 克 隆, 可 以 实 现 真 正 的 深 度 克 隆, 代 码 如 下
package com.lovo; import java.io.bytearrayinputstream; import java.io.bytearrayoutputstream; import java.io.objectinputstream; import java.io.objectoutputstream; public class MyUtil { private MyUtil() { throw new AssertionError(); public static <T> T clone(t obj) throws Exception { ByteArrayOutputStream bout = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bout); oos.writeobject(obj); ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); 没 有 任 何 意 义 ObjectInputStream ois = new ObjectInputStream(bin); return (T) ois.readobject(); ByteArrayInputStream // 说 明 : 或 调 ByteArrayOutputStream 用 对 象 的 close 方 法 // 这 两 个 基 于 内 存 的 流 只 要 垃 圾 回 收 器 清 理 对 象 就 能 够 释 放 资 源 下 面 是 测 试 代 码 : package com.lovo; import java.io.serializable; /** * 人 类 * @author 骆 昊 *
*/ class Person implements Serializable { private static final long serialversionuid = -9102017020286042305L; private String name; private int age; private Car car; // 姓 名 // 年 龄 // 座 驾 public Person(String name, int age, Car car) { this.name = name; this.age = age; this.car = car; public String getname() { return name; public void setname(string name) { this.name = name; public int getage() { return age; public void setage(int age) { this.age = age; public Car getcar() { return car; public void setcar(car car) { this.car = car; @Override public String tostring() {
car=" + car + "]"; return "Person [name=" + name + ", age=" + age + ", /** * 小 汽 车 类 * @author 骆 昊 * */ class Car implements Serializable { private static final long serialversionuid = -5713945027627603702L; private String brand; private int maxspeed; // 品 牌 // 最 高 时 速 public Car(String brand, int maxspeed) { this.brand = brand; this.maxspeed = maxspeed; public String getbrand() { return brand; public void setbrand(string brand) { this.brand = brand; public int getmaxspeed() { return maxspeed; public void setmaxspeed(int maxspeed) { this.maxspeed = maxspeed; @Override public String tostring() {
+ "]"; return "Car [brand=" + brand + ", maxspeed=" + maxspeed class CloneTest { public static void main(string[] args) { Car("Benz", 300)); try { Person p1 = new Person("Hao LUO", 33, new Person p2 = MyUtil.clone(p1); p2.getcar().setbrand("byd"); Person 对 象 p2 关 联 的 汽 车 对 象 // 的 品 牌 修 属 改 性 克 隆 的 Person 对 象 p1 关 联 的 汽 车 不 会 受 到 // 任 何 影 原 响 来 的 Person 对 象 时 其 关 联 的 汽 车 对 // 象 也 被 因 克 为 隆 在 了 克 隆 System.out.println(p1); catch (Exception e) { e.printstacktrace(); // 深 度 克 隆 注 意 : 基 于 序 列 化 和 反 序 列 化 实 现 的 克 隆 不 仅 仅 是 深 度 克 隆, 更 重 要 的 是 通 过 泛 型 限 定, 可 以 检 查 出 要 克 隆 的 对 象 是 否 支 持 序 列 化, 这 项 检 查 是 编 译 器 完 成 的, 不 是 在 运 行 时 抛 出 异 常, 这 种 是 方 案 明 显 优 于 使 用 Object 类 的 clone 方 法 克 隆 对 象 30 GC 是 什 么? 为 什 么 要 有 GC? 答 :GC 是 垃 圾 收 集 的 意 思, 内 存 处 理 是 编 程 人 员 容 易 出 现 问 题 的 地 方, 忘 记 或 者 错 误 的 内 存 回 收 会 导 致 程 序 或 系 统 的 不 稳 定 甚 至 崩 溃,Java 提 供 的 GC 功
能 可 以 自 动 监 测 对 象 是 否 超 过 作 用 域 从 而 达 到 自 动 回 收 内 存 的 目 的,Java 语 言 没 有 提 供 释 放 已 分 配 内 存 的 显 示 操 作 方 法 Java 程 序 员 不 用 担 心 内 存 管 理, 因 为 垃 圾 收 集 器 会 自 动 进 行 管 理 要 请 求 垃 圾 收 集, 可 以 调 用 下 面 的 方 法 之 一 :System.gc() 或 Runtime.getRuntime().gc(), 但 JVM 可 以 屏 蔽 掉 显 示 的 垃 圾 回 收 调 用 垃 圾 回 收 可 以 有 效 的 防 止 内 存 泄 露, 有 效 的 使 用 可 以 使 用 的 内 存 垃 圾 回 收 器 通 常 是 作 为 一 个 单 独 的 低 优 先 级 的 线 程 运 行, 不 可 预 知 的 情 况 下 对 内 存 堆 中 已 经 死 亡 的 或 者 长 时 间 没 有 使 用 的 对 象 进 行 清 除 和 回 收, 程 序 员 不 能 实 时 的 调 用 垃 圾 回 收 器 对 某 个 对 象 或 所 有 对 象 进 行 垃 圾 回 收 在 Java 诞 生 初 期, 垃 圾 回 收 是 Java 最 大 的 亮 点 之 一, 因 为 服 务 器 端 的 编 程 需 要 有 效 的 防 止 内 存 泄 露 问 题, 然 而 时 过 境 迁, 如 今 Java 的 垃 圾 回 收 机 制 已 经 成 为 被 诟 病 的 东 西 移 动 智 能 终 端 用 户 通 常 觉 得 ios 的 系 统 比 Android 系 统 有 更 好 的 用 户 体 验, 其 中 一 个 深 层 次 的 原 因 就 在 于 Android 系 统 中 垃 圾 回 收 的 不 可 预 知 性 补 充 : 垃 圾 回 收 机 制 有 很 多 种, 包 括 : 分 代 复 制 垃 圾 回 收 标 记 垃 圾 回 收 增 量 垃 圾 回 收 等 方 式 标 准 的 Java 进 程 既 有 栈 又 有 堆 栈 保 存 了 原 始 型 局 部 变 量, 堆 保 存 了 要 创 建 的 对 象 Java 平 台 对 堆 内 存 回 收 和 再 利 用 的 基 本 算 法 被 称 为 标 记 和 清 除, 但 是 Java 对 其 进 行 了 改 进, 采 用 分 代 式 垃 圾 收 集 这 种 方 法 会 跟 Java 对 象 的 生 命 周 期 将 堆 内 存 划 分 为 不 同 的 区 域, 在 垃 圾 收 集 过 程 中, 可 能 会 将 对 象 移 动 到 不 同 区 域 : 伊 甸 园 (Eden): 这 是 对 象 最 初 诞 生 的 区 域, 并 且 对 大 多 数 对 象 来 说, 这 里 是 它 们 唯 一 存 在 过 的 区 域 幸 存 者 乐 园 (Survivor): 从 伊 甸 园 幸 存 下 来 的 对 象 会 被 挪 到 这 里 终 身 颐 养 园 (Tenured): 这 是 足 够 老 的 幸 存 对 象 的 归 宿 年 轻 代 收 集
(Minor-GC) 过 程 是 不 会 触 及 这 个 地 方 的 当 年 轻 代 收 集 不 能 把 对 象 放 进 终 身 颐 养 园 时, 就 会 触 发 一 次 完 全 收 集 (Major-GC), 这 里 可 能 还 会 牵 扯 到 压 缩, 以 便 为 大 对 象 腾 出 足 够 的 空 间 与 垃 圾 回 收 相 关 的 JVM 参 数 : -Xms / -Xmx 堆 的 初 始 大 小 / 堆 的 最 大 大 小 -Xmn 堆 中 年 轻 代 的 大 小 -XX:-DisableExplicitGC 让 System.gc() 不 产 生 任 何 作 用 -XX:+PrintGCDetail 打 印 GC 的 细 节 -XX:+PrintGCDateStamps 打 印 GC 操 作 的 时 间 戳 31 String s=new String( xyz ); 创 建 了 几 个 字 符 串 对 象? 答 : 两 个 对 象, 一 个 是 静 态 存 储 区 的 "xyz", 一 个 是 用 new 创 建 在 堆 上 的 对 象 32 接 口 是 否 可 继 (extends) 承 接 口? 抽 象 类 是 否 可 实 (implements) 现 接 口? 抽 象 类 是 否 可 继 承 具 体 (concrete 类 class)? 答 : 接 口 可 以 继 承 接 口 抽 象 类 可 以 实 现 (implements) 接 口, 抽 象 类 可 继 承 具 体 类, 但 前 提 是 具 体 类 必 须 有 明 确 的 构 造 函 数
33 一 个.java 源 文 件 中 是 否 可 以 包 含 多 个 类 ( 不 是 内 部 类 )? 有 什 么 限 制? 答 : 可 以, 但 一 个 源 文 件 中 最 多 只 能 有 一 个 公 开 类 (public class) 而 且 文 件 名 必 须 和 公 开 类 的 类 名 完 全 保 持 一 致 34 Anonymous Inner Class( 匿 名 内 部 类 ) 是 否 可 以 继 承 其 它 类? 是 否 可 以 实 现 接 口? 答 : 可 以 继 承 其 他 类 或 实 现 其 他 接 口, 在 Swing 编 程 中 常 用 此 方 式 来 实 现 事 件 监 听 和 回 调 35 内 部 类 可 以 引 用 它 的 包 含 类 ( 外 部 类 ) 的 成 员 吗? 有 没 有 什 么 限 制? 答 : 一 个 内 部 类 对 象 可 以 访 问 创 建 它 的 外 部 类 对 象 的 成 员, 包 括 私 有 成 员 36 Java 中 的 final 关 键 字 有 哪 些 用 法? 答 :(1) 修 饰 类 : 表 示 该 类 不 能 被 继 承 ;(2) 修 饰 方 法 : 表 示 方 法 不 能 被 重 写 ; (3) 修 饰 变 量 : 表 示 变 量 只 能 一 次 赋 值 以 后 值 不 能 被 修 改 ( 常 量 )
37 指 出 下 面 程 序 的 运 行 结 果 : class A{ static{ System.out.print("1"); public A(){ System.out.print("2"); class B extends A{ static{ System.out.print("a"); public B(){ System.out.print("b"); public class Hello{ public static void main(string[] args){ A ab = new B(); ab = new B(); 答 : 执 行 结 果 :1a2b2b 创 建 对 象 时 构 造 器 的 调 用 顺 序 是 : 先 初 始 化 静 态 成 员, 然 后 调 用 父 类 构 造 器, 再 初 始 化 非 静 态 成 员, 最 后 调 用 自 身 构 造 器
38 数 据 类 型 之 间 的 转 换 : 1) 如 何 将 字 符 串 转 换 为 基 本 数 据 类 型? 2) 如 何 将 基 本 数 据 类 型 转 换 为 字 符 串? 答 : 1) 调 用 基 本 数 据 类 型 对 应 的 包 装 类 中 的 方 法 parsexxx(string) 或 valueof(string) 即 可 返 回 相 应 基 本 类 型 ; 2) 一 种 方 法 是 将 基 本 数 据 类 型 与 空 字 符 串 ( ) 连 接 (+) 即 可 获 得 其 所 对 应 的 字 符 串 ; 另 一 种 方 法 是 调 用 String 类 中 的 valueof( ) 方 法 返 回 相 应 字 符 串 39 如 何 实 现 字 符 串 的 反 转 及 替 换? 答 : 方 法 很 多, 可 以 自 己 写 实 现 也 可 以 使 用 String 或 StringBuffer / StringBuilder 中 的 方 法 有 一 道 很 常 见 的 面 试 题 是 用 递 归 实 现 字 符 串 反 转, 代 码 如 下 所 示 : public static String reverse(string originstr) { if(originstr == null originstr.length() <= 1) return originstr; return reverse(originstr.substring(1)) +
originstr.charat(0); 40 怎 样 将 GB2312 编 码 的 字 符 串 转 换 为 ISO-8859-1 编 码 的 字 符 串? 答 : 代 码 如 下 所 示 : String s1 = " 你 好 "; String s2 = newstring(s1.getbytes("gb2312"), "ISO-8859-1"); 41 日 期 和 时 间 : 1) 如 何 取 得 年 月 日 小 时 分 钟 秒? 2) 如 何 取 得 从 1970 年 1 月 1 日 0 时 0 分 0 秒 到 现 在 的 毫 秒 数? 3) 如 何 取 得 某 月 的 最 后 一 天? 4) 如 何 格 式 化 日 期? 答 : 操 作 方 法 如 下 所 示 : 1) 创 java.util.calendar 建 实 例, 调 用 其 get() 方 法 传 入 不 同 的 参 数 即 可 获 得 参 数 所 对 应 的 值 2) 以 下 方 法 均 可 获 得 该 毫 秒 数 : Calendar.getInstance().getTimeInMillis();
System.currentTimeMillis(); 3) 示 例 代 码 如 下 : Calendar time = Calendar.getInstance(); time.getactualmaximum(calendar.day_of_month); 4) 利 java.text.dataformat 用 的 子 类 ( 如 SimpleDateFormat 类 ) 中 的 format(date) 方 法 可 将 日 期 格 式 化 42 打 印 昨 天 的 当 前 时 刻 答 : public class YesterdayCurrent { public static void main(string[] args){ Calendar cal = Calendar.getInstance(); cal.add(calendar.date, -1); System.out.println(cal.getTime()); 43 比 较 一 下 Java 和 JavaSciprt 答 :JavaScript 与 Java 是 两 个 公 司 开 发 的 不 同 的 两 个 产 品 Java 是 原 Sun 公 司 推 出 的 面 向 对 象 的 程 序 设 计 语 言, 特 别 适 合 于 互 联 网 应 用 程 序 开 发 ; 而 JavaScript 是 Netscape 公 司 的 产 品, 为 了 扩 展 Netscape 浏 览 器 的 功 能 而 开 发 的 一 种 可 以 嵌 入 Web 页 面 中 运 行 的 基 于 对 象 和 事 件 驱 动 的 解 释 性 语 言, 它 的 前 身 是 LiveScript; 而 Java 的 前 身 是 Oak 语 言 下 面 对 两 种 语 言 间 的 异 同 作 如 下 比 较 :
1) 基 于 对 象 和 面 向 对 象 :Java 是 一 种 真 正 的 面 向 对 象 的 语 言, 即 使 是 开 发 简 单 的 程 序, 必 须 设 计 对 象 ;JavaScript 是 种 脚 本 语 言, 它 可 以 用 来 制 作 与 网 络 无 关 的, 与 用 户 交 互 作 用 的 复 杂 软 件 它 是 一 种 基 于 对 象 (Object-Based) 和 事 件 驱 动 (Event-Driven) 的 编 程 语 言 因 而 它 本 身 提 供 了 非 常 丰 富 的 内 部 对 象 供 设 计 人 员 使 用 ; 2) 解 释 和 编 译 :Java 的 源 代 码 在 执 行 之 前, 必 须 经 过 编 译 ;JavaScript 是 一 种 解 释 性 编 程 语 言, 其 源 代 码 不 需 经 过 编 译, 由 浏 览 器 解 释 执 行 ; 3) 强 类 型 变 量 和 类 型 弱 变 量 :Java 采 用 强 类 型 变 量 检 查, 即 所 有 变 量 在 编 译 之 前 必 须 作 声 明 ;JavaScript 中 变 量 声 明, 采 用 其 弱 类 型 即 变 量 在 使 用 前 不 需 作 声 明, 而 是 解 释 器 在 运 行 时 检 查 其 数 据 类 型 ; 4) 代 码 格 式 不 一 样 补 充 : 上 面 列 出 的 四 点 是 原 来 所 谓 的 标 准 答 案 中 给 出 的 其 实 Java 和 JavaScript 最 重 要 的 区 别 是 一 个 是 静 态 语 言, 一 个 是 动 态 语 言 目 前 的 编 程 语 言 的 发 展 趋 势 是 函 数 式 语 言 和 动 态 语 言 在 Java 中 类 (class) 是 一 等 公 民, 而 JavaScript 中 函 数 (function) 是 一 等 公 民 对 于 这 种 问 题, 在 面 试 时 还 是 用 自 己 的 语 言 回 答 会 更 加 靠 谱 44 什 么 时 候 用 assert? 答 :assertion( 断 言 ) 在 软 件 开 发 中 是 一 种 常 用 的 调 试 方 式, 很 多 开 发 语 言 中 都 支 持 这 种 机 制 一 般 来 说,assertion 用 于 保 证 程 序 最 基 本 关 键 的 正 确 性 assertion 检 查 通 常 在 开 发 和 测 试 时 开 启 为 了 提 高 性 能, 在 软 件 发 布 后, assertion 检 查 通 常 是 关 闭 的 在 实 现 中, 断 言 是 一 个 包 含 布 尔 表 达 式 的 语 句, 在 执 行 这 个 语 句 时 假 定 该 表 达 式 为 true; 如 果 表 达 式 计 算 为 false, 那 么 系
统 会 报 告 一 个 AssertionError 断 言 用 于 调 试 目 的 : assert(a > 0); // throws an AssertionError if a <= 0 断 言 可 以 有 两 种 形 式 : assert Expression1; assert Expression1 : Expression2 ; Expression1 应 该 总 是 产 生 一 个 布 尔 值 Expression2 可 以 是 得 出 一 个 值 的 任 意 表 达 式 ; 这 个 值 用 于 生 成 显 示 更 多 调 试 信 息 的 字 符 串 消 息 断 言 在 默 认 情 况 下 是 禁 用 的, 要 在 编 译 时 启 用 断 言, 需 使 用 source 1.4 标 记 : javac -source 1.4 Test.java 要 在 运 行 时 启 用 断 言, 可 使 用 -enableassertions 或 者 -ea 标 记 要 在 运 行 时 选 择 禁 用 断 言, 可 使 用 -da 或 者 -disableassertions 标 记 要 在 系 统 类 中 启 用 断 言, 可 使 用 -esa 或 者 -dsa 标 记 还 可 以 在 包 的 基 础 上 启 用 或 者 禁 用 断 言 可 以 在 预 计 正 常 情 况 下 不 会 到 达 的 任 何 位 置 上 放 置 断 言 断 言 可 以 用 于 验 证 传 递 给 私 有 方 法 的 参 数 不 过, 断 言 不 应 该 用 于 验 证 传 递 给 公 有 方 法 的 参 数, 因 为 不 管 是 否 启 用 了 断 言, 公 有 方 法 都 必 须 检 查 其 参 数 不 过, 既 可 以 在 公 有 方 法 中, 也 可 以 在 非 公 有 方 法 中 利 用 断 言 测 试 后 置 条 件 另 外, 断 言 不 应 该 以 任 何 方 式 改 变 程 序 的 状 态
45 Error 和 Exception 有 什 么 区 别? 答 :Error 表 示 系 统 级 的 错 误 和 程 序 不 必 处 理 的 异 常, 是 恢 复 不 是 不 可 能 但 很 困 难 的 情 况 下 的 一 种 严 重 问 题 ; 比 如 内 存 溢 出, 不 可 能 指 望 程 序 能 处 理 这 样 的 情 况 ;Exception 表 示 需 要 捕 捉 或 者 需 要 程 序 进 行 处 理 的 异 常, 是 一 种 设 计 或 实 现 问 题 ; 也 就 是 说, 它 表 示 如 果 程 序 运 行 正 常, 从 不 会 发 生 的 情 况 补 充 :2005 年 摩 托 罗 拉 的 面 试 中 曾 经 问 过 这 么 一 个 If 问 题 a process reports a stack overflow run-time error, what s the most possible cause?, 给 了 四 个 选 项 a. lack of memory; b. write on an invalid memory space; c. recursive function calling; d. array index out of boundary. Java 程 序 在 运 行 时 也 可 能 会 遭 遇 StackOverflowError, 这 是 一 个 错 误 无 法 恢 复, 只 能 重 新 修 改 代 码 了, 这 个 面 试 题 的 答 案 是 c 如 果 写 了 不 能 迅 速 收 敛 的 递 归, 则 很 有 可 能 引 发 栈 溢 出 的 错 误, 如 下 所 示 : package com.lovo; public class StackOverflowErrorTest { public static void main(string[] args) { main(null); 因 此, 用 递 归 编 写 程 序 时 一 定 要 牢 记 两 点 :1. 递 归 公 式 ;2. 收 敛 条 件 ( 什 时 候 就 不 再 递 归 而 是 回 溯 了 )
46 try{ 里 有 一 个 return 语 句, 那 么 紧 跟 在 这 个 try 后 的 finally{ 里 的 code 会 不 会 被 执 行, 什 么 时 候 被 执 行, 在 return 前 还 是 后? 答 : 会 执 行, 在 方 法 返 回 调 用 者 前 执 行 Java 允 许 在 finally 中 改 变 返 回 值 的 做 法 是 不 好 的, 因 为 如 果 存 在 finally 代 码 块,try 中 的 return 语 句 不 会 立 马 返 回 调 用 者, 而 是 记 录 下 返 回 值 待 finally 代 码 块 执 行 完 毕 之 后 再 向 调 用 者 返 回 其 值, 然 后 如 果 在 finally 中 修 改 了 返 回 值, 这 会 对 程 序 造 成 很 大 的 困 扰,C# 中 就 从 语 法 上 规 定 不 能 做 这 样 的 事 47 Java 语 言 如 何 进 行 异 常 处 理, 关 键 字 :throws throw try catch finally 分 别 如 何 使 用? 答 :Java 通 过 面 向 对 象 的 方 法 进 行 异 常 处 理, 把 各 种 不 同 的 异 常 进 行 分 类, 并 提 供 了 良 好 的 接 口 在 Java 中, 每 个 异 常 都 是 一 个 对 象, 它 是 Throwable 类 或 其 子 类 的 实 例 当 一 个 方 法 出 现 异 常 后 便 抛 出 一 个 异 常 对 象, 该 对 象 中 包 含 有 异 常 信 息, 调 用 这 个 对 象 的 方 法 可 以 捕 获 到 这 个 异 常 并 进 行 处 理 Java 的 异 常 处 理 是 通 过 5 个 关 键 词 来 实 现 :try catch throw throws 的 和 finally 一 般 情 况 下 是 用 try 来 执 行 一 段 程 序, 如 果 出 现 异 常, 系 统 会 抛 出 (throw) 一 个 异 常, 这 时 候 你 可 以 通 过 它 的 类 型 来 捕 捉 (catch) 它, 或 最 后 (finally) 由 缺 省 处 理 器 来 处 理 ;try 用 来 指 定 一 块 预 防 所 有 异 常 的 程 序 ;catch 子 句 紧 跟 在 try 块 后 面, 用 来 指 定 你 想 要 捕 捉 的 异 常 的 类 型 ;throw 语 句 用 来 明 确 地 抛 出 一 个 异 常 ;throws 用 来 标 明 一 个 成 员 函 数 可 能 抛 出 的 各 种 异 常 ;finally 为 确 保 一 段 代 码 不 管 发 生 什 么 异 常 都 被 执 行 一 段 代 码 ; 可 以 在 一 个 成 员 函 数 调 用 的 外 面 写 一 个 try 语 句, 在 这 个 成 员 函 数 内 部 写 另 一 个 try 语 句 保 护 其 他 代 码 每 当 遇 到 一 个 try 语 句, 异 常 的 框 架 就 放 到 栈 上 面, 直 到 所 有 的 try 语 句 都 完 成 如 果 下 一 级 的 try 语 句 没 有 对 某 种 异 常 进 行 处 理, 栈 就 会 展 开, 直 到 遇 到 有 处 理 这 种 异 常 的 try 语 句
48 运 行 时 异 常 与 受 检 异 常 有 何 异 同? 答 : 异 常 表 示 程 序 运 行 过 程 中 可 能 出 现 的 非 正 常 状 态, 运 行 时 异 常 表 示 虚 拟 机 的 通 常 操 作 中 可 能 遇 到 的 异 常, 是 一 种 常 见 运 行 错 误, 只 要 程 序 设 计 得 没 有 问 题 通 常 就 不 会 发 生 受 检 异 常 跟 程 序 运 行 的 上 下 文 环 境 有 关, 即 使 程 序 设 计 无 误, 仍 然 可 能 因 使 用 的 问 题 而 引 发 Java 编 译 器 要 求 方 法 必 须 声 明 抛 出 可 能 发 生 的 受 检 异 常, 但 是 并 不 要 求 必 须 声 明 抛 出 未 被 捕 获 的 运 行 时 异 常 异 常 和 继 承 一 样, 是 面 向 对 象 程 序 设 计 中 经 常 被 滥 用 的 东 西, 神 作 Effective Java 中 对 异 常 的 使 用 给 出 了 以 下 指 导 原 则 : 不 要 将 异 常 处 理 用 于 正 常 的 控 制 流 ( 设 计 良 好 的 API 不 应 该 强 迫 它 的 调 用 者 为 了 正 常 的 控 制 流 而 使 用 异 常 ) 对 可 以 恢 复 的 情 况 使 用 受 检 异 常, 对 编 程 错 误 使 用 运 行 时 异 常 避 免 不 必 要 的 使 用 受 检 异 常 ( 可 以 通 过 一 些 状 态 检 测 手 段 来 避 免 异 常 的 发 生 ) 优 先 使 用 标 准 的 异 常 每 个 方 法 抛 出 的 异 常 都 要 有 文 档 保 持 异 常 的 原 子 性 不 要 在 catch 中 忽 略 掉 捕 获 到 的 异 常 49 列 出 一 些 你 常 见 的 运 行 时 异 常? 答 :
ArithmeticException( 算 术 异 常 ) ClassCastException ( 类 转 换 异 常 ) IllegalArgumentException ( 非 法 参 数 异 常 ) IndexOutOfBoundsException ( 下 表 越 界 异 常 ) NullPointerException ( 空 指 针 异 常 ) SecurityException ( 安 全 异 常 ) 50 final, finally, finalize 的 区 别? 答 :final: 修 饰 符 ( 关 键 字 ) 有 三 种 用 法 : 如 果 一 个 类 被 声 明 为 final, 意 味 着 它 不 能 再 派 生 出 新 的 子 类, 即 不 能 被 继 承, 因 此 它 和 abstract 是 反 义 词 将 变 量 声 明 为 final, 可 以 保 证 它 们 在 使 用 中 不 被 改 变, 被 声 明 为 final 的 变 量 必 须 在 声 明 时 给 定 初 值, 而 在 以 后 的 引 用 中 只 能 读 取 不 可 修 改 被 声 明 为 final 的 方 法 也 同 样 只 能 使 用, 不 能 在 子 类 中 被 重 写 finally: 通 常 放 在 try catch 的 后 面 构 造 总 是 执 行 代 码 块, 这 就 意 味 着 程 序 无 论 正 常 执 行 还 是 发 生 异 常, 这 里 的 代 码 只 要 JVM 不 关 闭 都 能 执 行, 可 以 将 释 放 外 部 资 源 的 代 码 写 在 finally 块 中 finalize:object 类 中 定 义 的 方 法,Java 中 允 许 使 用 finalize() 方 法 在 垃 圾 收 集 器 将 对 象 从 内 存 中 清 除 出 去 之 前 做 必 要 的 清 理 工 作 这 个 方 法 是 由 垃 圾 收 集 器 在 销 毁 对 象 时 调 用 的, 通 过 重 写 finalize() 方 法 可 以 整 理 系 统 资 源 或 者 执 行 其 他 清 理 工 作 感 谢 原 作 者 的 精 心 整 理, 原 文 地 址 : http://blog.csdn.net/jackfrued/article/details/17339393
[ 剑 指 offer] 面 试 题 43:n 个 骰 子 的 点 数 (Java) 题 目 : 把 n 个 骰 子 扔 在 地 上, 所 有 骰 子 朝 上 一 面 的 点 数 之 和 为 S 输 入 n, 打 印 出 S 的 所 有 可 能 的 值 出 现 的 概 率 分 析 : 一 般 来 说 骰 子 只 有 6 面, 点 数 为 1~6, n 个 骰 故 子 的 最 小 和 为 n, 最 大 和 为 6*n, 则 n 个 骰 子 的 点 数 之 和 出 现 的 频 数 可 以 用 一 个 数 组 来 保 存, 大 小 为 6*n-n 思 路 1: 最 直 接 的 方 法 是 求 出 n 个 骰 子 点 数 的 全 排 列, 然 后 一 一 计 算 其 和 值, 统 计, 最 后 算 出 每 个 和 值 的 概 率, 这 里 使 用 基 于 递 归 的 方 法 来 求 各 和 值 的 频 数. 先 把 n 个 骰 子 分 为 两 堆 : 第 一 堆 只 有 一 个, 另 一 个 有 n-1 个 单 独 的 那 一 个 有 可 能 出 现 从 1 到 6 的 点 数 我 们 需 要 计 算 从 1 到 6 的 每 一 种 点 数 和 剩 下 的 n-1 个 骰 子 来 计 算 点 数 和 接 下 来 把 剩 下 的 n-1 个 骰 子 还 是 分 成 两 堆, 第 一 堆 只 有 一 个, 第 二 堆 有 n-2 个 我 们 把 上 一 轮 那 个 单 独 骰 子 的 点 数 和 这 一 轮 单 独 骰 子 的 点 数 相 加, 再 和 剩 下 的 n-2 个 骰 子 来 计 算 点 数 和 Java 实 现 代 码 : public class PrintSumProbabilityOfDices {
private int gmaxvalue = 6; public void probility(int orignal, int current, int sum, int[] probilities){ if(current == 1){ probilities[sum - orignal]++; else{ for(int i=1; i<= gmaxvalue; i++){ probility(orignal, current - 1, sum + i, probilities); public void probility(int number, int[] probilities){ for(int i=1; i<= gmaxvalue; i++){ probility(number,number, i,probilities); public void printprobability(int number){ if(number < 1) return; int maxsum = number * gmaxvalue; int[] probilities = new int[maxsum - number + 1]; probility(number, probilities); double total = Math.pow(gMaxValue, number); for(int i=number; i<= maxsum; i++){ double ratio = probilities[i - number] / total; System.out.println(i + ": " + ratio); public static void main(string[] args){ int number = 5; new PrintSumProbabilityOfDices().printProbability(number); 思 路 2: 基 于 循 环 求 骰 子 的 点 数, 这 样 避 免 了 很 多 重 复 的 计 算, 时 间 性 能 要 好 我 们 可 以 考 虑 用 两 个 数 组 来 存 储 骰 子 点 数 每 一 总 数 出 现 的 次 数 在 一 次 循 环 中, 第 一 个 数 组 中 的 第 n 个 数 字 表 示 骰 子 和 为 n 出 现 的 次 数 那 么 在 下
一 循 环 中, 我 们 加 上 一 个 新 的 骰 子 那 么 此 时 和 为 n 的 骰 子 出 现 的 次 数, 应 该 等 于 上 一 次 循 环 中 骰 子 点 数 和 为 n-1 n-2 n-3 n-4 n-5 与 n-6 的 总 和 Java 实 现 代 码 : public void printprobability_2(int number){ if(number < 1) return; int maxsum = gmaxvalue * number + 1; int[][] probilities = new int[2][maxsum]; int flag = 0; for(int i=1; i<=gmaxvalue; i++) probilities[flag][i] = 1; for(int i=2; i<= number; i++){ for(int j = 0; j<i; j++) probilities[1-flag][j] = 0; for(int j = i; j<=gmaxvalue * i; j++){ probilities[1-flag][j] = 0; for(int k=1; k<=j && k<=gmaxvalue; k++) probilities[1-flag][j] += probilities[flag][j-k]; flag = 1 - flag; double total = Math.pow(gMaxValue, number); for(int i=number; i< maxsum; i++){ double ratio = probilities[flag][i] / total; System.out.println(i + ": " + ratio); 考 点 总 结 :1. 考 察 数 学 建 模 能 力 能 否 想 到 用 数 组 建 立 一 个 简 单 的 哈 希 表 来 存 储 骰 子 点 数 和 值 的 频 数 2. 考 察 对 递 归 和 循 环 程 序 性 能 的 理 解
参 考 资 料 : 1. Offer 剑 指 名 企 面 试 官 精 讲 典 型 编 程 题 P223~226 [ 剑 指 offer] 面 试 题 42: 翻 转 单 词 顺 序 VS 左 旋 转 字 符 串 (Java) 题 目 : 输 入 一 个 英 文 句 子, 翻 转 句 子 中 单 词 的 顺 序, 但 单 词 内 字 符 的 顺 序 不 变 为 简 单 起 见, 标 点 符 号 和 普 通 字 母 一 样 处 理 例 如 输 入 字 符 串 I am a student., 则 输 出 "student. a am I". 实 现 代 码 public void reverse(char[] str, int start, int end){ System.out.println("tag XX"); if(str == null str.length < 2) return; int left = start; int right = end; while(left < right){ char tmp = str[right]; str[right--] = str[left]; str[left++] = tmp;
public void reversesentence(char[] str){ if(str == null str.length < 2) return; reverse(str, 0, str.length - 1); int left = 0; int right = 0; while(left < str.length){ if(str[left] == ' '){ left++; right++; else if(str[right] == ' ' right == str.length - 1){ System.out.println("left:" + left + ",right:" + right); reverse(str, left, (right == str.length -1)?right:(right-1)); left = right + 1; right++; else{ right++; 其 实 这 道 题 如 果 只 是 打 印 出 翻 转 后 的 句 子, 或 者 允 许 使 用 O(n) 的 空 间, 那 么 可 以 使 用 递 归 或 者 分 配 栈 来 完 成 会 更 加 简 便 至 于 左 旋 转 字 符 串, 其 实 有 了 反 转 句 子 的 基 础, 解 答 起 来 就 十 分 简 单 了
[ 剑 指 offer] 面 试 题 41: 和 为 s 的 两 个 数 字 VS 和 为 s 的 连 续 序 列 题 目 一 : 输 入 一 个 递 增 排 序 的 数 组 和 一 个 数 s, 字 在 数 组 中 查 找 两 个 数, 使 得 他 们 的 和 正 好 是 s, 如 果 有 多 对 数 字 的 和 等 于 s, 输 出 任 意 一 对 即 可 但 凡 搜 索 题, 一 般 都 可 以 通 过 暴 力 找 出 答 案, 但 那 样 的 解 往 往 会 令 不 会 帮 助 你 拿 到 心 仪 的 offer, 但 从 另 一 个 层 面 上 反 应 了 一 个 人 思 维 的 反 应 能 力, 在 输 入 规 模 较 少 的 情 况 下, 暴 力 也 不 是 不 能 解 决 问 题 这 道 题 的 暴 力 解 法 就 是 直 接 两 重 循 环, 遍 历 所 有 的 解, 时 间 复 杂 度 O(n^2) 能 O(n) 解 的 问 题,O(n^2) 的 解 法 显 然 无 法 得 到 面 试 官 的 青 睐 要 学 会 善 于 挖 掘 题 中 给 出 的 信 息, 递 增 排 序 的 数 组, 这 就 是 一 个 及 其 有 价 值 的 信 息 在 排 序 的 数 组 中, 一 般 会 想 到 二 分 来 搜 索 解, 因 为 二 分 的 解 法 可 能 只 会 需 要 O(logN) 的 时 间 的 复 杂 度 但 是 本 题 求 解 的 问 题 是 两 个 数 的 求 和, 也 可 能 不 会 只 有 一 个 解, 所 有 只 要 求 第 一 个 解, 这 样 不 宜 使 用 二 分, 而 是 使 用 双 指 针 来 解 答 这 道 题 思 路 是 定 义 两 个 指 针 ( 其 实 就 是 数 组 的 下 标 )left,right,left 指 向 开 始,right 指 向 数 组 最 后 一 个 元 素, 向 着 靠 拢 的 方 向 搜 索 第 一 个 可 能 的 解, 这 种 解 法 的 时 间 复 杂 度 是 O(n) 具 体 的 实 现 代 码 如 下 : index){ public boolean findnumberwithsum(int[] nums, int sum, int[] if(nums == null nums.length <2 index.length <2)
return false; boolean tag = false; int left = 0; int right = nums.length - 1; while(left < right){ int s = nums[left] + nums[right]; if(s == sum){ index[0] = nums[left]; index[1] = nums[right]; tag = true; break; else if(s > sum){ right --; else{ left++; return tag; 题 二 : 输 入 一 个 正 数 s, 打 印 出 所 有 和 为 s 的 连 续 正 整 数 序 列 ( 至 少 含 有 两 个 数 字 ), 例 如 15, 由 于 1+2+3+4+5 = 4+5+6 = 7+8 = 连 续 序 列 1~5,4~6,7~8 作 为 题 一 的 变 型 题, 难 度 有 所 提 高, 但 是 在 题 一 的 启 发 下, 也 不 难 想 出 解 法, 题 目 的 求 解 可 以 转 化 为 在 含 有 n 个 无 重 复 元 素 的 有 序 数 组 里 求 解 问 题, 那 么 同 样 可 以 使 用 双 指 针 来 求 解 注 意 本 题 的 关 键 在 于 解 是 连 续 的 整 数 序 列, 所 有 我 们 从 数 组 ( 假 设 出 来 的, 其 实 不 存 在 ) 的 一 端 移 动 两 个 指 针 (left,right, left<=right), 相 当 于 在 两 个 指 针 之 间 维 护 了 一 个 长 度 可 变 的 窗 口, 然 后 根 据 窗 口 内 各 元 素 的 和 值 去 移 动 两 个 指 针, 显 然 left 指 针 不 能 大 于 (n+1)/2 实 现 代 码 如 下 :
public List<List<Integer>> findcontinuoussequence(int sum){ List<List<Integer>> res = new ArrayList<List<Integer>>(); if(sum < 3) return res; int rear = 1; int front = 2; int tsum = rear + front; int mid = (sum + 1) / 2; while(rear < mid){ if(tsum == sum){ List<Integer> tmp = new ArrayList<Integer>(); for(int i = rear; i<= front; i++){ tmp.add(i); res.add(tmp); front++; rear++; tsum += (front - rear + 1); else if(tsum > sum){ tsum -= rear; rear++; else{ front ++; tsum += front; return res;