Java常用类

最新推荐文章于 2023-10-30 20:41:08 发布

望穿先生L

最新推荐文章于 2023-10-30 20:41:08 发布

阅读量2k

点赞数 2

分类专栏： Java Java常用类文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_55983004/article/details/122667544

版权

Java 同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

Java常用类

1 篇文章 0 订阅

订阅专栏

Java常用类

Object类

1.Object类是超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
2.任何类如没有书写extends显示继承某个类，都默认直接继承0bject类，否则为间接继承。
3.0bject类中所定义的方法，是所有对象都具备的方法。
4.0bject类型可以存储任何对象。
（1）作为参数，可接受任何对象。
（2）作为返回值,可返回任何对象。

getClass()方法

public final native Class<?> getClass();

注：此处的native关键字

使用native关键字修饰的函数(方法)，说明这个方法是原生函数，也就是这个方法是用C/C++语言实现的，并且被编译成了DLL，由java去调用。

返回引用中存储的实际对象类型（返回一个class类型的值）

主要应用：通常用于判断两个引用中实际存储对象类型是否一致

hashCode()方法

public native int hashCode();

该方法返回该对象的哈希码值

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

一般情况下相同对象返回相同哈希码。

toString()方法

public String toString() {}

返回该对象的字符串表示

可以根据程序需求覆盖该方法，如：展示各个对象各个属性值

equals()方法

public boolean equals(Object anObject) {}

默认实现为（this == obj）,比较两个对象的地址是否相同

可进行覆盖，比较两个对象的内容是否相同

finalize()方法

（程序员自己一般不会调用该方法）

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。

垃圾对象:没有有效引用指向此对象时,为垃圾对象。垃圾回收:由GC销毁垃圾对象,释放数据存储空间。

自动回收机制:JVM的内存耗尽，一次性回收所有垃圾对象。手动回收机制:使用System. gc();通知JVM执行垃圾回收。

包装类

基本类型存在栈空间里

包装类是一个引用类型，存放在堆中

包装类将基本数据类型包装在一个对象中

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FmyBIMws-1643007184418)(C:\Users\28905\AppData\Roaming\Typora\typora-user-images\image-20220121153237038.png)]$

8种包装类提供不同类型间的转换方式:

Number父类中提供的6个共性方法。

parseXXX()静态方法。（将字符串转换成基本类型）
valueof()静态方法。(将基本类型转换成引用类型)

public class Application {
    public static void main(String[] args) {
        int num=10;
        //装箱
        Integer integer = new Integer(num);
        Integer integer1=Integer.valueOf(num);   //将整型转换成引用类型
        
        //拆箱
        int num2=integer1.intValue();         //将引用类型转换为整型
    }
}

基本类型和字符串之间的转换

通过基本类型封装对象的parsXXX()方法进行字符串向基本数据类型的转换

public class Common_Class {
    public static void main(String[] args) {
        //将基本类型转换成字符串
        //1.通过“+”号连接
        //2.通过toString()方法
        int num=10;
        String s1=num+"";
        String s2=Integer.toString(num);
        String s3=Integer.toString(num,16);   //toString()的重载方法，此处是将整型转换成16进制表示后，再变成字符串类型
        System.out.println(s1+" "+s2+" "+s3);

        //将字符串转换成基本类型
        //通过parseXXX()方法进行转换
        int num_a=Integer.parseInt(s1);      //将字符串s1转换成整型
        float num_b=Float.parseFloat(s1);    //将字符串s1转换成浮点类型
    }
}

注：boolean类型的字符串转换成基本类型的时候，只有字符串"true"会转换成boolean类型的true,其他的boolean类型的字符串都会转换成false

Integer整数缓冲区

Java预先创建了256个常用的整数包装类型对象

(缓冲区中的数为-128~127，如果新创建的引用类型数据在这个区间内，则直接在堆空间中取这个数映射到栈空间中，如果不在这个区间内则在堆空间中新开辟一个空间)

注：只有通过valueof()方法定义的整型引用类型才会有缓冲区

public class Integer_Demo {
    public static void main(String[] args) {
        //通过实例化一个引用类型对象，没有缓冲区，所以输出false
        Integer int1=new Integer(127);
        Integer int2=new Integer(127);
        System.out.println(int1==int2);  //等于号是比地址equals()方法比的是字符串的值
       
        /*Integer.java文件中的valueof()方法
        public static Integer valueOf(int i) {
            if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)
                return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];
            return new Integer(i);
        }*/
        
        //只有通过valueof()方法定义的引用类型才会有整型缓冲区
        //128不在整型缓冲区提供的区间内，输出false
        Integer int3=Integer.valueOf(128);
        Integer int4=Integer.valueOf(128);
        System.out.println(int3==int4);
        
        //111在整型缓冲区提供的区间内，所以输出true
        Integer int5=Integer.valueOf(111);
        Integer int6=Integer.valueOf(111);
        System.out.println(int5==int6);
    }
}

整型缓冲区映射图

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-90yVX1kd-1643007184420)(C:\Users\28905\AppData\Roaming\Typora\typora-user-images\image-20220122150229808.png)]$

String

字符串是常量,创建之后不可改变。
字符串字面值存储在字符串池中，可以共享。
String name = “Hello”;产生一个对象，在字符串池中存储。
String s = new String(“Hello”); 产生两个对象，堆、池各存储一个。
$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9C5HRjq2-1643007184420)(C:\Users\28905\AppData\Roaming\Typora\typora-user-images\image-20220122152046031.png)]$

String常用方法

1.public int length():返回字符串的长度。
2.public char charAt(int index):根据下标获取字符（下标从0开始）。
3.public boolean contains(String str):判断当前字符串中是否包含str.

4.public char[] toCharArray():将字符串转换成数组。
5.public int indexOf(String str):查找str首次出现的下标，存在，则返回该下标;不存在，则返回-1。

6.public int lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的下标索引。

7.public String trim():去掉字符串前后的空格。

8.public String toUpperCase():将小写转成大写。
9.public boolean endWith(String str):判断字符串是否以str结尾。

10.public boolean startWith(String str):判断字符串是否以str开始。

11.public String replace(char oldChar, char newChar)：将旧字符串替换成新字符串

12.public String[] split(String str):根据str做拆分。

13.public boolean equals(Object anObject):可以用于比较两个字符串是否相等

14.public int compareTo(String anotherString)：如果被比较的两个字符串不相等，则返回Ascii码值的差；如果被比较的两个字符串，字符串1是字符串2的子串则返回长度的差

String str1="abcwccc";
String str2="abcwa";
System.out.println(str1.compareTo(str2));        //比较ASCII码值：输出2 （99-97=2）
String str3="abc";
String str4="abcefg";
System.out.println(str3.compareTo(str4));       //比较长度：输出-3 (3-6=-3)

StringBuffer和StringBuilder

StringBuffer:可变长字符串，JDK1.0提供，运行效率慢、线程安全。
StringBuilder:可变长字符串，JDK5.0提供，运行效率快、线程不安全。

和String相比：（1）效率比String高（2）比String节省内存

public static void main(String[] args) {
    StringBuffer sb = new StringBuffer();
    //StringBuilder sb = new StringBuilder();
    //append()追加
    sb.append("你好，");                  //追加字符串
    sb.append("望穿先生");
    System.out.println(sb.toString());
    //insert()添加
    sb.insert(3,"我是");      //在下标为3的位置添加字符串你好
    System.out.println(sb.toString());
    //replace()替换
    sb.replace(0,2,"Hello"); //（含头不含尾）从下标为0的位置开始，替换到下标为1的位置
    System.out.println(sb.toString());
    //delete()删除
    sb.delete(0,8);     //含头不含尾，删除下标从0开始到下标为7的字符串
    System.out.println(sb);
}

BigDecimal类

很多实际应用中需要精确运算,而double是近似值存储,不再符合要求,需要借助BigDecimal。

public static void main(String[] args) {
    double num1=1.0;
    double num2=0.9;
    System.out.println(num1-num2);  //输出0.09999999999999998
                                    //原因是double类型在内存中近似存储
    //使用BigDecimal进行精确运算
    BigDecimal n1 = new BigDecimal("1.0");  //注意要用字符串,否则结果仍然有误差
    BigDecimal n2 = new BigDecimal("0.9");
    BigDecimal n3=n1.subtract(n2);      //进行减法运算
    System.out.println(n3);

//注意：除法如果除不尽会报错，要使用除法的一个重载方法保留小数
    BigDecimal b1 = new BigDecimal("10");
    BigDecimal b2 = new BigDecimal("3");
    BigDecimal b3=b1.divide(b2,2,BigDecimal.ROUND_HALF_UP); //BigDecimal.ROUND_HALF_UP为四舍五入
    System.out.println(b3);
}

注意除法：

除法: divide (BigDecimal bd,int scal, RoundingMade mode) 参数scal
:指定精确到小数点后几位。参数mode :
指定小数部分的取舍模式，通常采用四舍五入的模式,
取值为BigDecimal.ROUND_HALF_UP。

Date类

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。

时间单位：
1秒=1000毫秒

1毫秒=1000微秒

1微秒=1000纳秒

public static void main(String[] args) {
    Date date = new Date();
    System.out.println(date.getTime());//gettime()方法获取当前时间的毫秒数（从1970年1月1日开始）
    System.out.println(date);
    Date date2=new Date(date.getTime()-(60*60*24*1000));//用当前时间的毫秒数减去一天的毫秒数，得到昨天此时的时间
    boolean b=date2.before(date); //before()方法用于判断时间的前后
    System.out.println(b);
}

Calendar类

Calendar提供了获取或设置各种日历字段的方法构造方法
protected Calendar() :由于修饰符是protected，所以无法直接创建该对象。

其他方法：
1.static Calendar getInstance()：使用默认时区和区域获取日历
2.void set(int year,int month,int date,int hourofday,int minute,int second)设置日历的年、月、日、时、分、秒。
3.int get(int field)：返回给定日历字段的值。字段比如年、月、日等
4.void setTime(Date date)：用给定的Date设置此日历的时间。Date-Calendar
5.Date getTime()：返回一个Date表示此日历的时间。Calendar-Date
6.void add(int field,int amount)：按照日历的规则，给指定字段添加或减少时间量
7.long getTimelnMillies()：毫秒为单位返回该日历的时间值

public static void main(String[] args) {
    //创建对象
    Calendar calendar=Calendar.getInstance(); //不能直接实例化Calendar对象

    //获取时间，通过get()方法
    int year=calendar.get(Calendar.YEAR); //获取年
    int month=calendar.get(Calendar.MONTH); //获取月
    int day=calendar.get(Calendar.DAY_OF_MONTH); //获取日
    int hour=calendar.get(Calendar.HOUR_OF_DAY); //HOUR是12小时；HOUR_OF_DAY是24小时
    //月份要加1，因为该方法显示的月份是从0到11
    System.out.println("当前时间是："+year+"年"+(month+1)+"月"+day+"日"+hour+"时");

    //可以通过getMaximum（）和getMinimum（）获取当前月份的最大和最小时间
    Calendar calendar1=Calendar.getInstance();
    int num=calendar1.getMaximum(Calendar.DAY_OF_MONTH);//获取当前月份的最大天数
    System.out.println(num);
    int num1=calendar1.getMinimum(Calendar.DAY_OF_MONTH);//获取当前月份的最小天数
    System.out.println(num1);

}

SimpleDateFormat类

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
进行格式化（日期->文本）、解析（文本->日期）。常用的时间模式字母

在这里插入图片描述

public static void main(String[] args) {
    //创建SimpleDateFormat对象
    SimpleDateFormat time= new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
    //创建Date对象
    Date date = new Date();
    //使用format()方法格式化,将日期转换成字符串
    String str=time.format(date);
    System.out.println(str);


    //把字符串转换成Date日期
    try {
        Date date1=time.parse("2020年12月11日 10:22:11");
        System.out.println(date1);
    } catch (ParseException e) {
        e.printStackTrace();
    }
}

System类

System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有
在这里插入图片描述

public static void main(String[] args) {
    //使用arraycopy()方法实现数组的复制
    // src:原数组、srcPos:从哪个位置开始复制
    //dest:目标数组 、destPos:目标数组的开始位置 、length:复制的长度
    int[] arr=new int[]{11,22,33,44,55};
    int[] dest=new int[5];
    System.arraycopy(arr,0,dest,0,arr.length);
    System.out.println(Arrays.toString(dest));

    //通过currentTimeMillis()方法实现计算代码的运行时间
    long start=System.currentTimeMillis();
    for (int i = 0; i < 9999; i++) {
        for (int j = 0; j < 999999; j++) {
            int result=i+j;
        }
    }
    long end=System.currentTimeMillis();
    System.out.println("运行时间为："+(end-start));
}

望穿先生L

关注

2
点赞
踩
19

收藏

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

Java常用类Object类1.Object类是超类、基类，所有类的直接或间接父类，位于继承树的最顶层。2.任何类如没有书写extends显示继承某个类，都默认直接继承0bject类，否则为间接继承。3.0bject类中所定义的方法，是所有对象都具备的方法。4.0bject类型可以存储任何对象。（1）作为参数，可接受任何对象。（2）作为返回值,可返回任何对象。getClass()方法public final native Class<?> getClass();注：此处
复制链接

扫一扫