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后相加
引用类型:属性名.hashCide ()
相加
类库中的引用类型:该方法已经提供过重写,所以直接调用方法即可
自定义的引用类型:需要先将自定义类型的该方法重写,在进行调用
- 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也进行重写,然后调用
- 比较属性值:
1. 基本类型: ==直接比较
2. 引用类型:
- 类库中的引用类型: 对equals已经提供过重写,所以可以直接调用
- 自定义的引用类型: 对自定义类型中的equals也进行重写,然后调用
~~~java
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); 报错
### 整数缓冲区
官方认定-129—127是最常用的256个数字,为了减少包装类型使用反复数字带来的空间浪费,所以在方法区中设立了整数缓冲区,用来存放这256个数字,当包装类型使用的数字在此范围内,则直接引用缓冲区地址,不再额外开辟对象空间,以此达到节省空间的目的
>==比较引用类型地址时,优先使用堆中的对象地址
~~~java
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引用名.方法名(实参列表)`
1. **char charAt(下标): 获取指定下标位置的字符**
2. **boolean contains(字符串): 判断当前字符串中是否包含指定内容**
3. boolean endsWith(字符串): 判断字符串是否以指定内容结尾
4. boolean startsWith(字符串): 判断字符串是否以指定内容开头
5. **boolean equals(字符串): 判断与指定字符串内容是否相同, 区分大小写**
6. boolean equalsIgnoreCase(字符串): 判断与指定字符串内容是否相同, 不区分大小写
7. byte[] getBytes(): 以byte数组的形式返回字符串内容
8. char[] toCharArray(): 以char数组的形式返回字符串内容
9. **下标 indexOf(字符串): 获取指定字符串第一次出现的下标, 不存在返回-1**
10. 下标 lastIndexOf(字符串): 获取指定字符串最后一次出现的下标, 不存在返回-1
11. boolean isEmpty(): 判断字符串内容是否为空,无法判比null值
12. **int length(): 获取字符串长度**
13. 新字符串 replace(旧字符串,新字符串): 将符合条件的旧字符串替换为新字符串内容
14. **String[] split(分隔符): 对字符串根据分隔符进行分割, 不保留分隔符**
15. **新字符串 substring(下标): 将原字符串从指定下标位置截取至末尾**
16. **新字符串 substring(起始下标,结束下标): 将原字符串从起始下标截取至结束下标前一位**
17. 新字符串 toLowerCase(): 转全小写
18. 新新字符串 toUpperCase(): 转全大写
19. 新字符串 trim(): 去除前后空格
~~~java
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的重点常用方法