常用类

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

字母	日期或时间	示例
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

posted @ 2022-05-04 02:08 L先生988 阅读(41) 评论(0) 收藏举报

刷新页面返回顶部

L先生988

常用类

常用类

Object类

getClass()方法

hashCode方法

toString()方法

equals()方法

finalize()方法

包装类

类型转换与装箱、拆箱

整数缓冲区

String类

字符串池

常用方法

可变字符串

四个常用方法

BigDecimal

Date

Calendar

SimpleDateFormat

System类

公告