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

基本数据类型	包装数据类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

包装类的方法可以自行查阅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毫秒数

后两者用过不多说