JAVA String常用APi

JAVA String 常 用API 2015 年 5 月13 日 星 期 三 ------------------------------------------ String 类 的 特 点 : 字 符 串 对 象 一 旦 被 初 始 化 就 不 会 被 改 变 abc 存 储 在 字 符 串 常 量 池 中 Java 的 核 心 类 包 是 java.lang eclipse:ctrl+ 方 向 键 下 = 向 下 复 制? 面 试 题 : String s = "abc" ; String s1 = new String( "abc"); System. out.println( s== s1); 这 两 个 String 是 不 一 样 的 上 面 在 常 量 池 里 创 建 一 个 字 符 串 对 象, 下 面 在 堆 里 创 建 两 个 对 象, 一 个 new, 一 个 字 符 串 对 象 所 以 结 果 是 false System.out.println(s.equals( s1)); 结 果 是 true String 类 中 的 equals 复 写 了 Object 类 中 的 equals, 建 立 了 自 己 的 判 断 字 符 串 对 象 是 否 相 同 的 依 据 其 实 就 是 比 较 字 符 串 内 容 String s = new String();// 等 效 于 String s = "", 不 等 效 于 String s = null; byte[] arr = 97,66,67,68; String s1 = new String(arr); 这 里 将 字 节 数 组 变 成 了 字 符 串, 所 以 s1 的 值 是 abcd 按 照 面 向 对 象 的 思 想 对 字 符 串 进 行 功 能 分 类 : "abcd" 1. 获 取 : 1.1 获 取 字 符 串 中 字 符 的 个 数 ( 长 度 ): int length(); 1.2 根 据 位 置 获 取 字 符 : char charat(int index); 1.3 根 据 字 符 获 取 在 字 符 串 中 第 一 次 出 现 的 位 置 : int indexof(int ch); int indexof(int ch, int fromindex) 从 指 定 位 置 进 行ch 的 查 找 第 一 次 出 现 的 位 置 int indexof(string str); int indexof(string str, int formindex); 最 后 一 次 出 现 的 位 置 : int lastindexof(int ch); int lastindexof(int ch, int fromindex) 从 指 定 位 置 进 行ch 的 查 找 第 一 次 出 现 的 位 置 int lastindexoff(string str); int lastindexof(string str, int fromindex); 1.4 获 取 字 符 串 中 一 部 分 字 符 串, 也 叫 字 串 String substring(int beginindex, int endindex); 从 beginindex 到 endindex-1 String substring(int beginindex); 2. 转 换 1

2015 年 5 月13 日 星 期 三 2.1 将 字 符 串 变 成 字 符 串 数 组 ( 字 符 串 的 切 割 ) String[] split(string regex); 涉 及 到 正 则 表 达 式 2.2 将 字 符 串 变 成 字 符 数 组 char[] tochararray(); 2.3 将 字 符 串 变 成 字 节 数 组 byte[] getbytes(); 2.4 将 字 符 串 中 的 字 母 转 成 大 小 写 String touppercase(); String tolowercase(); 2.5 将 字 符 串 中 的 内 容 进 行 替 换 String replace(char oldchar, char newchar); String replace(string olds; String news); String s1 = "java"; String s2 = s1.replace( 'q', 'z'); System. out.println(s1 ==s2 );//true 2.6 将 字 符 串 两 端 空 格 去 除 String trim(); 2.7 将 字 符 串 进 行 连 接 String concat(string s1, String s2); 3. 判 断 3.1 两 个 字 符 串 内 容 是 否 相 同 啊? boolean equals(object obj); boolean equalsignorecase(string str); 忽 略 大 小 写 比 较 字 符 串 内 容 3.2 字 符 串 中 是 否 包 含 指 定 字 符 串? boolean contains(string str); 3.3 字 符 串 是 否 以 指 定 字 符 串 开 头, 是 否 以 指 定 字 符 串 结 尾 boolean startswith(string); boolean endwith(string); 4. 比 较 int compareto(string anotherstring) intern(): 对 字 符 串 池 进 行 操 作 String 类 练 习 : Problem1 给 定 一 个 字 符 串 数 组, 按 照 字 典 顺 序 进 行 从 小 到 大 的 排 序 "nba","abc","cba","qq","haha" 思 路 : 1. 对 数 组 排 序 可 以 用 选 择, 冒 泡 都 行 2.for 嵌 套 和 比 较 以 及 换 位 3. 问 题 : 以 前 排 的 是 整 数, 比 较 用 的 是 比 较 运 算 符, 可 是 现 在 是 字 符 串 对 象 字 符 串 对 象 怎 么 比 较 呢? 爽 了, 对 象 中 提 供 了 用 于 字 符 串 对 象 比 较 的 功 能 Problem2 一 个 字 串 在 整 串 中 出 现 的 次 数 "nbaernbatynbauinbaopnba" 思 路 : 2

2015 年 5 月13 日 星 期 三 1. 要 找 的 字 串 是 否 存 在, 如 果 存 在 获 取 其 出 现 的 位 置 这 个 可 以 使 用indexOf 完 成 2. 如 果 找 到 了, 那 么 就 记 录 出 现 的 位 置, 并 在 剩 余 的 字 符 串 中 继 续 查 找 该 字 串 而 剩 余 字 符 串 的 起 始 位 是 出 现 位 置 加 字 串 的 长 度 3. 以 此 类 推, 通 过 循 环 完 成 查 找, 如 果 找 不 到 就 是 -1, 并 对 每 次 找 到 用 计 数 器 记 录 Problem3 两 个 字 符 串 中 最 大 相 同 的 字 串 String str1 = "qwerabcdtyuiop"; String str2 = "xcabcdvbn"; 思 路 : 1. 既 然 取 的 是 最 大 字 串, 先 看 短 的 那 个 字 符 串 是 否 在 长 的 那 个 字 符 串 中 如 果 存 在, 短 的 那 个 字 符 串 就 是 最 大 字 符 串 2. 如 果 不 是, 就 将 短 的 字 串 进 行 长 度 递 减 的 方 式 取 子 串, 去 长 串 中 判 断 是 否 存 在 如 果 存 在 就 已 找 到, 就 不 用 再 找 了 private static String unisubstring(string s1, String s2) for(int i = 0; i < s2.length(); i++) for(int a = 0,b =s2.length()- i; b!=s2.length() +1; a++, b++) String sub = s2.substring( a, b); //System.out.println(sub); if(s1.contains(sub)) return sub ; return null ; Problem4 模 拟 一 个 trim 功 能 一 致 的 方 法, 去 除 字 符 串 两 端 的 空 白 思 路 :1. 定 义 两 个 变 量, 一 个 变 量 作 为 从 头 开 始 判 断 字 符 串 空 格 的 角 标, 一 个 变 量 作 为 从 尾 开 始 判 断 字 符 串 空 格 的 角 标 2. 判 断 到 不 是 空 格 为 止, 取 头 尾 之 间 的 字 符 串 即 可 注 意 保 证 前 面 的 变 量 小 于 等 于 后 面 的 变 量 StringBuffer StringBuffer: 就 是 字 符 串 缓 冲 区 用 于 存 储 数 据 的 容 器 特 点 : 1, 长 度 的 可 变 的 2, 可 以 存 储 不 同 类 型 数 据 3, 最 终 要 转 成 字 符 串 进 行 使 用 4, 可 以 对 字 符 串 进 行 修 改 既 然 是 一 个 容 器 对 象 应 该 具 备 什 么 功 能 呢? 1, 添 加 : StringBuffer append(data); 3

2015 年 5 月13 日 星 期 三 StringBuffer insert(index,data); 2, 删 除 : StringBuffer delete(start,end): 包 含 头, 不 包 含 尾 StringBuffer deletecharat(int index): 删 除 指 定 位 置 的 元 素 3, 查 找 : char charat(index); int indexof(string); int lastindexof(string); 4, 修 改 : StringBuffer replace(start,end,string); void setcharat(index,char); 增 删 改 查 C(create)U(update)R(read)D(delete) 清 空 缓 冲 区 sb.delete(0,sb.length()); sb = new StringBuffer(); StringBuilder jdk1.5 以 后 出 现 了 功 能 和 StringBuffer 一 模 一 样 的 对 象 就 是 StringBuilder 不 同 的 是 : StringBuffer 是 线 程 同 步 的 通 常 用 于 多 线 程 StringBuilder 是 线 程 不 同 步 的 通 常 用 于 单 线 程 它 的 出 现 提 高 效 率 jdk 升 级 : 1, 简 化 书 写 2, 提 高 效 率 3, 增 加 安 全 性 / class StringBuffer jdk1.0 object lock; public StirngBuffer append(int x) synchronized(lock) 4 public synchronized StringBuffer delete(int start,int end) synchronized(lock)

2015 年 5 月13 日 星 期 三 基 本 数 据 类 型 对 象 包 装 类 : 为 了 方 便 操 作 基 本 数 据 类 型 值, 将 其 封 装 成 了 对 象, 在 对 象 中 定 义 了 属 性 和 行 为 丰 富 了 数 据 操 作 int Integer boolean Boolean double Double char Char 该 包 装 对 象 主 要 用 基 本 类 型 和 字 符 串 之 间 的 转 换 基 本 类 型 - 字 符 串 : 1. 基 本 类 型 数 值 + 2.String 中 的 静 态 方 法 valueof( 基 本 类 型 数 值 ) 字 符 串 - 基 本 类 型 : 1. 使 用 包 装 类 中 的 静 态 方 法 parseint xxx.parsexxx( xxx 类 型 的 字 符 串 ") 只 有 character 没 有 parse 方 法 ( 用forDigit) 2. 如 果 字 符 串 被 Integer 进 行 对 象 的 封 装, 即 new Integer( s ); 可 使 用 另 一 个 非 静 态 的 方 法,intValue(); 将 一 个 Integer 对 象 转 成 基 本 数 据 类 型 值, 如 Integer i = new Integer( 123 ); i.intvalue(); 整 数 的 不 同 进 制 : 1. 〸十 进 制 转 其 他 进 制 :tostring( 整 数, 进 制 ); 转 二 进 制 : Integer.toBinaryString( 整 数 ); 转 八 进 制 : Integer.toOctalString( 整 数 ); 转 〸十 六 进 制 :Integer.toHexString( 整 数 ); 2. 其 他 进 制 转 〸十 进 制 Integer.parseInt( 整 数 的 字 符 串, 转 之 前 的 进 制 ); Integer a = new Integer("5" ); Integer b = new Integer(5); System. out.println(a ==b ); System. out.println(a.equals(b )); System. out.println(a.compareto(b)); Integer a = new Integer(127) Integer b = new Integer(127); System. out.println(a == b ); //false System. out.println(a.equals(b ));//True 5

因 为 这 里 的 a,b 都 是 对 象, 调 用 对 象 的 equals 方 法 比 较 的 是 负 值 2015 年 5 月13 日 星 期 三 装 箱 拆 箱 : Integer i = 4; //i = new Integer(4); 自 动 装 箱, 简 化 书 写 i = i + 6; // i = new Integer(i.intValue() + 6); // i.intvalue() 自 动 拆 箱 Integer x = 127; //jdk1.5 以 后, 自 动 装 箱, 如 果 装 箱 的 是 一 个 字 节, 那 么 该 数 据 会 被 共 享 不 会 重 新 开 辟 空 间 Integer y = 127; System. out.println(x ==y ); //true System. out.println(x.equals(y ));//true ctrl+shift+x 大 写 ctrl+shift+y 小 写 private static final String SPACE_SEPARATOR = " ";// 封 装 StringBuiler StringBuffer 最 终 必 须 转 成 字 符 串 才 可 以 用 6