常用类
Object
- 最大父类,也称为祖宗类. 所有类都直接或间接的继承自Object
常用方法
-
Class getClass() : 获取引用的实际对象类型
Animal a1 = new Dog(); Animal a2 = new Cat(); Dog dog = new Dog(); //获取实际对象类型 System.out.println(a1.getClass());//com.by.entity.Dog System.out.println(a2.getClass());//com.by.entity.Cat //判断a1和a2是否相同 System.out.println(a1.getClass() == a2.getClass());//f System.out.println(a1.getClass() == dog.getClass());//t -
int hashCode() : 获取当前对象的哈希码值
- 重写原因: 该方法默认关注对象地址,地址不同则哈希码值不同. 但是开发过程中某些情况下我们需要关注的是对象内容,内容一致则哈希码值必定一致,所以需要对其重写
- 重写规则:
- 整型: 直接相加
- 小数类型: 强转int后相加
- 引用类型:
属性名.hashCode()相加- 类库中的引用类型: 该方法已经提供过重写,所以直接调用方法即可
- 自定义的引用类型: 需要先将自定义类型的该方法重写,再进行调用
-
boolean equals(Object o): 判断当前对象与参数对象是否相同
-
重写原因: 该方法默认比较对象地址,但是在开发过程中,某些情况下需要比较双方内容,所以需要提供重写
-
重写规则:
public boolean equals(Object o) { //自反性 if (this == o) { return true;//自己和自己比,一定相同 } //非空判断 和 类型比较 if (o == null || this.getClass()!=o.getClass()) { return false;//与null值比或者实际对象类型不一致,一定不同 } //类型强转 当前类名 引用名 = (当前类名) o; //比较属性值 return 让当前对象的属性与引用名的属性进行比较,多个属性值之间的比较&&连接; }- 比较属性值:
- 基本类型: ==直接比较
- 引用类型:
- 类库中的引用类型: 对equals已经提供过重写,所以可以直接调用
- 自定义的引用类型: 对自定义类型中的equals也进行重写,然后调用
package com.by.entity; public class Student { private String name; private int age; private double score; private Teacher tea; @Override public int hashCode() { return age+(int)score+name.hashCode()+ tea.hashCode(); } public boolean equals(Object o) {//Object o=new Student(); //自反性 if (this == o) { return true;//自己和自己比,一定相同 } //非空判断 和 类型比较 if (o == null || this.getClass()!=o.getClass()) { return false;//与null值比或者实际对象类型不一致,一定不同 } //类型强转 Student s = (Student) o; //比较属性值 return this.age==s.age && this.score==s.score && this.name.equals(s.name) && this.tea.equals(s.tea); } //省略getter\setter\构造 }package com.by.entity; public class Teacher { private String name; public int hashCode(){ return name.hashCode(); } public boolean equals(Object o) { //自反性 if (this == o) { return true; } //非空判断+类型比较 if (o == null || this.getClass() != o.getClass()) { return false; } //类型强转 Teacher t = (Teacher) o; //属性值比较 return this.name.equals(t.name); } //省略getter\setter\构造 } - 比较属性值:
-
-
String toString() : 用来返回当前对象的信息
- 重写原因: 该方法默认获取对象地址返回,但是实际开发中,通常查看的是对象的内容,所以需要重写
- 重写规则: 根据查看需求拼接属性值返回即可
- 使用:
- 在直接查看引用时可以自动调用
-
void finalize() : 用来进行垃圾回收
- 垃圾回收机制: 当内存满到不足以支撑新对象的创建时,虚拟机会调用垃圾对象的该方法对其进行回收销毁,以此来释放空间
- 垃圾对象判断标准: 没有任何引用指向的对象 (零引用机制)
- 手动垃圾回收: 可以借助垃圾回收期GC,通过在代码中书写
System.gc()来实现手动的垃圾回收
包装类
- 作用为将八大基本类型包装为引用类型
| byte | short | int | long | float | double | char | boolean |
|---|---|---|---|---|---|---|---|
| Byte | Short | Integer | Long | Float | Double | Character | Boolean |
基本类型与包装类型
基转包
-
利用构造
包装类型 引用名=new 包装类名(基本类型); -
利用valueOf
包装类型 引用名=包装类名.valueOf(基本类型);
包转基
-
利用xxxValue
基本类型 变量名=包装类型引用名.xxxValue(); 注:xxx对应的是基本类型名
自动转换
- JDK5.0之后,为了方便操作,提供了自动封箱与拆箱,使得基本类型与包装类型之间可以自动转换
- 封箱: 基本类型转包装类型
- 拆箱: 包装类型转基本类型
int a1=10;
//1.构造
Integer i1 = new Integer(a1);
//2. valueOf
Integer i2 = Integer.valueOf(a1);
//包转基
int a2 = i2.intValue();
//自动转换
Integer i3 = a1;
int a3 = i3;
基本类型与String
基转String
-
字符串拼接
String 引用名=基本类型+""; String 引用名=""+基本类型; -
利用valueOf
String 引用名=String.valueOf(基本类型);
String转基
-
利用parseXxx方法
基本类型 变量名=对应的包装类名.parseXxx(String类型); 注:Xxx对应的是基本类型名,首字母大写
必须包装String中的数据是基本类型能够盛放的数据,否则执行时会触发NumberFormatException数据类型转换异常
int a1 = 100;
//字符串拼接
String s1 = a1 + "abc";
String s2 = "" + a1;
String s3=String.valueOf(a1);
//String转基
int a2 = Integer.parseInt(s2);
// int a3 = Integer.parseInt(s1);//100abc 报错
包装类型与String
包转String
-
字符串拼接
String 引用名=包装类型+""; String 引用名=""+包装类型; -
利用toString
String 引用名=包装类型引用名.toString();
String转包
与基转包一致
必须保证String的值为包装类型能够盛放的值
Integer i1 = 100;
//字符串拼接
String s1 = i1 + "qwe";
String s2 = "" + i1;
//toString
String s3 = i1.toString();
//String转包
Integer i2 = new Integer(s2);
Integer i3 = Integer.valueOf(s3);
// Integer i4 = new Integer(s1); 报错
整数缓冲区
官方认定-128至127是最常用的256个数字，为了减少包装类型使用反复数字带来的空间浪费，所以在方法区中设立了整数缓冲区，用来存放这256个数字，当包装类型使用的数字在此范围内，则直接引用缓冲区地址，不再额外开辟对象空间，以此达到节省空间的目的
==比较引用类型地址时，优先使用堆中的对象地址
Integer i1 = 200;
Integer i2 = 200;
System.out.println(i1 == i2);//f
Integer i3 = 100;
Integer i4 = 100;
System.out.println(i3 == i4);//t
Integer i5 = new Integer(100);
Integer i6 = new Integer(100);
System.out.println(i5 == i6);//f
System.out.println(i3 == i5);//f
String
- 特点: 是一个内存中常量, 在内存中值一旦确定则不可更改
String s1 = "abc";
String s2 = s1;
s2 = "edf";
System.out.println("s1: "+s1);//abc
System.out.println("s2: "+s2);//edf
创建
-
双引号直接赋值
String 引用名="值"; -
利用构造
String 引用名=new String("值");
串池:
全程字符串常量池, 由于String是实际开发中使用频率最高的数据类型,且开发过程中对一个字符串的复用率远远高于对其的更改频率, 为了减少字符串重复使用带来的空间浪费,所以在方法区中设立了串池,保证相同字符串内容只会占用一块串池空间,以此来减少空间浪费,节约空间资源.
区别
- 第一种创建方式: 当创建时,会先去串池中寻找对应字符串内容,如果存在,则引用直接指向,如果不存在, 则先在串池中创建对应字符串内容然后引用指向
- 第二种创建方式: 无论如何都会开辟对象空间. 如果串池中存在对应内容,则对象空间直接存放对应串池地址,如果串池中不存在对应内容,则先在串池中创建,再让对象空间存放对应串池地址
String s1 = "abc";
String s2 = "abc";
String s3 = new String("edf");
String s4 = new String("edf");
System.out.println(s1 == s2);//t
System.out.println(s3 == s4);//f
String s5 = new String("abc");
System.out.println(s1 == s5);//f
可变长字符串
- StringBuffer: JDK1.0 线程安全,效率低
- StringBuilder: JDK5.0 线程不安全,效率高
特点
- 必须通过构造创建
- 无法使用串池
- 内容操作必须调用对应方法实现
//拼接26个大写字母并输出
StringBuilder sb = new StringBuilder();
for (char c = 'A'; c <= 'Z'; c++) {
//将当前遍历内容追加至可变长字符串末尾
sb.append(c);
}
System.out.println(sb);
//将可变长字符串转变为String类型
String s = sb.toString();
由于字符串的复用率高于更改频率,所以使用更简单且能用串池的String应用场景要远远多于可变长字符串
常用方法
String引用名.方法名(实参列表)
- char charAt(下标): 获取指定下标位置的字符
- boolean contains(字符串): 判断当前字符串中是否包含指定内容
- boolean endsWith(字符串): 判断字符串是否以指定内容结尾
- boolean startsWith(字符串): 判断字符串是否以指定内容开头
- boolean equals(字符串): 判断与指定字符串内容是否相同, 区分大小写
- boolean equalsIgnoreCase(字符串): 判断与指定字符串内容是否相同, 不区分大小写
- byte[] getBytes(): 以byte数组的形式返回字符串内容
- char[] toCharArray(): 以char数组的形式返回字符串内容
- 下标 indexOf(字符串): 获取指定字符串第一次出现的下标, 不存在返回-1
- 下标 lastIndexOf(字符串): 获取指定字符串最后一次出现的下标, 不存在返回-1
- boolean isEmpty(): 判断字符串内容是否为空,无法判比null值
- int length(): 获取字符串长度
- 新字符串 replace(旧字符串,新字符串): 将符合条件的旧字符串替换为新字符串内容
- String[] split(分隔符): 对字符串根据分隔符进行分割, 不保留分隔符
- 新字符串 substring(下标): 将原字符串从指定下标位置截取至末尾
- 新字符串 substring(起始下标,结束下标): 将原字符串从起始下标截取至结束下标前一位
- 新字符串 toLowerCase(): 转全小写
- 新新字符串 toUpperCase(): 转全大写
- 新字符串 trim(): 去除前后空格
package com.by.test.string;
public class Test4 {
public static void main(String[] args) {
String s = "hello";
//char charAt(下标): 获取指定下标位置的字符
System.out.println(s.charAt(2));//l
//boolean contains(字符串): 判断当前字符串中是否包含指定内容
System.out.println(s.contains("el"));//t
System.out.println(s.contains("eo"));//f
//boolean endsWith(字符串): 判断字符串是否以指定内容结尾
System.out.println(s.endsWith("o"));//t
System.out.println(s.endsWith("hello"));//t
//boolean startsWith(字符串): 判断字符串是否以指定内容开头
System.out.println(s.startsWith("h"));//t
//boolean equals(字符串): 判断与指定字符串内容是否相同, 区分大小写
System.out.println(s.equals("hello"));//t
System.out.println(s.equals("HeLLo"));//f
//boolean equalsIgnoreCase(字符串): 判断与指定字符串内容是否相同, 不区分大小写
System.out.println(s.equalsIgnoreCase("HELLO"));//t
//byte[] getBytes(): 以byte数组的形式返回字符内容
byte[] bs = s.getBytes();
for (int i = 0; i < bs.length; i++) {
System.out.print((char) bs[i]+" ");
}
System.out.println();
//char[] toCharArray(): 以char数组的形式返回字符串内容
char[] cs = s.toCharArray();
for (int i = 0; i < cs.length; i++) {
System.out.print(cs[i]+" ");
}
System.out.println();
//下标 indexOf(字符串): 获取指定字符串第一次出现的下标, 不存在返回-1
System.out.println(s.indexOf("l"));//2
//下标 lastIndexOf(字符串): 获取指定字符串最后一次出现的下标, 不存在返回-1
System.out.println(s.lastIndexOf("l"));//3
//boolean isEmpty(): 判断字符串内容是否为空,无法判比null值
System.out.println(s.isEmpty());//f
String s2 = "";
System.out.println(s2.isEmpty());//t
String s3 = " ";
System.out.println(s3.isEmpty());//f
String s4 = null;
//System.out.println(s4.isEmpty()); 空指针
//int length(): 获取字符串长度
System.out.println(s.length());//5
//新字符串 replace(旧字符串,新字符串): 将符合条件的旧字符串替换为新字符串内容
System.out.println(s.replace("l", "m"));//hemml
//String[] split(分隔符): 对字符串根据分隔符进行分割, 不保留分隔符
String str = "2000-01-01";
//通过-进行分割
String[] ss = str.split("-");//[2000 01 01]
for (int i = 0; i < ss.length; i++) {
System.out.print(ss[i]+" ");
}
System.out.println();
//直接分割
String[] ss2 = str.split("");
for (int i = 0; i < ss2.length; i++) {
System.out.print(ss2[i]+" ");
}
System.out.println();
//新字符串 substring(下标): 将原字符串从指定下标位置截取至末尾
String s5 = "abcdefg";
System.out.println(s5.substring(3));//edfg
//新字符串 substring(起始下标,结束下标): 将原字符串从起始下标截取至结束下标前一位
System.out.println(s5.substring(1, 6));//bcdef
//新字符串 toLowerCase(): 转全小写
String s6 = "ABCD";
System.out.println(s6.toLowerCase());//abcd
//新新字符串 toUpperCase(): 转全大写
System.out.println(s5.toUpperCase());//ABCDEFG
//新字符串 trim(): 去除前后空格
String s7 = " a b c ";
System.out.println(s7.trim());//a b c
}
}
今日掌握
- getClass方法和instanceof的区别
- equals方法的重写规则
- 自动封箱和拆箱的概念
- String转基本类型的写法
- 串池的概念
- String的两种创建方式及区别
- String的重点常用方法
348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
