10 - java的常用api - Object String StringBuffer/StringBuilder 正则表达式
1. Object类
它是所有类的超类，祖宗类。java中所有的类都直接或间接的继承这个类
方法：
1.1. public String toString() 返回当前对象中的内容, 对于Object类默认操作来说，返回的对象的类型+@+内存地址值
1.2. public boolean equals(Object obj) 比较两个对象内容是否相同，对于Object类默认操作来说,比较的是地址值
package cn.itcast.demo01; public class Person extends Object{ private String name; private int age; public Person(){} public Person(String name, int age) { this.name = name; this.age = age; } /* * 重写父类的方法toString() * 没有必要让调用者看到内存地址 * 要求: 方法中,返回类中所有成员变量的值 */ public String toString(){ return name + age; } /* * 将父类的equals方法写过来,重写父类的方法 * 但是,不改变父类方法的源代码, 方法equals 比较两个对象的内存地址 * * 两个对象,比较地址,没有意义 * 比较两个对象的成员变量,age * 两个对象变量age相同,返回true,不同返回false * * 重写父类的equals,自己定义自己对象的比较方式 */ public boolean equals(Object obj){ if( this == obj){ return true; } //对参数obj,非null判断 if( obj == null){ return false; } if( obj instanceof Person){ // 参数obj接受到是Person对象,才能转型 // 对obj参数进行类型的向下转型,obj转成Person类型 Person p = (Person)obj; return this.age == p.age; } return false; } 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; } }
package cn.itcast.demo01; public class TestEquals { public static void main(String[] args) { //Person类继承Object类,继承下来了父类的方法equals Person p1 = new Person("李四",20); Person p2 = new Person("张三",20); //Person对象p1,调用父类的方法equals,进行对象的比较 boolean b = p1.equals(p1); System.out.println(b); boolean bo = p1.equals(p2); } }
package cn.itcast.demo01; public class TestToString { public static void main(String[] args) { //调用Person类的方法toString() //输出语句中,写的是一个对象,默认调用对象的toString方法 Person p = new Person("张三",20); String s = p.toString(); System.out.println(p); System.out.println(s); /* * System.out.println(p); * System.out.println(p.toString()); */ /*Random r = new Random(); System.out.println(r.toString()); Scanner sc = new Scanner(System.in); System.out.println(sc.toString());*/ } }
2. String类
字符串类，字符串是常量；它们的值在创建之后不能更改
方法：
2.1. boolean equals(Object obj) 判断两个字符串中的内容是否相同
2.2. boolean equalsIgnoreCase(String str) 判断两个字符串中的内容是否相同, 忽略大小写
2.3. boolean contains(String str) 判断该字符串中 是否包含给定的字符串
2.4. boolean startsWith(String str) 判断该字符串 是否以给定的字符串开头
2.5. boolean endsWith(String str) 判断该字符串 是否以给定的字符串结尾
2.6. boolean isEmpty() 判断该字符串的内容是否为空的字符串 ""
2.7. int length() 获取该字符串的长度
2.8. char charAt(int index) 获取该字符串中指定位置上的字符
2.9. String substring(int start) 从指定位置开始，到末尾结束，截取该字符串，返回新字符串
2.10. String substring(int start,int end) 从指定位置开始，到指定位置结束，截取该字符串，返回新字符串
2.11. int indexOf(int ch ) 获取给定的字符，在该字符串中第一次出现的位置
2.12. int indexOf(String str) 获取给定的字符串，在该字符串中第一次出现的位置
2.13. int indexOf(int ch,int fromIndex) 从指定位置开始，获取给定的字符，在该字符
2.14. byte[] getBytes() 把该字符串 转换成 字节数组
2.15. char[] toCharArray() 把该字符串 转换成 字符数组
2.16. String replace(char old,char new) 在该字符串中，将给定的旧字符，用新字符替换
2.17. String replace(String old,String new) 在该字符串中， 将给定的旧字符串，用新字符串替换
2.18. String trim() 去除字符串两端空格，中间的不会去除，返回一个新字符串
2.19. String toLowerCase() 把该字符串转换成 小写字符串
2.20. String toUpperCase() 把该字符串转换成 大写字符串
2.21. int indexOf(String str,int fromIndex) 从指定位置开始，获取给定的字符串，在该字符串中第一次出现的位置
package cn.itcast.demo02; /* * String类特点: * 一切都是对象,字符串事物 "" 也是对象 * 类是描述事物,String类,描述字符串对象的类 * 所有的 "" 都是String类的对象 * * 字符串是一个常量,一旦创建,不能改变 */ public class StringDemo { public static void main(String[] args) { //引用变量str执行内存变化 //定义好的字符串对象,不变 String str = "itcast"; System.out.println(str); str = "itheima"; System.out.println(str); } }
package cn.itcast.demo02; public class StringDemo2 { public static void main(String[] args) { //字符串定义方式2个, 直接= 使用String类的构造方法 String str1 = new String("abc"); String str2 = "abc"; System.out.println(str1); System.out.println(str2); System.out.println(str1==str2);//引用数据类型,比较对象的地址 false System.out.println(str1.equals(str2));//true } }
package cn.itcast.demo02; /* * String类构造方法 * String类的构造方法,重载形式 * */ public class StringDemo3 { public static void main(String[] args) { function_1(); } /* * String(char[] value) 传递字符数组 * 将字符数组,转成字符串, 字符数组的参数,不查询编码表 * * String(char[] value, int offset, int count) 传递字符数组 * 将字符数组的一部分转成字符串 * offset 数组开始索引 * count 个数 */ public static void function_1(){ char[] ch = {'a','b','c','d','e','f'}; //调用String构造方法,传递字符数组 String s = new String(ch); System.out.println(s); String s1 = new String(ch,1,4); System.out.println(s1); } /* * 定义方法,String类的构造方法 * String(byte[] bytes) 传递字节数组 * 字节数组转成字符串 * 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。 * 平台 : 机器操作系统 * 默认字符集: 操作系统中的默认编码表, 默认编码表GBK * 将字节数组中的每个字节,查询了编码表,得到的结果 * 字节是负数,汉字的字节编码就是负数, 默认编码表 ,一个汉字采用2个字节表示 * * String(byte[] bytes, int offset, int length) 传递字节数组 * 字节数组的一部分转成字符串 * offset 数组的起始的索引 * length 个数,转几个 , 不是结束的索引 */ public static void function(){ byte[] bytes = {97,98,99,100}; //调用String类的构造方法,传递字节数组 String s = new String(bytes); System.out.println(s); byte[] bytes1 ={65,66,67,68,69}; //调用String构造方法,传递数组,传递2个int值 String s1 = new String(bytes1,1,3); System.out.println(s1); } }
package cn.itcast.demo02; /* * String类的查找功能 */ public class StringDemo4 { public static void main(String[] args) { function_9(); } /* * boolean equals(Object obj) * 方法传递字符串,判断字符串中的字符是否完全相同,如果完全相同返回true * * boolean equalsIgnoreCase(String s) * 传递字符串,判断字符串中的字符是否相同,忽略大小写 */ public static void function_9(){ String str1 = "Abc"; String str2 = "abc"; //分别调用equals和equalsIgnoreCase boolean b1 = str1.equals(str2); boolean b2 = str1.equalsIgnoreCase(str2); System.out.println(b1); System.out.println(b2); } /* * char[] toCharArray() 将字符串转成字符数组 * 功能和构造方法相反 */ public static void function_8(){ String str = "itcast"; //调用String类的方法toCharArray() char[] ch = str.toCharArray(); for(int i = 0 ; i < ch.length ; i++){ System.out.println(ch[i]); } } /* * byte[] getBytes() 将字符串转成字节数组 * 此功能和String构造方法相反 * byte数组相关的功能,查询编码表 */ public static void function_7(){ String str = "abc"; //调用String类方法getBytes字符串转成字节数组 byte[] bytes = str.getBytes(); for(int i = 0 ; i < bytes.length ; i++){ System.out.println(bytes[i]); } } /* * int indexOf(char ch) * 查找一个字符,在字符串中第一次出现的索引 * 被查找的字符不存在,返回-1 */ public static void function_6(){ String str = "itcast.cn"; //调用String类的方法indexOf int index = str.indexOf('x'); System.out.println(index); } /* * boolean contains (String s) * 判断一个字符串中,是否包含另一个字符串 */ public static void function_5(){ String str = "itcast.cn"; //调用String类的方法contains boolean b =str.contains("ac"); System.out.println(b); } /* * boolean endsWith(String prefix) * 判断一个字符串是不是另一个字符串的后缀,结尾 * Demo.java * .java */ public static void function_4(){ String str = "Demo.java"; //调用String类方法endsWith boolean b = str.endsWith(".java"); System.out.println(b); } /* * boolean startsWith(String prefix) * 判断一个字符串是不是另一个字符串的前缀,开头 * howareyou * hOw */ public static void function_3(){ String str = "howareyou"; //调用String类的方法startsWith boolean b = str.startsWith("hOw"); System.out.println(b); } /* * String substring(int beginIndex,int endIndex) 获取字符串的一部分 * 返回新的字符串 * 包含头,不包含尾巴 * * String substring(int beginIndex)获取字符串的一部分 * 包含头,后面的字符全要 */ public static void function_2(){ String str = "howareyou"; //调用String类方法substring获取字符串一部分 str= str.substring(1, 5); System.out.println(str); String str2 = "HelloWorld"; str2 = str2.substring(1); System.out.println(str2); } /* * int length() 返回字符串的长度 * 包含多少个字符 */ public static void function(){ String str = "cfxdf#$REFewfrt54GT"; //调用String类方法length,获取字符串长度 int length = str.length(); System.out.println(length); } }
package cn.itcast.demo02; public class StringTest { public static void main(String[] args) { getCount("A%A3eBr1FFy"); System.out.println(toConvert("aBc5%4dEF")); System.out.println(getStringCount("hellojava,nijavahaojava,javazhenbang", "java")); } /* * 获取一个字符串中,另一个字符串出现的次数 * 思想: * 1. indexOf到字符串中到第一次出现的索引 * 2. 找到的索引+被找字符串长度,截取字符串 * 3. 计数器++ */ public static int getStringCount(String str, String key){ //定义计数器 int count = 0; //定义变量,保存indexOf查找后的索引的结果 int index = 0; //开始循环找,条件,indexOf==-1 字符串没有了 while(( index = str.indexOf(key) )!= -1){ count++; //获取到的索引,和字符串长度求和,截取字符串 str = str.substring(index+key.length()); } return count; } /* * 将字符串的首字母转成大写,其他内容转成小写 * 思想: * 获取首字母, charAt(0) substring(0,1) * 转成大写 toUpperCase() * * 获取剩余字符串, substring(1) toLowerCase() */ public static String toConvert(String str){ //定义变量,保存首字母,和剩余字符 String first = str.substring(0,1); String after = str.substring(1); //调用String类方法,大写,小写转换 first = first.toUpperCase(); after = after.toLowerCase(); return first+after; } /* * 获取指定字符串中，大写字母、小写字母、数字的个数。 * 思想: * 1. 计数器,就是int变量,满足一个条件 ++ * 2. 遍历字符串, 长度方法length() + charAt() 遍历 * 3. 字符判断是大写,是小写,还是数字 */ public static void getCount(String str){ //定义三个变量,计数 int upper = 0; int lower = 0; int digit = 0; //对字符串遍历 for(int i = 0 ; i < str.length() ; i++){ //String方法charAt,索引,获取字符 char c = str.charAt(i); //利用编码表 65-90 97-122 48-57 if(c >='A' && c <=90){ upper++; }else if( c >= 97 && c <= 122){ lower++; }else if( c >= 48 && c <='9'){ digit++; } } System.out.println(upper); System.out.println(lower); System.out.println(digit); } }
3. StringBuffer/StringBuilder类：
StringBuffer 线程安全，慢。
StringBuilder 线程不安全，快。一般用这个。
方法：
3.1. public StringBuffer append(String str) 在原有字符串缓冲区内容基础上，在末尾追加新数据
3.2. public StringBuffer insert(int offset,String str) 在原有字符串缓冲区内容基础上，在指定位置插入新数据
3.3. public StringBuffer deleteCharAt(int index) 在原有字符串缓冲区内容基础上，删除指定位置上的字符
3.4. public StringBuffer delete(int start,int end) 在原有字符串缓冲区内容基础上，删除指定范围内的多个字符
3.5. public StringBuffer replace(int start,int end,String str)在原有字符串缓冲区内容基础上，将指定范围内的多个字符 用给定的字符串替换
3.6. public StringBuffer reverse() 将字符串缓冲区的内容 反转 "abc"----"cba"
3.7. public String substring(int start) 从指定位置开始，到末尾结束，截取该字符串缓冲区，返回新字符串
3.8. public String substring(int start,int end) 从指定位置开始，到指定位置结束，截取该字符串缓冲区，返回新字符串
package cn.itcast.demo03; public class StringBufferDemo { public static void main(String[] args) { function_5(); } /* * StringBuffer类的方法 * String toString() 继承Object,重写toString() * 将缓冲区中的所有字符,变成字符串 */ public static void function_5(){ StringBuffer buffer = new StringBuffer(); buffer.append("abcdef"); buffer.append(12345); //将可变的字符串缓冲区对象,变成了不可变String对象 String s = buffer.toString(); System.out.println(s); } /* * StringBuffer类的方法 * reverse() 将缓冲区中的字符反转 */ public static void function_4(){ StringBuffer buffer = new StringBuffer(); buffer.append("abcdef"); buffer.reverse(); System.out.println(buffer); } /* * StringBuffer类方法 * replace(int start,int end, String str) * 将指定的索引范围内的所有字符,替换成新的字符串 */ public static void function_3(){ StringBuffer buffer = new StringBuffer(); buffer.append("abcdef"); buffer.replace(1, 4, "Q"); System.out.println(buffer); } /* * StringBuffer类方法 insert * insert(int index, 任意类型) * 将任意类型数据,插入到缓冲区的指定索引上 */ public static void function_2(){ StringBuffer buffer = new StringBuffer(); buffer.append("abcdef"); buffer.insert(3, 9.5); System.out.println(buffer); } /* * StringBuffer类方法 * delete(int start,int end) 删除缓冲区中字符 * 开始索引包含,结尾索引不包含 */ public static void function_1(){ StringBuffer buffer = new StringBuffer(); buffer.append("abcdef"); buffer.delete(1,5); System.out.println(buffer); } /* * StringBuffer类方法 * StringBuffer append, 将任意类型的数据,添加缓冲区 * append 返回值,写return this * 调用者是谁,返回值就是谁 */ public static void function(){ StringBuffer buffer = new StringBuffer(); //调用StringBuffer方法append向缓冲区追加内容 buffer.append(6).append(false).append('a').append(1.5); System.out.println(buffer); } }
package cn.itcast.demo03; public class StringBufferTest { public static void main(String[] args) { int[] arr = {4,1,4,56,7,8,76}; System.out.println(toString(arr)); } /* * int[] arr = {34,12,89,68};将一个int[]中元素转成字符串 * 格式 [34,12,89,68] * String s = "[" * 数组遍历 * s+= arr[i]; * s+"]" * StringBuffer实现,节约内存空间, String + 在缓冲区中,append方法 */ public static String toString(int[] arr){ //创建字符串缓冲区 StringBuffer buffer = new StringBuffer(); buffer.append("["); //数组遍历 for(int i = 0 ; i < arr.length;i++){ //判断是不是数组的最后一个元素 if(i == arr.length-1){ buffer.append(arr[i]).append("]"); }else{ buffer.append(arr[i]).append(","); } } return buffer.toString(); } }
4. 正则表达式：
用来定义匹配规则，匹配一系列符合某个句法规则的字符串。
匹配规则：
字符：x
含义：代表的是字符x
例如：匹配规则为 "a"，那么需要匹配的字符串内容就是 ”a”
字符：\\
含义：代表的是反斜线字符'\'
例如：匹配规则为"\\" ，那么需要匹配的字符串内容就是 ”\”
字符：\t
含义：制表符
例如：匹配规则为"\t" ，那么对应的效果就是产生一个制表符的空间
字符：\n
含义：换行符
例如：匹配规则为"\n"，那么对应的效果就是换行,光标在原有位置的下一行
字符：\r
含义：回车符
例如：匹配规则为"\r" ，那么对应的效果就是回车后的效果,光标来到下一行行首
字符类：[abc]
含义：代表的是字符a、b 或 c
例如：匹配规则为"[abc]" ，那么需要匹配的内容就是字符a，或者字符b，或字符c的一个
字符类：[^abc]
含义：代表的是除了 a、b 或 c以外的任何字符
例如：匹配规则为"[^abc]"，那么需要匹配的内容就是不是字符a，或者不是字符b，或不是字符c的任意一个字符
字符类：[a-zA-Z]
含义：代表的是a 到 z 或 A 到 Z，两头的字母包括在内
例如：匹配规则为"[a-zA-Z]"，那么需要匹配的是一个大写或者小写字母
字符类：[0-9]
含义：代表的是 0到9数字，两头的数字包括在内
例如：匹配规则为"[0-9]"，那么需要匹配的是一个数字
字符类：[a-zA-Z_0-9]
含义：代表的字母或者数字或者下划线(即单词字符)
例如：匹配规则为" [a-zA-Z_0-9] "，那么需要匹配的是一个字母或者是一个数字或一个下滑线
预定义字符类：.
含义：代表的是任何字符
例如：匹配规则为" . "，那么需要匹配的是一个任意字符。如果，就想使用 . 的话，使用匹配规则"\\."来实现
预定义字符类：\d
含义：代表的是 0到9数字，两头的数字包括在内，相当于[0-9]
例如：匹配规则为"\d "，那么需要匹配的是一个数字
预定义字符类：\w
含义：代表的字母或者数字或者下划线(即单词字符)，相当于[a-zA-Z_0-9]
例如：匹配规则为"\w "，，那么需要匹配的是一个字母或者是一个数字或一个下滑线
边界匹配器：^
含义：代表的是行的开头
例如：匹配规则为^[abc][0-9]$ ，那么需要匹配的内容从[abc]这个位置开始, 相当于左双引号
边界匹配器：$
含义：代表的是行的结尾
例如：匹配规则为^[abc][0-9]$ ，那么需要匹配的内容以[0-9]这个结束, 相当于右双引号
边界匹配器：\b
含义：代表的是单词边界
例如：匹配规则为"\b[abc]\b" ，那么代表的是字母a或b或c的左右两边需要的是非单词字符([a-zA-Z_0-9])
数量词：X?
含义：代表的是X出现一次或一次也没有
例如：匹配规则为"a?"，那么需要匹配的内容是一个字符a，或者一个a都没有
数量词：X*
含义：代表的是X出现零次或多次
例如：匹配规则为"a*" ，那么需要匹配的内容是多个字符a，或者一个a都没有
数量词：X+
含义：代表的是X出现一次或多次
例如：匹配规则为"a+"，那么需要匹配的内容是多个字符a，或者一个a
数量词：X{n}
含义：代表的是X出现恰好 n 次
例如：匹配规则为"a{5}"，那么需要匹配的内容是5个字符a
数量词：X{n,}
含义：代表的是X出现至少 n 次
例如：匹配规则为"a{5, }"，那么需要匹配的内容是最少有5个字符a
数量词：X{n,m}
含义：代表的是X出现至少 n 次，但是不超过 m 次
例如：匹配规则为"a{5,8}"，那么需要匹配的内容是有5个字符a 到 8个字符a之间
练习：
规则："[0-9]{6,12}" 该规则需要匹配的内容是：长度为6位到12位的数字。
规则："1[34578][0-9]{9}" 该规则需要匹配的内容是：11位的手机号码，第1位为1，第2位为3、4、5、7、8中的一个，后面9位为0到9之间的任意数字。
规则："a*b" 该规则需要匹配的内容是：在多个a或零个a后面有个b；b必须为最后一个字符。
常用方法：
public boolean matches(String regex) //判断字符串是否匹配给定的规则
public String[] split(String regex) //根据给定正则表达式的匹配规则，拆分此字符串
public String replaceAll(String regex,String replacement) //将符合规则的字符串内容，全部替换为新字符串
练习：
1.匹配正确的数字
匹配规则：
匹配正整数：”\\d+”
匹配正小数：”\\d+\\.\\d+”
匹配负整数：”-\\d+”
匹配负小数：”-\\d+\\.\\d+”
匹配保留两位小数的正数：”\\d+\\.\\d{2}”
匹配保留1-3位小数的正数：”\\d+\\.\\d{1,3}”
2.匹配合法的邮箱
匹配规则：
”[a-zA-Z_0-9]+@[a-zA-Z_0-9]+(\\.[a-zA-Z_0-9]+)+”
”\\w+@\\w+(\\.\\w+)+”
3.获取IP地址(192.168.1.100)中的每段数字
匹配规则：
”\\.”
package cn.itcast.demo01; /* * 实现正则规则和字符串进行匹配,使用到字符串类的方法 * String类三个和正则表达式相关的方法 * boolean matches(String 正则的规则) * "abc".matches("[a]") 匹配成功返回true * * String[] split(String 正则的规则) * "abc".split("a") 使用规则将字符串进行切割 * * String replaceAll( String 正则规则,String 字符串) * "abc0123".repalceAll("[\\d]","#") * 安装正则的规则,替换字符串 */ public class RegexDemo { public static void main(String[] args) { checkTel(); } /* * 检查手机号码是否合法 * 1开头 可以是34578 0-9 位数固定11位 */ public static void checkTel(){ String telNumber = "1335128005"; //String类的方法matches boolean b = telNumber.matches("1[34857][\\d]{9}"); System.out.println(b); } /* * 检查QQ号码是否合法 * 0不能开头,全数字, 位数5,10位 * 123456 * \\d \\D匹配不是数字 */ public static void checkQQ(){ String QQ = "123456"; //检查QQ号码和规则是否匹配,String类的方法matches boolean b = QQ.matches("[1-9][\\d]{4,9}"); System.out.println(b); } }
package cn.itcast.demo01; public class RegexDemo1 { public static void main(String[] args) { replaceAll_1(); } /* * "Hello12345World6789012"将所有数字替换掉 * String类方法replaceAll(正则规则,替换后的新字符串) */ public static void replaceAll_1(){ String str = "Hello12345World6789012"; str = str.replaceAll("[\\d]+", "#"); System.out.println(str); } /* * String类方法split对字符串进行切割 * 192.168.105.27 按照 点切割字符串 */ public static void split_3(){ String ip = "192.168.105.27"; String[] strArr = ip.split("\\."); System.out.println("数组的长度"+strArr.length); for(int i = 0 ; i < strArr.length ; i++){ System.out.println(strArr[i]); } } /* * String类方法split对字符串进行切割 * 18 22 40 65 按照空格切割字符串 */ public static void split_2(){ String str = "18 22 40 65"; String[] strArr = str.split(" +"); System.out.println("数组的长度"+strArr.length); for(int i = 0 ; i < strArr.length ; i++){ System.out.println(strArr[i]); } } /* * String类方法split对字符串进行切割 * 12-25-36-98 按照-对字符串进行切割 */ public static void split_1(){ String str = "12-25-36-98"; //按照-对字符串进行切割,String类方法split String[] strArr = str.split("-"); System.out.println("数组的长度"+strArr.length); for(int i = 0 ; i < strArr.length ; i++){ System.out.println(strArr[i]); } } }
package cn.itcast.demo01; public class RegexDemo2 { public static void main(String[] args) { checkMail(); } /* * 检查邮件地址是否合法 * 规则: * 1234567@qq.com * mym_ail@sina.com * nimail@163.com * wodemail@yahoo.com.cn * * @: 前 数字字母_ 个数不能少于1个 * @: 后 数字字母 个数不能少于1个 * .: 后面 字母 * */ public static void checkMail(){ String email ="abc123@sina.com"; boolean b = email.matches("[a-zA-Z0-9_]+@[0-9a-z]+(\\.[a-z]+)+"); System.out.println(b); } }
