Java常用类
day07所看的视频来源
千锋教育-新版 Java常用类最新教程
内部类
内部类的分类
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
什么是内部类
概念：在一个类的内部定义一个完整的类
class Outer{
class Inner{
}
}
特点：
- 编译之后可生成独立的字节码文件，文件格式是（Outer$Inner.class）
- 内部类可以直接访问还不累的私有成员，而不破坏封装
成员内部类
- 在类的内部定义，与实例变量，实例方法同级别的类
- 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象
- Outer out = new Outer();
- Outer.Inner in = out.new Inner();（IDEA写法）
- 当外部类、内部类存在重名的属性时，会优先访问内部类的属性，这种情况要访问相同名字的外部类属性名字，则Outer.this.属性名来访问
- 成员内部类不能定义静态成员，但是可以包含静态常量即static final
静态内部类
- 不依赖外部类对象，可以直接创建或通过类名访问，可声明静态成员（相当于外部类）
//Outer.java
public class Outer{
private String name = "XXX";
private int age = 28;
static class Inner{//级别和外部类一样
private String address = "上海";
private String phone = "111";
//静态成员
private static int cout = 1000;
public void show(){
//调用外部类的属性
//1.先创建外部类对象
Outer outer = new Outer();
//2.再调用外部类对象的属性
System.out.println(out.name);
System.out.println(out.age);
//调用静态内部的属性和方法，直接调用即可
System.out.println(address);
System.out.println(out.phone);
//调用静态内部类的静态属性
System.out.println(Inner.cout);
}
}
}
//Test.java
public class TestOuter{
public static void main(String[] args){
//直接创建静态内部类对象而不需要先new外部类
Outer.Inner inner = new Outer.Inner();//注意是new Outer.Inner()而不是new Outer().new.Inner()
}
}
- 只能直接访问外部类的静态成员（实例成员需实例化外部类对象）
- Outer.Inner inner = new Outer.Inner();
- Outer.Inner.show();（这里是不是有点问题？存疑）
局部内部类（实际开发使用场合不多）
- 定义在外部类的方法中，作用范围和创建对象方位仅限于当前方法
//Outer.java
public class Outer{
private String name = "刘德华";
private int age = 35;
public void show(){
//定义局部变量
String address = "深圳";//jdk1.8自动是final
//局部内部类，注意不能加任何访问修饰符
class Inner{
//局部内部类的属性
private String phone = "15588888888";
private String email = "[email protected]";
public void show2(){
//访问外部类的属性，可以直接访问，不可访问静态属性，因为静态属性是类的属性，不是成员的属性
System.out.println(name);//可以写成Outer.this.name
System.out.println(age);
//访问内部类的属性
System.out.println(phone);//可以写成this.phone
System.out.println(email);
//访问局部变量，jdk1.7要求，变量必须是常量final，jdk1.8自动添加final
System.out.println(address);//其实已经是常量，也就是“深圳”
}
}
//创建局部内部类对象然后调用才能输出结果
Inner inner = new Inner();
Inner.show2();
}
}
//Test.java
public class TestOuter{
public static void main(String[] args){
Outer outer = new Outer();
outer.show();//注意要在show里面创建局部内部类对象然后调用
}
}
- 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final
- 限制类的适用范围
匿名内部类
- 没有类名的局部内部类（一切特征与局部内部类相同）
- 必须继承一个父类或者实现一个接口
//Usb.java
//接口
public interface USB{
//服务
void service();
}
//Mouse.java
public class Mouse implements Usb{
@Override
public void Service(){
System.out.println("连接电脑成功，鼠标开始工作了...");
}
}
//Test.java
public class TestOuter{
public static void main(String[] args){
//创建接口类型的变量
Usb usb = new Mouse();
usb.service();
//局部内部类
class Fan implements Usb{
@Override
public void Service(){
System.out.println("连接电脑成功，风扇开始工作了...");
}
}
//使用局部内部类创建对象
Usb usb = new Fan();
usb.servise();
//使用匿名内部类优化（相当于创建了一个局部内部类）
Usb usb = new Usb(){
@Oberride
public void service(){
System.out.println("连接电脑成功，风扇开始工作了...");
}
};
usb.service();
}
}
- 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
- 优点：减少代码量
- 缺点：可读性较差
Object类
- 超类、基类，所有类的直接或间接父类，位于继承树的最顶层
- 任何类，如果没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承
- Object类中所定义的方法，是所有对象都具备的方法
- Object类型可以村粗任何对象
- 作为参数，可以接受任何对象
- 作为返回值，可以返回任何对象
getClass()方法
- public final Class getClass(){}
- 返回引用中存储的实际对象类型
- 应用：通常用于判断两个引用中实际存储对象类型是否一致
//Test.java
public class Test{
public static void main(String[] args){
Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb",22);
//判断s1和s2是不是同一类型
Class class1 = s1.getclass();
Class class2 = s2.getclass();
if(class1 == class2){
System.out.println("s1和s2属于同一类型");
}
}
}
hashCode()方法
- public int hashCode(){}
- 返回该对象的哈希码值
- 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
- 一般情况下相同对象返回相同哈希码
//Test.java
public class Test{
public static void main(String[] args){
Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb",22);
//判断s1和s2是不是同一类型
Class class1 = s1.getclass();
Class class2 = s2.getclass();
if(class1 == class2){
System.out.println("s1和s2属于同一类型");
}
//hashCode方法
System.out.println(s1.hashCode());//s1和s2的hashCode不一样
System.out.println(s2.hashCode());
Student s3 = s1;
System.out.println(s3.hashCode());//和s1一样
}
}
toString()方法
- public String toString(){}
- 返回该对象的字符串表示（表现形式）
- 可以根据程序需求覆盖该方法，如：展示对象各个属性值
//toString方法
//Test.java
public class Test{
public static void main(String[] args){
Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb",22);
System.out.println(s1.toString());
System.out.println(s2.toString());
//打印结果是com.(包名).Student@(哈希值)
}
}
equals()方法
- public boolean equals(Object obj){}
- 默认实现为(this == obj)，比较两个对象地址是否相同
- 可以进行覆盖，比较两个对象的内容是否相同
//Test.java
public class Test{
public static void main(String[] args){
Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb",22);
System.out.println(s1.equals(s2));//打印flase
Student s4 = new Student("小明",17);
Student s5 = new Student("小明",17);
System.out.println(s4.equals(s5));//打印flase，因为地址不同
}
}
//重写equals
//Student.java
public class Student extends Object{
private String name;
private int age;
@Override
public boolean equals(object obj){
//1.判断两个对象是否是同一个引用
if(this == obj){
return true;
}
//2.判断obj是否为null
if(obj == null){
return false;
}
//3.判断是否同一类型
if(obj instanceof Student){
//4.强制类型转换，因为instanceof判断的是是否是子类或同类，是就返回true，所有需要类型转换
Student s = (Student)obj;
//5.比较属性
if(this.name.equals(s.getName()) && this.age==s.getAge()){
return true;
}
}
}
}
finalize()方法
- 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
- 垃圾对象：没有有效引用指向此对象时，为垃圾对象
- 垃圾回收：由GC销毁垃圾对象，释放数据存储空间
- 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
- 手动回收机制：使用System.gc()；通知JVM执行垃圾回收
包装类
- 基本数据类型对应的引用数据类型
- Object可统一所有数据，包装类的默认值是null
包装类
类型转换与装箱、拆箱
装箱：把基本类型转换为引用类型（把栈里的基本数据类型放在堆里）
拆箱：把引用类型转换为基本类型
-
8种包装类提供不同类型的转换方式：
- Number父类中提供的6各共性方法
- valueOf()静态方阿飞
package com.changyonglei.demo03; public class Demo01 { public static void main(String[] args) { //类型转换：装箱，把基本类型转为引用类型的过程 //基本类型 int num1 = 18; //使用Interger类创建对象 Integer integer1 = new Integer(num1); Integer integer2 = Integer.valueOf(num1); //类型转换，拆箱，把引用类型转为基本类型 Integer integer3 = new Integer(100); int num2 = integer3.intValue(); //JDK1.5之后，提供自动装箱和拆箱 int age = 30; //自动装箱 Integer integer4 = age; //自动拆箱 int age2 = integer4; } }
- parseXXX()静态方法
package com.changyonglei.demo03;
public class Demo01 {
public static void main(String[] args) {
//把基本数据类型转换为字符串
int n1 = 15;
//1.使用+号
String s1 = n1+"";
//2.使用Integer中的toString()方法
String s2 = Integer.toString(n1,16);//输出f，十六进制
//字符串转换为基本类型
String str = "150";
//使用Integer.parseXXX();
int n2 = Integer.parseInt(str);
//boolean字符串形式转成基本类型，"true"--->true，非"true"--->false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);//是true
}
}
- 注意：需保证类型兼容，否则抛出NumberFormatException异常
整数缓冲区
- Java预先创建了256个常用的整数包装类型对象
先看代码
package com.changyonglei.demo03;
public class Demo02 {
public static void main(String[] args) {
//测试题
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1==integer2);//flase
Integer integer3 = 100;//自动装箱
Integer integer4 = 100;
System.out.println(integer3 == integer4);//true
Integer integer5 = 200;//自动装箱
Integer integer6 = 200;
System.out.println(integer5 == integer6);//false
}
}
- 在实际应用中，堆已创建的对象进行复用
堆里有一个Cache数组，从-128到127的对象都创建好了，所以100是true，200不在这个范围内，他就new了Integer
String类
String
- 字符串是常量，创建之后不可改变
- 字符串字面值存储在字符串池（字符串池在方法区中）中，可以共享
package com.changyonglei.demo04;
public class Demo01 {
public static void main(String[] args) {
String name = "hello";//"hello"常量存储在字符串池中
name = "zhangsan";//”张三“赋值给name，是在字符串池重新开辟一个空间，让name指向它
String name2 = "zhangsan";//找一下字符串池有没有zhangsan，有就name2指向它，和name指向同一个对象
}
}
- String s = "Hello";产生一个对象，字符串池中存储
- String s = new String("Hello");产生两个对象，堆、池各存储一个
String常用方法
- public in length()：返回字符串的长度
- public char charAt(int index)：根据下标获取字符
- public boolean contains(String str)：判断当前字符串是否包含str
//整体代码的一部分
String content = "Java是世界上最好的编程语言";
System.out.println(content.length());//15,空格也算一个字符
System.out.println(content.charAt(content.length()-1));//言
System.out.println(content.contains("Java"));//true
System.out.println(content.contains("php"));//false
- public char[] toCharArray()：将字符串转换成数组
- public int indexOf(String str)：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
- public int lastIndexOf(String str)：查找字符串在当前字符串中最后一次出现的下标索引
//代码的一部分
String content = "Java是世界上最好的编程语言";
System.out.println(Arrays.toString(content.toCharArray()));//[J, a, v, a, 是, 世, 界, 上, 最, 好, 的, 编, 程, 语, 言]
System.out.println(content.indexOf("Java"));//0
System.out.println(content.indexOf("Java",5));//从第5个下表开始找，实际上没有输出-1
System.out.println(content.lastIndexOf("Java"));//0
- public String trim()：去掉字符串前后的空格
- public String toUpperCase()：将小写转成大写。toLowerCase()：把大写转成小写
- public boolean endWith(String str)：判断字符串是否以str结尾
//代码的一部分
String content2 = " hello world ";
System.out.println(content2.trim());//hello world
System.out.println(content2.toUpperCase(Locale.ROOT));// HELLO WORLD
System.out.println(content2.toLowerCase(Locale.ROOT));// hello world
String filename = "hello.java";
System.out.println(filename.endsWith(".java"));//true
System.out.println(filename.startsWith("hello"));//true
}
- public String replace(char oldChar,char newChar)：将旧字符串替换成新字符串
- public String[] split(String str)：根据str做拆分
//代码的一部分
String content = "Java是世界上最好的编程语言";
System.out.println(content.replace("Java","php"));//php是世界上最好的编程语言
String say = "java is the best programing language,java xiang";
String[] arr = say.split("[ ,]");//用空格或者逗号拆分，写成[ ,]+，则空格或者逗号可以出现多个
System.out.println(arr.length);//8
for(String string : arr){
System.out.println(string);//一个个输出
- equals和compare
//代码的一部分
//补充两个方法equals,comnpare();比较大小
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写的比较，true
String s3 = "abc";//97
String s4 = "xyz";//120
System.out.println(s3.compareTo(s4));//比较首个不同字母的数值，-23
String s5 = "abc";
String s6 = "abcxyz";
System.out.println(s5.compareTo(s6));//这种情况比较长度，输出-3
可变字符串
- StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全
- StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全
//四个常用方法
package com.changyonglei.demo04;
/*
- StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全
- StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全
*/
public class Demo05 {
public static void main(String[] args) {
//StringBuffer sb = new StringBuffer();//两种写法都可以
StringBuilder sb = new StringBuilder();
//1.append();追加
sb.append("java世界第一");
System.out.println(sb.toString());//java世界第一
sb.append("java真香");
System.out.println(sb.toString());//java世界第一java真香
sb.append("java不错");
System.out.println(sb.toString());//java世界第一java真香java不错
//2.insert();添加
sb.insert(0,"我在最前面");
System.out.println(sb.toString());//我在最前面java世界第一java真香java不错
//3.replace();替换
sb.replace(0,5,"hello");//含头不含尾巴
System.out.println(sb.toString());//hellojava世界第一java真香java不错
//4.delete();删除
sb.delete(0,5);
System.out.println(sb.toString());//java世界第一java真香java不错
//清空
sb.delete(0,sb.length());
System.out.println(sb.length());//0
}
}
BigDecimal
- 位置：java.math包中
- 作用：精确计算浮点数
- 创建方法：BigDecimal bd=new BigDecimal("1.0");
- 方法：加减乘除如下代码
package com.changyonglei.demo04;
import com.oop.demo05.B;
import java.math.BigDecimal;
public class Demo07 {
public static void main(String[] args) {
//BigDecimal，大的浮点数精确计算
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//减法
BigDecimal r1 = bd1.subtract(bd2);
System.out.println(r1);//0.1
//加法
BigDecimal r2 = bd1.add(bd2);
System.out.println(r2);//1.9
//乘法
BigDecimal r3 = bd1.multiply(bd2);
System.out.println(r3);//0.90
//除法
BigDecimal r4 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"));
System.out.println(r4);//1
BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);//ROUND_HALF_UP四舍五入的意思，可以选择模式，2是保留小数的位数
System.out.println(r5);//3.33
}
}
Date类
- Date表示特定的瞬间，精确到毫秒。Date类中大部分方法都已经被Calendar类中的方法所去掉
- 时间单位
- 1秒=1000毫秒
- 1毫秒=1000微妙
- 1微妙=1000纳秒
package com.changyonglei.demo05;
import java.util.Date;
public class Demo01 {
public static void main(String[] args) {
//1.创建Date对象
Date date1 = new Date();
System.out.println(date1.toString());//Fri Feb 11 22:55:38 CST 2022
System.out.println(date1.toLocaleString());//2022-2-11 22:55:38
Date date2 = new Date(date1.getTime()-60*60*24*1000);
System.out.println(date2.toLocaleString());//2022-2-10 22:55:38
//2.方法after before8
boolean b1 = date1.after(date2);
System.out.println(b1);//true
boolean b2 = date1.before(date2);
System.out.println(b2);//false
//比较compareTo(),输出0或者1
int d = date1.compareTo(date2);
System.out.println(d);//1
//比较是否相等equals()
boolean b3 = date1.equals(date2);
System.out.println(b3);//false
}
}
Calendar
- Calendar提供了获取或设置各种日历字段的方法
- 构造方法
- protected Calendar()：由于修饰符是protected，所以无法直接创建对象
SimpleDateFormate
- SimpleDateFormat是一个以语言环境有关的方式来格式化和解析日期的具体类
- 进行格式化（日期->文本）、解析（文本->日期）
- 常用的时间模式字母
常用的时间模式字母
package com.changyonglei.demo05;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo03 {
public static void main(String[] args) throws Exception{
//1.创建一个SimpleDateFormat
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
//2.创建Date
Date date = new Date();
//格式化date（把日期转成字符串）
String str = sdf.format(date);
System.out.println(str);
//解析（把字符串转成日期）
Date date2 = sdf.parse("1990/05/01");
System.out.println(date2);
}
}
System类
- System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的
package com.changyonglei.demo05;
public class Demo04 {
public static void main(String[] args) {
//1.System.arraycopy();复制数组
//arraycopy，数组的复制
//src：源数组
//srcPos：从哪个位置开始复制
//dest：目标数组
//destPos：目标数组的位置
//length：复制的长度
int[] arr = {20,18,15,8,35,26,45,90};
int[] dest = new int[8];
System.arraycopy(arr, 0, dest, 0, arr.length);
for(int i=0; i