java常用类

Object类

基类，超类，所有类的直接或间接父类

object类定义的方法是所有对象都具有的方法

object类型可以存储任何对象

• 作为参数，可以接受任何对象
• 作为返回值，可以返回任何对象

getClass()

返回引用中存储的实际对象类型

public class  Student  {
 public static void main(String[] args) {
	Student student = new Student();
	System.out.println(student.getClass());
	System.out.println(student.getClass().getName());
	System.out.println(student.getClass().getSimpleName());
    }
}
/* out:
class com.xxx.Student
com.xxx.Student
Student

hashCode()

返回该对象的哈希码值（int）

哈希值：根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。

一般情况下相同对象返回相同哈希码

Student student = new Student();
System.out.println(student.hashCode());
Student student1 = new Student();
System.out.println(student.hashCode()==student1.hashCode());
/*
1435804085
false

toString()

返回对象的字符串表现形式

可以进行重写，自己来觉得展示的字符串形式

Student student = new Student();
System.out.println(student.toString());
//com.xxx.Student@5594a1b5

equals()

比较两个对象地址是否相同

也可以重写，自己觉得比较方式

Student student = new Student();
Student student1 = new Student();
System.out.println(student.equals(student1));
//false

finalize()

当对象被判定为垃圾对象时，由JVM自动调用此方法，用来标记，进入回收队列

垃圾对象：没有有效引用指向此对象，

垃圾回收：释放数据存储空间

自动回收机制：JVM内存耗尽，一次性回收所有垃圾对象

手动回收机制：使用System.gc()；通知JVM回收

垃圾回收时调用finalize()，本身为空需要重写

public static void main(String[] args) {
    Student student = new Student();
    //后两者为垃圾
    new Student();
    new Student();
    System.gc();
}

@Override
protected void finalize() throws Throwable {
    System.out.println("一个垃圾被回收了");
}
/*一个垃圾被回收了
一个垃圾被回收了

包装类

为解决基本数据类型没有相应方法，设计了基本数据类型对应的引用数据类型，这就是包装类

包装类默认值：null

包装类的方法可以自行查阅java的官方文档

类型转换和装箱、拆箱

装箱：基本类型转换成引用类型

拆箱：引用类型转换为基本类型

Number类

Number类是六个包装类以及一些其他类的子类

基本类型转引用类型

int a = 2;
Integer integer = new Integer(a);
Integer integer1 =  Integer.valueOf(2);

自动装箱（jdk1.5之后）

int a = 2;
Integer integer = a;

引用类型转基本类型

int b = integer.intValue();

自动拆箱（jdk1.5之后）

int a = 2;
Integer integer = a;
Integer integer1 = integer;

parseXXX()静态方法

基本类型转字符串

int n1=100;
String s1 = n1+"";
//或者
String s2 = Integer.toString(n1);
//十六进制
String s2 = Integer.toString(n1,16);

字符串转基本类型

字符串转int：Integer.parseInt(String)

字符串转其他：包装类.praseXXX(String)

boolean字符串转基本类型，除了"true"是true全是false

Integer缓冲区

//因为左边创建变量在栈，栈存放堆里地址，两者地址不同不相等
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1==integer2);
//自动装箱，自动装箱本质是调用Integer.ValueOf方法,可以直接看一下Integer.ValueOf方法，因为该方法中有判断条件为：如果值大于等于-128，小于等于127直接返回缓冲区（堆中）对象值，否则new一个新的Integer返回。综上所以后两者结果不同
integer1 =100;
integer2 =100;
System.out.println(integer1==integer2);

integer1 =200;
integer2 =200;
System.out.println(integer1==integer2);
//地址相等了
Integer integer3 = new Integer(100);
Integer integer4 = integer3;
System.out.println(integer3==integer4);
/*
false
true
false
true

String类

String的一些特性

字符串是常量，创建之后不可改变：

什么意思呢？当我们修改字符串时并不是把旧的字符串的值改成了新的值，而是在字符串池开辟新空间存储新增，并且把栈中的声明地址指向新的值。旧的值成了“垃圾”。

与此同时，当我们再次什么一个新的字符串变量，并且把他赋值为和刚才已有变量相同的值，那么直接指向已有变量值的字符串池空间，不再开辟新的空间存值

使用new创建字符串时又有所不同，他是在堆中创建了的空间存储对象然后堆中空间又指向（可能说指向不对但可以这样理解）字符串池（相同值依旧指向同一个字符串池空间）,总的来说创建了两个对象分别在方法区和堆中

String s = "name";
String s1 = "name";
System.out.println(s==s1);
//true

String s = "name";
String s1 = new String("name");
System.out.println(s==s1);
//equals比较的是数据
System.out.println(s.equals(s1));
//false
//true

字符串字面值（右边）存储在字符串池（在方法区中（方法区逻辑上独立，物理上属于堆））中，可以共享

java常用方法

这些方法应该不用我一行行的演示吧

可变字符串

由于上面描述的String的不可变性质，我们需要通过其他的类来解决这个特性带来的一些问题（效率低等）

StringBuffer类：可变长字符串在String的基础上加上了缓冲区，运行效率慢、线程安全

StringBuilder：可变长字符串，运行效率快、线程不安全

两者相对于String，效率更高，更加节省内存

StringBuffer sb = new StringBuffer();
//追加
sb.append("hello");
System.out.println(sb.toString());
sb.append("world");
System.out.println(sb.toString());
   //添加
   sb.insert(0,"最前面");
   System.out.println(sb.toString());
   //replace();左闭右开
   sb.replace(0,3,"hello");
   System.out.println(sb.toString());
   //delete()
   sb.delete(0,5);
   System.out.println(sb.toString());
   //其他方法如翻转清空自己搜索
/*
hello
helloworld
最前面helloworld
hellohelloworld
helloworld

//StringBuider和StringBuffer相同，单线程用前者，否则后者

BigDecimal

关于double存在精度丢失（存储的实际上是近似值）

double d1 = 1.0;
double d2 = 0.9;
double d3 = d1-d2;
System.out.println(d3);

//0.09999999999999998

需要精确计算或是小数比较时用BigDecimal类，可以精确计算浮点数

        BigDecimal bigDecimal = new BigDecimal("1.0");
        BigDecimal bigDecimal1 = new BigDecimal("0.9");
        //减法
        System.out.println(bigDecimal.subtract(bigDecimal1));
        //加法
        bigDecimal.add(bigDecimal1);
//        乘法
        bigDecimal.multiply(bigDecimal1);
//        除法
        bigDecimal.divide(bigDecimal1);
        
        bigDecimal.subtract(bigDecimal1).divide(bigDecimal1);
//+保留几位，四舍五入
bigDecimal.subtract(bigDecimal1).divide(bigDecimal1,1,BigDecimal.ROUND_HALF_EVEN);
//0.1

Data

很多方法已经过时或者被Calendar类替代

不想多说自己看文档

Date date = new Date();
System.out.println(date.toString());
//Thu May 18 19:41:35 CST 2023

Calendar

Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());
//2023年5月18日 下午7:46:33
 //年
        int year = Calendar.get(Calendar.YEAR);
        //月,比实际小1
        calendar.get(Calendar.MONTH);
//        日
        calendar.get(Calendar.DAY_OF_MONTH);
//        小时
        calendar.get(Calendar.HOUR_OF_DAY);//HOUR12小时，HOUR_OF_DAY24小时
//        分钟
        calendar.get(Calendar.MINUTE);
//        秒
        calendar.get(Calendar.SECOND);

其他自己查文档

SimpleDataFormat

与语言环境有关的方式来格式化和解析日期的具体类

实现日期-->文本或者文本-->日期

SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
        Date date = new Date();
        //格式化
        String string = sdf.format(date);
        System.out.println(string);
        //解析
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
        Date date2 = sdf1.parse("1990-05-01");
        System.out.println(date2);
/*2023年05月18日20:09:03
Tue May 01 00:00:00 CDT 1990

System类

构造方法私有,方法是静态的

int[] arr={20,18,15,8,45,90,1,65};
int[] dest=new int[8];
//源数组-开始复制位置下标-目标数组-目标数组的位置-复制长度
System.arraycopy(arr,0,dest,0,arr.length);
for(int i=0;i<dest.length;i++){
    System.out.println(dest[i]);
}
/*
20
18
15
8
45
90
1
65

currentTimeMillis():现在到1970毫秒数

后两者用过不多说