JAVA常用类

最新推荐文章于 2022-06-20 19:05:05 发布

 Alisa-WikL

最新推荐文章于 2022-06-20 19:05:05 发布

阅读量148

点赞数

本文链接：https://blog.csdn.net/Alisa_WikL/article/details/108529975

版权

Object类

getClass()方法

比较两个对象是否属于同一类

public class GetClassDemo {
    public static void main(String[] args) {
        StudentGetClassDemo s1=new StudentGetClassDemo("LHD",24);
        StudentGetClassDemo s2=new StudentGetClassDemo("WMZ",23);
        //判断s1，s2是不是同一类型
        Class class1=s1.getClass();
        Class class2=s2.getClass();
        if (class1==class2){
            System.out.println("是同一类");
        }else{
            System.out.println("不是同一类");
        }
    }
}

hashCode()方法

返回对象的哈希码值
哈希码值是根据对象的地址或字符串或数字用hash算法算出来的int类型的数值

public class HashCodeDemo {
    public static void main(String[] args) {
        StudentGetClassDemo s1=new StudentGetClassDemo("LHD",24);
        StudentGetClassDemo s2=new StudentGetClassDemo("WMZ",23);
        StudentGetClassDemo s3=s2;
        //返回对象的哈希码值
        int h1=s1.hashCode();
        int h2=s2.hashCode();
        int h3=s3.hashCode();
        System.out.println(h1);//1239731077
        System.out.println(h2);//557041912
        System.out.println(h3);//557041912
    }
}

toString()

返回对象的字符串表现形式
可根据需要在相应类中重写该方法

public class ToStringDemo {
    public static void main(String[] args) {
        StudentGetClassDemo s1=new StudentGetClassDemo("LHD",24);
        StudentGetClassDemo s2=new StudentGetClassDemo("WMZ",23);
        System.out.println(s1.toString());//LHD，24
        System.out.println(s2.toString());//WMZ，23
    }
}

重写了类中的方法

    @Override
    public String toString() {
        return name+"，"+age;
    }

equals()

默认比较两个对象地址是否相同
可以重写，比较内容是否相同

public class EqualsDemo {
    public static void main(String[] args) {
        StudentGetClassDemo s1=new StudentGetClassDemo("LHD",24);
        StudentGetClassDemo s2=new StudentGetClassDemo("WMZ",23);
        System.out.println(s1.equals(s2));//false

        StudentGetClassDemo s3=new StudentGetClassDemo("WMZ",23);
        StudentGetClassDemo s4=new StudentGetClassDemo("WMZ",23);
        System.out.println(s3.equals(s4));//重写前为false，重写后为true
    }
}

重写

@Override
    public boolean equals(Object obj) {
        //1.判断两个对象是否为同一引用
        if (this==obj){
            return true;
        }
        //2.判断obj是否为null
        if (obj==null){
            return false;
        }
        //3.判断是否是同一类型
        // 方法一    if (this.getClass()==obj.getClass()){}
        //方法二 instanceof
        if (obj instanceof StudentGetClassDemo){
            //4.强制类型转换
            StudentGetClassDemo s=(StudentGetClassDemo)obj;
            //5.比较属性
            if (this.name.equals(s.getName())&&this.age==s.getAge()){
                return true;
            }
        }
        return false;
    }

finalize()

当对象被判定成垃圾对象时，JVM自动调用此方法，标记为垃圾对象进入回收队列
JVM可以自动回收
使用System.gc()可以手动通知JVM进行回收，但是还是要看cpu的心情，可能不会回收
使用时需要进行重写，原方法是空的

public class FinalizeDemo {
    public static void main(String[] args) {
        new StudentGetClassDemo("aaa",10);
        new StudentGetClassDemo("bbb",10);
        new StudentGetClassDemo("ccc",10);
        new StudentGetClassDemo("ddd",10);
        System.gc();
        System.out.println("回收垃圾");
    }
}

重写：

@Override
    protected void finalize() {
        System.out.println(this.name + "被回收了");
    }

输出结果：
aaa被回收了
bbb被回收了
ccc被回收了
ddd被回收了
回收垃圾

包装类

基本数据类型所对应的引用数据类型，引用类型有属性有方法，默认值为null
对应表格

装箱、封箱

装箱：栈里的数据拿到堆里，基本类型变成引用类型
拆箱：堆里的数据拿到栈里，引用类型变为基本类型

public class IntegerDemo {
    public static void main(String[] args) {
        //简洁写法
           //装箱
        int num1=10;//基本类型
        Integer integer1=num1;//引用类型
        System.out.println(num1);
        System.out.println(integer1);
           //拆箱
        Integer integer2=100;//引用类型
        int num2=integer2;//基本类型
        System.out.println(integer2);
        System.out.println(num2);

        //繁琐写法
            //装箱
        int num3=20;//基本类型
        Integer integer31=new Integer(num3);//引用类型,方式一
        Integer integer32=Integer.valueOf(num3);//引用类型,方式二
        System.out.println(num3);
        System.out.println(integer31);
        System.out.println(integer32);
            //拆箱
        Integer integer4=new Integer(200);//引用
        int num4=integer4.intValue();//基本
        System.out.println(integer4);
        System.out.println(num4);
    }
}

Integer缓冲区

JAVA预先创立了256个常用的整数包装类型对象
已经创建的对象地址一样：在-128到127之间的数据，在堆里有位置，返回到栈里的地址是相同的；不在范围内会重新开一个地址，地址不同就不相同。

public class IntegerCacheDemo {
    public static void main(String[] args) {
        Integer integer1=new Integer(100);
        Integer integer2=new Integer(100);
        System.out.println(integer1==integer2);//false
        System.out.println(integer1.equals(integer2));//true

        Integer integer3=Integer.valueOf(100);
        Integer integer4=Integer.valueOf(100);
        System.out.println(integer3==integer4);//true
        System.out.println(integer3.equals(integer4));//true

        Integer integer5=Integer.valueOf(200);
        Integer integer6=Integer.valueOf(200);
        System.out.println(integer5==integer6);//false
        System.out.println(integer5.equals(integer6));//true

        /*
        缓冲区源码
         public static Integer valueOf(int i) {
        if (i >= IntegerCache.low（-128） && i <= IntegerCache.high（127）)//在-128到127之间的数据，在堆里有位置，返回到栈里的地址是相同的
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);//不在范围内会重新开一个地址，地址不同就不相等
    }
         */
    }
}

String类

字符串是常量，创建后不可改变
String s=“Hello”:创建了一个对象，在字符串池中存储
String s=new String(“Hello”):产生两个对象，堆、池中各一个，但是堆中指向的池

public class StringIntroduce {
    public static void main(String[] args) {
        String s="Alisa";//创建了一个对象，在字符串池中存储
        s="Name";//重新在字符串池中开了一个位置，重新赋值，”Alisa“就没用了

        String s1=new String("LHD");//产生两个对象，堆、池中各一个，但是堆中指向的池
        String s2=new String("LHD");
        System.out.println(s1==s2);//false,池中存储的一样，但是堆中不一样
        System.out.println(s1.equals(s2));//true
    }
}

length()

返回字符串的长度（int）

String truth="  LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!   ";
System.out.println(truth.length());//字符串长度：62

charAT（）

根据下标获取字符（char）

String truth="  LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!   ";
System.out.println(truth.charAt(5));//第5个位置的字符：“是”

contains()

判断当前字符串中是否包含目标字符串（boolean）

String truth="  LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!   ";
System.out.println(truth.contains("LHD"));//是否包含“LHD”：true
System.out.println(truth.contains("WMZ"));//是否包含“WMZ”：false

toCharArray()

变成字符串对应的数组（char[ ]）

String truth="  LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!   ";
System.out.println(truth.toCharArray());//对应的数组:  LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!   
System.out.println(Arrays.toString(truth.toCharArray()));//变成字符串对应的数组:[ ,  , L, H, D, 是, 世, 界, 上, 最, 帅, 的, 男, 人, !, I,  , l, o, v, e,  , L, H, D, !, I,  , l, o, v, e,  , L, H, D, !, I,  , l, o, v, e,  , L, H, D, !, I,  , l, o, v, e,  , L, H, D, !,  ,  ,  ]

indexOf()

查找字符串首次出现的位置，存在返回下标，不存在返回-1

String truth="  LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!   ";
System.out.println(truth.indexOf("LHD"));//字符第一次出现的位置:2
System.out.println(truth.indexOf("LHD",6));//从第6位开始字符第一次出现的位置:22

lastIndexOf()

查找字符串最后出现的位置

String truth="  LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!   ";
System.out.println(truth.lastIndexOf("LHD"));//字符最后一次出现的位置：55

trim()

去掉前后空格

String truth="  LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!   ";
System.out.println(truth.trim());//LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!

toUpperCase()

小写变大写

String truth="  LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!   ";
System.out.println(truth.toUpperCase());

toLowerCase()

大写变小写

String truth="  LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!   ";
System.out.println(truth.toLowerCase());

endsWith()

是否以某个字符串结尾

String truth="  LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!   ";
System.out.println(truth.endsWith("!   "));//true
System.out.println(truth.endsWith("!"));//false

startsWith(）

是否以某个字符串开始

String truth="  LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!   ";
System.out.println(truth.startsWith("  LHD"));//true
System.out.println(truth.startsWith("LHD"));//false

replace(）

用新的字符或者字符串替换旧的

String truth="  LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!   ";
System.out.println(truth.replace("LHD","My Husband"));

String[ ] Split()

根据str做拆分

String truth="  LHD是世界上最帅的男人!I love LHD!I love LHD!I love LHD!I love LHD!   ";
String[]arr=truth.split("[!, ]+");//[]中间为多个拆分依据，+表示遇到重复的依据可以不用拆
System.out.println(arr.length);
for (String s : arr) {
   System.out.println(s);//遍历输出
}

equals()

比较是否相等

String s1="hello";
String s2="HELLO";
System.out.println(s1.equals(s2));//比较是否相等:false
System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写比较是否相等:true

compareTO()

比较大小

String s3="aabc";//a97
String s4="axyz";//x120
System.out.println(s3.compareTo(s4));//比较源码大小，做第一位差，如果第一位相同，继续往下：-23

String s5="abc";
String s6="abcxyz";
System.out.println(s5.compareTo(s6));//长度不相同时，比较长度差：-3

StringBuffer()和StringBulider()

可变字符串
StringBuffer：效率慢，线程安全。StringBuilder：效率快，线程不安全
与String比较：效率高，省内存。
append() 追加
insert() 插入
replace() 替换
delete() 删除

public class StringBuffer01 {
    public static void main(String[] args) {
        //StringBuffer stringBuffer=new StringBuffer();
        StringBuilder stringBuffer=new StringBuilder();
        //追加
        stringBuffer.append("LHD最棒！");
        System.out.println(stringBuffer);
        stringBuffer.append("LHD最帅！");
        System.out.println(stringBuffer);
        stringBuffer.append("我太爱LHD啦！");
        System.out.println(stringBuffer);
        //添加
        stringBuffer.insert(0,"LHD加油！");//数字代表位置
        System.out.println(stringBuffer);
        //替换
        stringBuffer.replace(0,5,"HD");//数字为起始位置，结束位置，含首不含尾
        System.out.println(stringBuffer);
        //删除
        stringBuffer.delete(0,2);//数字为起始位置，结束位置，含首不含尾
        System.out.println(stringBuffer);
        //清空
        stringBuffer.delete(0,stringBuffer.length());
        System.out.println(stringBuffer);
    }
}

Date类

表示特定时间，精确到毫秒

toString()

以字符串类型输出当前时间
toLocaleString()：输出当地形式的时间

Date today=new Date();
System.out.println(today.toString());
System.out.println(today.toLocaleString());

getTime()

获取现在的时间

Date yesterday=new Date(today.getTime()-(60*60*24*1000));//今天的时间-一整天的毫秒数
System.out.println(yesterday.toLocaleString());

before()&after()

比较时间先后顺序

 boolean b1=yesterday.after(today);//false
System.out.println(b1);
boolean b2=yesterday.before(today);//true
System.out.println(b2);

compareTo()

比较:做差，负数、正数、0

int i=yesterday.compareTo(today);//-1
int i=today.compareTo(yesterday);//1
int i=yesterday.compareTo(yesterday);//0

equals()

比较是否相等

boolean b3=yesterday.equals(today);//false
System.out.println(b3);

Calendar类

getInstance()

获取默认时间
**getTimeInMillis()**从1970年1月1日到现在的毫秒数

Calendar calendar1=Calendar.getInstance();
System.out.println(calendar1.getTime().toLocaleString());
System.out.println(calendar1.getTimeInMillis());

get()

获取时间

int year=calendar1.get(Calendar.YEAR);
int month=calendar1.get(Calendar.MONTH);//0-11,正常输出需要+1
int day=calendar1.get(Calendar.DAY_OF_MONTH);//DATE也一样
int hour=calendar1.get(Calendar.HOUR_OF_DAY);//HOUR也一样,hour为12，HOUR_OF_DAY为24
int minute=calendar1.get(Calendar.MINUTE);
int second=calendar1.get(Calendar.SECOND);
System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);

set()

修改时间为

Calendar calendar2=Calendar.getInstance();
calendar2.set(Calendar.DAY_OF_MONTH,5);
System.out.println(calendar2.getTime().toLocaleString());

add()

增减时间

calendar2.add(Calendar.DAY_OF_MONTH,-5);
System.out.println(calendar2.getTime().toLocaleString());

getActualMaximum()&getActualMinimum()

获取最大值，最小值

calendar2.add(Calendar.DAY_OF_MONTH,-5);//可以先更改再获取
int max=calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
int min=calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
System.out.println(max);
System.out.println(min);

SimpleDateFormat类

格式化/解析日期

SimpleDateFormat()

创建对象并设置格式：y年 M月 d日 h/H小时 m分钟 s秒 S毫秒

两种不同的格式：

SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy/MM/dd");

format()

按照给定格式格式化日期：日期→文本

 //创建DATE
Date date=new Date();
String str= simpleDateFormat.format(date);
System.out.println(str);

解析

解析：将按照格式输入的字符串转换成当地常用写法：文本→日期

Date date1=new Date("1997/11/27");
System.out.println(date1.toLocaleString());

System类

用于获取系统属性和其他操作，方法私有

arraycopy()

复制数组
入参意义：
原数组，原数组开始位置，新数组，新数组开始位置，复制长度

int[] array={12,34,45,23,658,324,47,4};
int[] des=new int[8];
System.arraycopy(array,4,des,4,4);
for (int i = 0; i < des.length; i++) {
     System.out.println(des[i]);
    }

currentTimeMillis()

获取时间：从1970年1月1日到现在的毫秒数

System.out.println(System.currentTimeMillis());

用处：获取程序运行时间

long start=System.currentTimeMillis();
 程序运行代码
long end=System.currentTimeMillis();
System.out.println("运行时间"+(end-start));

gc()

诉系统回收垃圾,如果系统觉得正在使用就先不回收

 System.gc();

exit()

退出JVM

System.exit(0);

 Alisa-WikL

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA常用类

JAVA常用类Object类getClass()方法hashCode()方法toString()equals()finalize()包装类装箱、封箱Integer缓冲区String类length()charAT（）contains()toCharArray()indexOf()lastIndexOf()trim()toUpperCase()toLowerCase()endsWith()startsWith(）replace(）String[ ] Split()equals()compareTO()Strin
复制链接

扫一扫