本文主要是介绍常用类，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

• 常用类
  • Object类
    • getClass()方法
    • hashCode方法
    • toString()方法
    • equals()方法
    • finalize()方法
  • 包装类
    • 类型转换与装箱、拆箱
    • 整数缓冲区
  • String类
    • 字符串池
    • 常用方法
    • 可变字符串
      • 四个常用方法
  • BigDecimal
  • Date
  • Calendar
  • SimpleDateFormat
  • System类

常用类

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

类型转换与装箱、拆箱

• 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调用即可；

这篇关于常用类的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！