Java教程

常用类

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

目录
  • 常用类
    • 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
基本数据类型 包装类型
byte Byte
short Short
int Integer
long Long
float Float
double Double
boolean Boolean
char Character

类型转换与装箱、拆箱

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

方法名 说明
static void arraycopy() 复制数组
static long currentTimeMillis() 获取当前系统时间。返回的是毫秒值
static void gc() 建议JVM赶快启动垃圾回收器回收垃圾
static void exit(int status) 退出jvm,如果参数是0表示正常退出jvm,非0表示异常退出jvm
这篇关于常用类的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!