常用类
目录
常用类
Object类
- 超类、基类，所有类的直接或间接父类，位于继承树的最顶层
- 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
- Object类中所定义的方法，是所有对象都具备的方法
- Object类型可以储存任何对象
- 作为参数，可接受任何对象
- 作为返回值，可返回任何对象
getClass()方法
- public final Class<?> getClass(){}
- 返回引用中存储的实际对象类型
- 应用：通常用于判断两个引用 中实际储存对象类型是否一致
package usedClass; public class Application1 { public static void main(String[] args) { Student s1=new Student(23,小明); Student s2=new Student(18,小红); Class c1=s1.getClass(); Class c2=s2.getClass(); if(c1==c2){ System.out.println(属于同一个类); }else{ System.out.println(不属于同一个类); } } } 输出结果：
属于同一个类
hashCode方法
- public int hashCode(){}
- 返回该对象的哈希码值
- 哈希值根据对象的地址 或 字符串 或 数字使用hash算法计算出的int类型的数值
- 一般情况下相同对象返回相同哈希码
toString()方法
- public String toString(){}
- 返回该对象的字符串表示（表现形式）
- 可以根据程序需求覆盖该方法，如：展示对象各个属性值
equals()方法
- public boolean equals(){}
- 默认实现为（this == obj），比较两个对象的地址是否相同
- 可进行覆盖，比较两个对象的内容是否相同
finalize()方法
- 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
- 垃圾对象：没有有效引用指向此对象时，为垃圾对象
- 垃圾回收：由GC销毁垃圾对象，释放数据存储空间
- 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
- 手动回收机制：使用System.gc(); 通知JVM执行垃圾回收
package usedClass; public class Student { private int age; private String name; public Student() { } public Student(int age, String name) { this.age = age; this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override protected void finalize() throws Throwable { System.out.println(name+被回收了); } } package usedClass; public class Application2 { public static void main(String[] args) { Student s1=new Student(26,小红); new Student(21,小明); System.gc(); System.out.println(通知jvm回收了); } } 输出结果：
小明被回收了
通知jvm回收了
包装类
什么是包装类？
- 基本数据类型所对应的引用数据类型
- Object可统一所有数据，包装类的默认值是null
| 基本数据类型 | 包装类型 |
|---|---|
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
| char | Character |
类型转换与装箱、拆箱
- 8种包装类提供不同类型间的转换方式
- Number父类中提供的6个共性方法
- parseXXX()静态方法
- valueOf()静态方法
- 注意：需保证类型兼容，否则抛出NumberFormatException异常
整数缓冲区
- Java预先创建了256个常用的整数包装类型对象
- 在实际应用中，对已创建的对象进行复用
package usedClass; public class Application3 { public static void main(String[] args) { //装箱 int age=12; Integer integer=new Integer(age); Integer integer2=Integer.valueOf(age); //拆箱 Integer integer3=new Integer(25); int num=integer3.intValue(); /* jdk1.5之后可自动拆装箱，实际上还是调用以上方法进行操作 */ //自动装箱, 等同于Integer integer4=Integer.valueOf(num2); int num2=55; Integer integer4=num2; //自动拆箱，等同于int num3=integer4.intValue(); int num3=integer4; //字符串类型与基本类型的转换 //基本类型准换成字符串类型 System.out.println(--------------------------------字符串类型与基本类型的转换----------------------------------); int num4=669; String str1=Integer.toString(num4); String str2=num4+; //字符串类型转换成基本类型 int num5=Integer.parseInt(str2); //boolean类型字符串形式转换成基本类型,非true字符串都将转换成false String str3=true; String str4=jdahjdh; String str5=false; boolean b1=Boolean.parseBoolean(str3); boolean b2=Boolean.parseBoolean(str4); boolean b3=Boolean.parseBoolean(str5); System.out.println(b1); System.out.println(b2); System.out.println(b3); /* 整数缓冲区,范围为 -128 至 127 */ System.out.println(--------------------------------整数缓冲区------------------------------------------); Integer k1=new Integer(100); Integer k2=new Integer(100); System.out.println(k1==k2); Integer k3=100; Integer k4=100; System.out.println(k3==k4); Integer k5=128; Integer k6=128; System.out.println(k5==k6); } } 输出结果：
--------------------------------字符串类型与基本类型的转换-----------------
true
false
false
--------------------------------整数缓冲区------------------------------------------
false
true
false
String类
字符串池
- 字符串是常量，创建之后不可改变
- 字符串字面值存储在字符串池中，可以共享
- String s= Hello; 产生一个对象，字符串池中存储
- String s=new String(Hello); 产生两个对象，堆、池中各存储一个
package usedClass; public class Application { public static void main(String[] args) { String str1=张三; //在方法区中字符串池中存储“张三” str1=李四; //发现字符串池中没有，即新建空间存储“李四”， 将str1指向“李四”字符串，原来的“张三”字符 串不会被修改，依然存在字符串池中 String str2=李四; //字符串池中已经有了“李四”，则将str2指 向“李四”，不会再开辟新的空间 //1、字符串池中没有，新建空间存储“haha” //2、使用了new，也会在堆空间开辟空间存储“haha”,实际还是指向字符 串池中 String str3=new String(haha); /* 1、同样会去字符串池中查找，已经有了，就不会在字符串池中新增了 2、使用了new ,即会在堆空间中开辟空间，存储字符串“haha”,实际中是 开辟后的空间还是指向了字符串池中 */ String str4=new String(haha); System.out.println(str3==str4); System.out.println(str3.equals(str4)); } } 输出结果：
false
true
常用方法
- public int length() 返回字符串的长度
- public charAt(int index) 根据 下标 获取字符
- public boolean contains(String str) 判断当前字符串中是否包含str
- public char[] toCharArray() 将字符串转换成数组
- public int indexOf(String str) 查找str首次出现的下标。存在，则返回下标，不存在则返回-1
- public int lastIndexOf(String str) 查找str在字符串中最后一次出现的下标索引
- public String trim() 去掉字符串前后的空格
- public String toUpperCase() 将字符串转成大写
- public String toLowerCase() 将字符串转成大写
- public boolean endsWith(String str) 判断字符串是否以str结尾
- public boolean startsWith(String str) 判断字符串是否以str开头
- public String replace(char oldChar,char newChar) 将旧字符串替换成新字符串
- public String[] split(String str) 根据str做拆分
package usedClass; import java.util.Arrays; public class Application4 { public static void main(String[] args) { //此字符串既有空格，又有，怎么拆分？ String str=Java is the best programmer,language; String[] strs=str.split([ ,]+); //System.out.println(Arrays.toString(strs)); for (String s : strs) { System.out.println(s); } //补充两个方法，equals,compareTo:比较两个字符串的大小，返回差值 System.out.println(---------------补充---------------); String s1=hello; String s2=HELLO; System.out.println(s1.equals(s2)); System.out.println(s1.equalsIgnoreCase(s2)); String str2=abc; String str3=efg; //如果第一个字符不相同，则返回第一个字符在编码表的差额，如果否，则判断第二个字符的差额，依次类推 System.out.println(str2.compareTo(str3)); //判断h与j在编码表中的差额 String str4=abch; String str5=abcjk; System.out.println(str4.compareTo(str5)); //此种情况，str6与str7前部分重合，str7比str6长，则返回字符串长度的差额 String str6=abc; String str7=abcjkfds; System.out.println(str6.compareTo(str7)); } } 输出结果：
Java
is
the
best
programmer
language
---------------补充---------------
false
true
-4
-2
-5
可变字符串
- StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全
- StringBuilder：可变长字符串，JDK5.0提供，运行效率快，线程不安全
- 和String区别：1、比String效率高；2、比String节省内存
四个常用方法
- append();追加
- insert();添加，指定添加位置处
- replace();替换
- delete();删除
package usedClass; public class Demo01 { public static void main(String[] args) { StringBuffer str1=new StringBuffer(start); System.out.println(str1); //1、append()追加 str1.append(123); str1.append(hello); System.out.println(追加后的字符串：+str1); //2、insert()添加 str1.insert(0,java); System.out.println(添加后的字符串+str1); //3、replace()替换 str1.replace(0,4,PHP); System.out.println(替换后的字符串+str1); //4、delete()删除 str1.delete(0,3); System.out.println(删除后的字符串+str1); //5、清空 str1.delete(0, str1.length()); System.out.println(str1.length()); System.out.println(---------效率测试---------); long start=System.currentTimeMillis(); String str2=; for (int i = 0; i < 99999; i++) { str2+=i; } long end=System.currentTimeMillis(); System.out.println(String耗时：+(end-start)); long start1=System.currentTimeMillis(); StringBuffer str3=new StringBuffer(); for (int i = 0; i < 99999; i++) { str3.append(i); } long end1=System.currentTimeMillis(); System.out.println(Stringbuffer耗时：+(end1-start1)); long start2=System.currentTimeMillis(); StringBuilder str4=new StringBuilder(); for (int i = 0; i < 99999; i++) { str4.append(i); } long end2=System.currentTimeMillis(); System.out.println(StringBuilder耗时：+(end2- start2)); } } 输出结果：
start
追加后的字符串：start123hello
添加后的字符串javastart123hello
替换后的字符串PHPstart123hello
删除后的字符串start123hello
0
---------------效率测试----------------
String耗时：25512
Stringbuffer耗时：2
StringBuilder耗时：1
BigDecimal
很多实际应用中需要精确运算，而double/float是近似值存储，不再符合要求，需要借助BigDecimal
- 位置：java.math包中；
- 作用：精确计算浮点数；
- 创建方式：BigDecimal bd=new BigDecimal(1.0);
- 方法：
- BigDecimal add(BigDecimal bd) +
- BigDecimal subtract(BigDecimal bd) -
- BigDecimal multiply(BigDecimal bd) *
- BigDecimal divide(BigDecimal bd) /
- devide(BigDecimal bd,int scal,RoundingMode mode)
- 参数scla：指定精确到小数点后几位
- 参数mode：
- 指定小数部分的取舍模式，通常采用四舍五入的模式
- 取值为BigDecimal.ROUND_HALF_UP
package usedClass; public class Demo02 { public static void main(String[] args) { double a=1.0; double b=0.9; System.out.println(a-b); double result=(1.4-0.5)/0.9; System.out.println(result); } } 输出结果：
0.09999999999999998
0.9999999999999999
package usedClass; import java.math.BigDecimal; public class Demo03 { public static void main(String[] args) { //使用字符串的方式传参数，内部会自动进行一些运算转换，不要使用double的传参，不然还是不准确 //减法运算 BigDecimal bd1=new BigDecimal(1.0); BigDecimal bd2=new BigDecimal(0.9); BigDecimal r1=bd1.subtract(bd2); System.out.println(r1); //加法运算 BigDecimal r2=bd1.add(bd2); System.out.println(r2); //乘法运算 BigDecimal bd3=new BigDecimal(10); BigDecimal bd4=new BigDecimal(0.3); BigDecimal r3=bd3.multiply(bd4); System.out.println(r3); //除法运算,使用除法时需要注意，除不尽时会报错，需要指定保留几位小数以及小数位舍弃方式 //BigDecimal r4=bd3.divide(bd4); 此运算报错 //BigDecimal.ROUND_HALF_UP 是 BigDecimal的常量，表示四舍五入 BigDecimal r4=bd3.divide(bd4,2,BigDecimal.ROUND_HALF_UP); System.out.println(r4); } } 输出结果：
0.1
1.9
3.0
33.33
Date
- Date表示特定的瞬间，精确到毫秒。
- JDK1.1之后Date 类中的大部分方法都已经被Calendar类中的方法所取代
- 时间单位
- 1秒=1000毫秒
- 1毫秒=1000微秒
- 1微秒=1000纳秒
package usedClass; import java.util.Date; public class Demo04 { public static void main(String[] args) { //今天 Date date1=new Date(); System.out.println(date1); System.out.println(今天:+date1.toLocaleString()); //昨天 getTime() 获取毫秒表示对应的时间点 Date date2=new Date(date1.getTime()-1000*60*60*24); System.out.println(昨天:+date2.toLocaleString()); //2、方法after before System.out.println(-----------方法after before--------); boolean b1=date2.before(date1); boolean b2=date1.after(date2); System.out.println(date2 before date 1:+b1); System.out.println(date1 after date2:+b2); //3、比较大小compareTo(); System.out.println(---------比较大小compareTo()---------); int d1=date1.compareTo(date2); int d2=date2.compareTo(date1); int d3=date1.compareTo(date1); System.out.println(date1比较date2:+d1); System.out.println(date2比较date1：+d2); System.out.println(date1比较date1：+d3); //4、比较是否相等 System.out.println(----------比较是否相等-------------); boolean b3=date1.equals(date2); System.out.println(b3); } } 输出结果：
Tue May 03 19:11:45 CST 2022
今天:2022-5-3 19:11:45
昨天:2022-5-2 19:11:45
-----------方法after before--------
date2 before date 1:true
date1 after date2:true
---------比较大小compareTo()---------
date1比较date2:1
date2比较date1：-1
date1比较date1：0
----------比较是否相等-------------
false
Calendar
- Calendar提供了获取或设置各种日历字段的方法
- 构造方法
- protected Calendar()：由于修饰符是protected，所以无法直接创建该对象
- 其他方法
package usedClass; import java.util.Calendar; public class Demo05 { public static void main(String[] args) { //1、创建Calendar对象,因为protected 修饰的构造方法，不能new Calendar c1=Calendar.getInstance(); //System.out.println(c1); System.out.println(c1.getTime().toLocaleString()); //2、获取时间信息 //获取年、月、日、小时、分、秒 int year=c1.get(Calendar.YEAR); int month=c1.get(Calendar.MONTH); //从0开始 int day = c1.get(Calendar.DAY_OF_MONTH); //Date int hour=c1.get(Calendar.HOUR_OF_DAY); //Hour：12小时 ，HOUR_OF_DAY：24小时 int minute =c1.get(Calendar.MINUTE); int second=c1.get(Calendar.SECOND); System.out.println(当前时间:+year+年+(month+1)+月+day+日+hour+:+minute+:+second); //3、修改时间 Calendar c2=Calendar.getInstance(); c2.set(Calendar.MONTH,1); System.out.println(设置月份1修改后的时间：+c2.getTime().toLocaleString()); //4、add()修改时间 Calendar c3=Calendar.getInstance(); c3.add(Calendar.DAY_OF_MONTH,-1); System.out.println(当前时间减1天后的时间：+c3.getTime().toLocaleString()); //5、补充方法,获取当前时间月份的最大天数，最小天数 Calendar c4=Calendar.getInstance(); int max=c4.getActualMaximum(Calendar.DAY_OF_MONTH); int min=c4.getActualMinimum(Calendar.DAY_OF_MONTH); System.out.println(本月的最大天数：+max); System.out.println(本月的最小天数：+min); } } 输出结果：
2022-5-3 19:46:16
当前时间:2022年5月3日19:46:16
设置月份1修改后的时间：2022-2-3 19:46:16
当前时间减1天后的时间：2022-5-2 19:46:16
本月的最大天数：31
本月的最小天数：1
SimpleDateFormat
-
SimpleDateFormat是一个以语言环境有关的方式来格式化和解析日期的具体类
-
进行格式化（日期 -> 文本）、解析（文本 -> 日期）
-
常用的时间模式字母
字母 日期或时间 示例 y 年 2019 M 年中月份 08 d 月中天数 10 H 1天中小时数（0-23） 22 m 分钟 16 s 秒 59 S 毫秒 367
package usedClass; import java.text.SimpleDateFormat; import java.util.Date; public class Demo06 { public static void main(String[] args) throws Exception { //1、创建SimpleDateFormat对象 SimpleDateFormat sdf=new SimpleDateFormat(yyyy年MM月dd日 hh:MM:ss); //2、创建时间 Date date=new Date(); System.out.println(date.toLocaleString()); //3、将时间转换成对应格式的字符串 String str=sdf.format(date); System.out.println(str); //4、将对应格式的字符串转换成Date SimpleDateFormat sdf2=new SimpleDateFormat(yyyyMMdd); Date date2=sdf2.parse(20190101); System.out.println(date2.toLocaleString()); } } 输出结果：
2022-5-3 20:25:15
2022年05月03日 08:05:15
2019-1-1 0:00:00
System类
System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的，不允许new ,因方法都是static修饰，即直接使用类名System调用即可；
| 方法名 | 说明 |
|---|---|
| static void arraycopy() | 复制数组 |
| static long currentTimeMillis() | 获取当前系统时间。返回的是毫秒值 |
| static void gc() | 建议JVM赶快启动垃圾回收器回收垃圾 |
| static void exit(int status) | 退出jvm,如果参数是0表示正常退出jvm,非0表示异常退出jvm |