1. 包装类
Java为8个基本类型提供了包装类，使得基本数据类型能够被当作Object类使用。
包装类的构建：
//将基本数据类型包装成包装类
Integer a = new Integer(5);
Double b = new Double(3.5);
Float f = new Float(4.5f);
//将字符串转换为包装类对象
Integer i = new Integer("5");
Boolean b2 = new Boolean("false");
//使用自动装箱创建
Integer iObject = 3;
Boolean bObject = true;2) 基本数据类型和字符串之间的转换
字符串转换为基本数据类型有两种方法，一种是使用包装类的构造方法，一种是使用包装类的parseXxx(String str)方法进行转换。如下：
int a = new Integer(“12”); //使用了包装类的自动拆箱
int b = Integer.parseInt(“12”); //使用了包换类的静态方法基本类型转换字符串可以使用String类的valueOf()静态方法或者是将基本类型与空字符串做连接运算。
String str = String.valueOf(12); //使用valueOf()静态方法
String str2 = 12 + “”; //连接一个空字符串;3) 包装类的比较
①包装类对象与基本类型的变量可以直接比较；
②包装类对象之间使用 ==比较时，比较的是引用。注意：整型包装类会缓存-128 ~ 127之间的整数，将其装箱放入包装类数组，所以两个该范围内的两个数值相等的包装类使用 == 比较返回true。
Integer a = 3;
Integer b = 3;
System.out.println(a == b) //两个引用指向同缓存数组中的同一个对象，返回true
Interger c = new Interger(4);
Interger d = new Inerger(4);
System.out.println(c == d) //两个引用指向内存中不同的对象，返回false③使用包装类的compare()方法比较两个基本类型
System.out.println(Integer.compare(new Integer(128), newInteger(128))); //返回true;2. 对象的处理
1) toString()方法
toString()是对象的自我描述。是Object类的实例方法。默认返回值为字符串：类名 + @ + 对象的hashcode。可重写此方法对输入自己需要的信息。
2) == 和 equals的区别
== 运算符比较两个数值型的基本类型变量时，只要数值相同，即使类型不同也返回true；
== 比较引用类型时，当变量引用的对象相同，返回true；
Equals()方法是Object类提供的方法。Object类中equals()方法的采用 == 进行比较，所以使用equals()比较与 == 比较完全相同。用户可对euqls()方法进行重写，自定义比较的条件。
String类已经重写了equals()方法，当两个字符串的字符序列相同，返回true;
注意：当程序首次出现一个字符串常量时，JVM会使用常量池缓存该字符串，当以后出现能够在编译时就能确定字符串时，如果两者字符序列相同，则将指向常量池中的字符串对象。
3. final 修饰符
1) final修饰静态字段和实例字段
final修饰静态字段时，并须在定义字段、静态初始化块中初始化。
final修饰实例字段时，必须在定义字段、非静态初始化块、类构造器中初始化。
final变量初始化后就不能再改变；
2) final 修饰局部变量
修饰局部变量是，系统不会为变量执行默认初始化，所以必须显示初始化。初始化的时机有两个，1.声明变量时 2.声明变量时未初始化，可在后面的代码中进行初始化，初始化后不能为变量重新赋值。
修饰引用变量时，变量的引用不可改变，但变量指向的对象可变：
final int[] arr = {1,2,3,4}; //final修饰的数组，数组同样是引用类型
arr[0] = 4; //可修改数组元素
Arrays.sort(arr); //对数组排序，合法
//arr = null; //改变数组的引用，不合法3) final 方法
final 方法不能重写，如Object类中的getClass()方法。Final修饰的方法可以被重载。
4) final类
final类不能有子类
5) 不可变类
不可变类指的是创建该类的实例后，实例的field不可改变的类。Java中的包装类和String类都是不可变类。
class Person {
privatefinal String name; //使用finalprivate 修饰实例field
privatefinal Address address;
publicPerson() { name = ""; address = null; }
publicPerson(String name, Address add) {
this.name= name;
//如果不可变类的field是一个可变类的对象时，不能直接将可变类对象赋值给address，需要创建一个新对象
this.address= new Address(add.getCity(), add.getCountry());
}
//对外只提供field的getter方法
publicString getName() {
returnname;
}
publicAddress getAddress() {
//返回一个临时新对象
returnnew Address(address.getCity(), address.getCountry());;
}
}
//普通可变类
class Address {
privateString city;
privateString country;
publicString getCity() {
returncity;
}
publicvoid setCity(String city) {
this.city= city;
}
publicString getCountry() {
returncountry;
}
publicvoid setCountry(String country) {
this.country= country;
}
publicAddress(String city, String country){
this.city= city;
this.country= country;
}
}4. String类
1)判断
- boolean equals(Object); 判断传入的字符串是否与调用的字符串字符序列是否相同,相同就返回 true否则false
- boolean equalsIgnoreCase(string); 判断传入的字符串是否与调用的字符串字符序列是否相同,不区分大小 写,相同就返回true否则false
- boolean contains(string); 判断传入的字符串是否被调用的字符串包含
- boolean startsWith(string); 判断调用的字符串是否以传入的字符串开头
- boolean endsWith(string); 判断调用的字符串是否以传入的字符串结尾
- boolean isEmpty(); 判断字符串是否为空
2)获取
- int length(); 获取字符串的长度
- char charAt(index); 通过索引获取对应的字符
- int indexOf(int ch); 通过传入int数或者是字符找对应索引
- intidnexOf(int ch,fromIndex); 在指定fromIndex的位置查找传入的字符
- int indexOf(string str); 通过传入字符串查找字符串所对应的索引
- IdnexOf(string str,fromIndex); 通过指定fromIndex的位置查找传入的字符串
- int lastIndexOf(ch); 通过传入的字符从后向前找字符的索引值,把从后向前第一次找到的索 引值返回
- intlastIndexOf(ch,fromIndex): 通过指定fromIndex的位置,从后向前查找字符,把从后向前第一次找到的 索引值返回
- int lastIndexOf(string); 通过传入的字符串,从后向前查找,将第一次找到字符串中第一个字符的 索引返回
- intlastIndexOf(string,fromIndex): 通过指定fromIndex的位置,从后向前查找对应字符串,将第一次找到字符 串中第一个字符的索引返回
- Stringsubstring(start); 通过传入的索引值开始向后截取,截取的是索引到length
- Stringsubstring(start,end); 通过传入的两个索引值截取,有开始有结尾,包含头不包含尾
3) 转换
- byte[] getBytes(); 编码,让计算机看的懂的,用默认的编码表,将字符串转换成字节数组
- byte[]getBytes(String) 用指定的编码表进行编码
- char[] toCharArray(); 将字符串转换成字符数组
- static String copyValueOf(char[]); 将字符数组转换成字符串
- static String copyValueOf(char[] data, int offset, int count);将字符数组转换字符串,通过offset开始,截取count个
- static String valueOf(char[]); 将字符数组转换成字符串
- static String valueOf(char[] data, int offset, int count);将字符数组转换字符串,通过offset开始,截取count个
- static String valueOf(int); 将一个int数转换成字符串
- staticString valueOf(double);
- staticString valueOf(boolean);
- static String valueOf(object); 和object.toString():结果是一样的。
- String toLowerCase(): 将字符串全部转换为小写
- StringtoUpperCase(): 将字符串全班转换为大写
- "abc".concat("kk"); 将两个字符串相连接,产生新的字符串
4) 替换。
- String replace(oldChar,newChar); 将newChar替换OldChar,如果OldChar不存在,原字符串直接赋值给替换 后字符串
- String replace(string,string);
5) 切割。
- String[] split(regex); 通过regex切割字符串,切割后会产生一个字符串数组
- String s = "rgfdgfdgfg fg fgf";
- String[] arr = s.split(" ");
6) 去除字符串两空格。
- String trim();
7) 比较
- String str = "ab";
- String str1 = "bc";
- int num = str.compareTo(str1); 如果str比str1大的话,返回的正数
5. 正则表达式：
- [abc] a b c----单个字符
- [^abc] 除了a b c 其他字符都可以 -----单个字符
- [a-zA-Z] 小写字母a-z和大写字母A-Z都可以-----单个字符
- [a-dp-m] a-d或者m-p 并集的关系 -------单个字符
- [a-z&&[def]] d、e 或 f（交集）-------单个字符
- [[a-z]&&[^b-e]] a-z里面除了b到e之外所有的 ------单个字符
1） 预定义字符类：
- \\d相当于[0-9]的范围 -----单个字符
- \\D相当于[^0-9] 除了0-9的字符都可以 -----单个字符
- \\s相当于[\t\n\r] 空白字符都可以(换行、制表符、空格) ------单个字符
- \\S相当于[^\t\n\r] 除了空白字符都可以(换行、制表符、空格) ------单个字符
- \\w 相当于[a-zA-Z_0-9] 大写字母和小写字母 _所有数字 -------单个字符
- \\W 相当于[^\\w] 除了大写字母和小写字母_所有数字以外都可以 ---单个字符
2）数量词：
- [abc]? 一次或一次也没有
- [abc]* 零次或多次
- [abc]+ 一次或多次
- [abc]{5} 正好几次
- [abc]{5,} 至少几次
- [abc]{5,7} 至少几次、最多几次
3）去重复字符：
- (a.replaceAll("(.)\\1+","$1"));组中出现的多个字符 一个组中的字符
- String a = "开开开玩玩笑呢吧？";
- System.out.println(a.replaceAll("(.)\\1+","$1"));
4）获取匹配值：
- Pattern.compile() 创建正则表达式对象
- Pattern.matcher() 用正则表达式匹配一个字符串,得到匹配器
- Matcher.find() 查找字符串中是否包含能匹配正则表达式的部分
- Matcher.group() 获取匹配的部分
Pattern p =Pattern.compile("1[34578]\\d{9}"); //创建正则表达式对象
Matcher m = p.matcher(message); //获取匹配器
while (m.find()){ //通过正则寻找 find
System.out.println(m.group()); //打印找到的匹配项group
}6. StringBuffer
1）添加
StringBuffer append(int x); //在缓冲区的末尾追加
StringBuffer insert(int index,Stringstr); //在指定索引位置添加
2）删除
StringBuffer delete(int start, intend); //包含头索引,不包含尾部索引
StringBuffer delete(0,sb.length); //清空缓冲区
ew StringBuffer();
sb.append("aaaaa");
sb = new StringBuffer();
StringBuffer deleteCharAt(int index); //根据指定的索引删除索引对应的元素
3）修改
- StringBuffer replace(int start,int end,string);/用String替换,包含头不包含尾
- voidsetCharAt(int index ,char); //修改,把指定索引位置的值改成传入的char值
- StringBuffer reverse(); //将缓冲区的元素反转
- voidsetLength(int len); //根据传入的len值截取缓冲区的长度
- toString() //转换成String
4）查找
- tindexOf(str); //查找str在缓冲区第一次出现的位置
- int lastIndexOf(str); //从后向前查找查找str在缓冲区第一次出现的位置
5）StringBuilder和StringBuffer与String的区别
- StringBuilder和StringBuffeer是可变字符序列
- String是不变得,一但被初始化,就不能改变
6）StringBuilder和StringBuffer的区别
- StringBuilder是线程不安全的,所以效率比较高,1.5版本出现
- StringBuffer是线程安全的,效率相对较低,1.0版本出现的
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
