常用类

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

Object类

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

getClass()方法

public final Class<?>getClass(){}
返回引用中存储的实际对象类型。

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

Student.java

package com.cclass.demo05;

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student(){

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

TestStudent.java

package com.cclass.demo05;

public class TestStudent {
    public static void main(String[] args) {
        //getClass方法
        Student s1 = new Student("abc",20);
        Student s2 = new Student("zxc",29);
        //判断s1和s2是不是同一个类型
        Class<? extends Student> aClass = s1.getClass();
        Class<? extends Student> aClass1 = s2.getClass();
        if (aClass==aClass1){
            System.out.println("s1和s2属于同一个类型");
        }else {
            System.out.println("s1和s2不属于同一个类型");
        }
		//s1和s2属于同一个类型
    }
}

hashCode()方法

public int hashCode(){}
返回该对象的哈希码值。
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。
一般情况下相同对象返回相同哈希码。

toString()方法

public String toString(){}
返回该对象的字符串表示（表现形式）
可以根据程序需求覆盖该方法，如：展示对象各个属性值。

equals()方法

public boolean equals(Object obj){}
默认实现为（this == obj），比较两个对象地址是否相同。
可进行覆盖，比较两个对象的内容是否相同。

equals()方法覆盖步骤

比较两个引用是否指向同一个对象。
判断obj是否为null。
判断两个引用指向的实际对象是否一致。
强制类型转换。

依次比较各个属性值是否相同。

public boolean equals (Object obj){
    //1.比较两个引用是否指向同一个对象
    if (this==obj){
        return true;
    }
    //2.判断obj是否为null
    if (obj==null){
        return false;
    }
    //3.判断是否是t同一个类型
    //instanceof 可判断对象是否是某种类型
    if (obj instanceof Student){
        //4.强制类型转换
        Student s = (Student)obj;
        //5.比较属性
        if (this.name.equals(s.getName())&&this.age==s.getAge()){
            return true;
    }
    return false;
}

finalize()方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，
进入回收队列。
垃圾对象：没有有效引用指向此对象时，为垃圾对象。
垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
手动回收机制：使用System.gc();通知JVM执行垃圾回收。

包装类

什么是包装类？

基本数据类型所对应的引用数据类型。
Object可统一所有数据，包装类的默认值是null。
包装类对应

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

Number父类种提供的6个共性方法。
parseXXX()静态方法。
valueof()静态方法。
注意：需保证类型兼容，否则抛出NumberFormatException异常。

类型转换与装箱、拆箱

装箱：将栈里的基本类型转为堆里的对象基本类型 ----> 引用类型

Integer.valueOf(num1);

拆箱：将堆里的对象拿到栈里引用类型 ----> 基本类型

integer3.intValue();

Demo01.java

package com.cclass.demo06;

public class Demo01 {
    public static void main(String[] args) {
        //类型转换：装箱，基本类型转成引用类型的过程
        //基本类型
        int num1 = 18;
        //使用Integer类创建对象
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("装箱");
        System.out.println(integer1);
        System.out.println(integer2);


        //类型转换：拆箱，引用类型转成基本类型
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println("拆箱");
        System.out.println(num2);
        //以上方式在jdk1.5之前使用

        //jdk1.5之后，提供了自动装箱和拆箱
        int age = 30;
        //自动装箱
        Integer integer4 = age;
        System.out.println("自动装箱");
        System.out.println(integer4);
        //自动拆箱
        int age2 = integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);


    }
}

反编译对比代码

Demo01.class

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.cclass.demo06;

public class Demo01 {
    public Demo01() {
    }

    public static void main(String[] args) {
        int num1 = 18;
        Integer integer1 = new Integer(num1);
        Integer integer2 = Integer.valueOf(num1);
        System.out.println("装箱");
        System.out.println(integer1);
        System.out.println(integer2);
        
        Integer integer3 = new Integer(100);
        int num2 = integer3;
        System.out.println("拆箱");
        System.out.println(num2);
        
        int age = 30;
        
        Integer integer4 = Integer.valueOf(age);
        System.out.println("自动装箱");
        System.out.println(integer4);
        
        int age2 = integer4;
        System.out.println("自动拆箱");
        System.out.println(age2);
    }
}

基本类型和字符串转换

parseXXX()静态方法

package com.cclass.demo06;

public class Demo01 {
    public static void main(String[] args) {
        //基本类型和字符串之间转换
        //1.基本类型转成字符串
        int n1 = 100;
        //1.1使用+号
        String s1 = n1+"";
        //1.2使用Integer中的toString()方法
        String s2 = Integer.toString(n1);//radix进制
        System.out.println(s1);//100
        System.out.println(s2);//100

        //2.字符串转成基本类型
        String str = "150";
        //使用Integer.parseXXX();
        int n2 = Integer.parseInt(str);
        System.out.println(n2);//150

        //boolean字符串形式转成基本类型，"true" ---> true  非"true" ---> false
        String str2 = "true";//treu ---> false
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);//true
    }
}

Integer缓冲区

整数缓冲区

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

在实际应用当中，对已创建的对象进行复用。

package com.cclass.demo06;

public class Demo02 {
    public static void main(String[] args) {
        //面试题
        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1==integer2);//引用类型变量integer1、integer2在栈中，
                                              // 对应100、100在堆中，地址不同，所以为false
        Integer integer3=Integer.valueOf(100);//自动装箱Integer integer3=100
        Integer integer4=Integer.valueOf(100);//查看valueof源码，整数缓冲区i落在-127~127之间，地址相同
        System.out.println(integer3==integer4);//true

        Integer integer5=Integer.valueOf(200);//自动装箱Integer integer5=200
        Integer integer6=Integer.valueOf(200);//200超过范围，会new Integer(i),地址不同
        System.out.println(integer5==integer6);//false

    }
}

String概述

字符串是常量，创建之后不可改变。
字符串字面值存储在字符串池中，可以共享。
String s = "Hello";产生一个对象，字符串池中存储。

String s = new String("Hello");//产生两个对象，堆、池各存储一个

package com.cclass.demo06;

public class Demo03 {
    public static void main(String[] args) {
        String name = "大白很白";//"大白很白”常量存储在字符串池中
        name="kazesan";//"kazesan"赋值给name，给字符串赋值时，并没有修改数据，而是重新开辟一个空间
        String name2 = "kazesan";

        //演示字符串的另一种创建方式，new String();
        String str=new String("java");
        String str2=new String("java");
        System.out.println(str==str2);//false
        System.out.println(str.equals(str2));//true

    }
}

常用方法

public int length():返回字符串的长度。
public char charAt(int index):根据下标获取字符。
public boolean contains(String str):判断当前字符串中是否包含str。

package com.cclass.demo06;

public class Demo03 {
    public static void main(String[] args) {
        //字符串方法的使用
        //1. length();返回字符串的长度
        //2. charAt(int index);返回某个位置的字符,下标从0开始
        //3. contain(String str);判断是否包含这个字符串

        String content="java是世界上最好的编程语言";
        System.out.println(content.length());//15
        System.out.println(content.charAt(content.length()-1));//言
        System.out.println(content.contains("java"));//true
        System.out.println(content.contains("php"));//false
    }
}

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

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

package com.cclass.demo06;

import java.util.Arrays;

public class Demo03{
    public static void main(String[] args){
        String content="java是世界上java最好的编程语言,java牛逼";
        //字符串方法的使用
        //4.toCharArray();返回字符串对应的数组
        //5.indexOf();返回字符串首次出现的位置
        //6.lastIndexOf();返回字符串最后一次出现的位置
        System.out.println(Arrays.toString(content.toCharArray()));
        System.out.println(content.indexOf("java"));
        System.out.println(content.indexOf("java",4));
        System.out.println(content.lastIndexOf("java"));
        /*
        [j, a, v, a, 是, 世, 界, 上, j, a, v, a, 最, 好, 的, 编, 程, 语, 言, ,, j, a, v, a, 牛, 逼]
		0
		8
		20
        */
    }
}

public String trim():去掉字符串前后的空格。
public String toUpperCase():将小写转成大写。

public boolean endWith(String str):判断字符串是否以Str结尾。

package com.cclass.demo06;
public class Demo03{
    public static void main(String[] args){
        //7.trim();去掉字符串前后的空格
        //8.toUpperCase;//把小写转换成大写。toLowerCase();把大写转成小写
        //9.endWith(str);判断是否以str结尾，startWith(str);判断是否以str开头

        String content2 = "  hello,world  ";
        System.out.println(content2.trim());//hello,world
        System.out.println(content2.toUpperCase());//HELLO,WORLD
        System.out.println(content2.toLowerCase());//hello,world

        String filename = "hello.java";
        System.out.println(filename.endsWith(".java"));//true
        System.out.println(filename.startsWith("hello"));//true
    }
}

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

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

package com.cclass.demo06;
public class Demo03{
     public static void main(String[] args){
         //10.replace(char oldChar, char newCha); 用新的字符或字符串替换旧的字符或字符串
        //11.split();对字符串进行拆分

        System.out.println(content.replace("java","php"));

        String say = "java is the best programing language,java xiang";
        String[] arr = say.split("[ ,]+");//[]表示选择，+表示出现一个或多个
        System.out.println(arr.length);
        for(String String : arr){
            System.out.println(String);
        }

        System.out.println("------------------------------------------");
        //补充两个方法equals、compareTo();比较大小 编码表里的位置
        String s1 = "hello";
        String s2 = "HELLO";
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true,忽略大小写的比较

        String s3 = "abc";//a:97
        String s4 = "xyz";//x:120
        System.out.println(s3.compareTo(s4));//-23

        String s5 = "abc";
        String s6= "abcxyz";
        System.out.println(s5.compareTo(s6));//-3,比较长度
     }
}

String案例

需求：
- 已知String str = "this is a text";
- 1. 将str中的单词单独获取出来
  2. 将str中的text替换为practice
  3. 在text前面插入一个easy
  4. 将每个单词的首字母改为大写

package com.cclass.demo06;

/*
 已知String str = "this is a text";
  1. 将str中的单词单独获取出来
  2. 将str中的text替换为practice
  3. 在text前面插入一个easy
  4. 将每个单词的首字母改为大写
 */
public class demo04 {
    public static void main(String[] args){
        String str = "this is a text";
        // 1. 将str中的单词单独获取出来
        String[] arr=str.split(" ");
        System.out.println("---------- 1. 将str中的单词单独获取出来--------------");
        for (String s : arr){
            System.out.println(s);
        }
        //2. 将str中的text替换为practice
        System.out.println("---------- 2. 将str中的text替换为practice--------------");
        String str2=str.replace("text","practice");
        System.out.println(str2);
        //3. 在text前面插入一个easy
        System.out.println("---------- 3. 在text前面插入一个easy--------------");
        String str3=str.replace("text","easy text");
        System.out.println(str3);
        //4. 将每个单词的首字母改为大写
        System.out.println("---------- 4. 将每个单词的首字母改为大写--------------");
        for (int i=0;i<arr.length;i++){
            char first=arr[i].charAt(0);
            //把第一个字母转成大写
            char upperfirst=Character.toUpperCase(first);
            String news=upperfirst+arr[i].substring(1);//substring截取
            System.out.println(news);

        }
    }
}

可变字符串

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

package com.cclass.demo06;

/**
 * StringBuffer和StringBuilder的使用
 * 和String的区别 (1)效率比String高 (2)比String节省内存
 * @author 大白很白
 */
public class demo05 {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();//或者StringBuilder sb = StringBuilder()
        //1.append();追加
        sb.append("java世界第一");//java世界第一
        System.out.println(sb.toString());
        sb.append("java真香");
        System.out.println(sb.toString());//java世界第一java真香
        sb.append("java不错");
        System.out.println(sb.toString());//java世界第一java真香java不错

        //2.insert();添加
        sb.insert(0,"我在最前面");
        System.out.println(sb.toString());//我在最前面java世界第一java真香java不错

        //3.replace();替换
        sb.replace(0,5,"hello");
        System.out.println(sb.toString());//hellojava世界第一java真香java不错

        //4.delete();删除
        sb.delete(0,5);
        System.out.println(sb.toString());//java世界第一java真香java不错

        //清空
        sb.delete(0,sb.length());
        System.out.println(sb.toString());//空白，sb.length();//0

    }
}

String和StringBuilder对比

package com.cclass.demo06;

/**
 *  验证StringBuilder效率高于String，也高于StringBuffer
 * @大白很白
 */
public class demo06 {
    public static void main(String[] args) {
        //开始时间
        long start = System.currentTimeMillis();
//       String string="";
//        for (int i=0;i<99999;i++){
//            string+=i;
//        }
//        System.out.println(string);
        StringBuilder sb=new StringBuilder();
        for (int i=0;i<99999;i++){
            sb.append(i);
        }
        //结束时间
        long end=System.currentTimeMillis();
        System.out.println("用时："+(end-start));//String用时：20386
                                                // StringBuilder用时：16

    }
}

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) 除
进行除法运算时，如果不能准确的计算出结果时需要指定保留的位数和取舍方式。
除法：divide(BigDecimal bd,int scale,RoundingMode mode)
参数scale：指定精确到小数点后几位。

参数mode：

指定小数部分的取舍模式，通常采用四舍五入的模式，
取值为BigDecimal.ROUND_HALF_UP。

package com.cclass.demo06;

import java.math.BigDecimal;

public class demo07 {
    public static void main(String[] args) {
        double d1 = 1.0;
        double d2 = 0.9;
        System.out.println(d1-d2);//0.09999999999999998
        /*
        很多实际应用中需要精确运算，而double是近似值存储，不在符合要求，
        需要借助BigDecimal
         */

        BigDecimal bd1 = new BigDecimal("1.0");
        BigDecimal bd2 = new BigDecimal("0.9");
        //减法
        BigDecimal r1=bd1.subtract(bd2);
        System.out.println(r1);//0.1

        //加法
        BigDecimal r2 = bd1.add(bd2);
        System.out.println(r2);//1.9

        //乘法
        BigDecimal r3 = bd1.multiply(bd2);
        System.out.println(r3);//0.90

        //除法
        BigDecimal r4 = new BigDecimal("1.4")
                .subtract(new BigDecimal("0.5"))
                .divide(new BigDecimal("0.9"));
        System.out.println(r4);//1

        BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);//四舍五入
        System.out.println(r5);//3.33


    }
}

Date类

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

时间单位

1秒=1000毫秒
1毫秒=1000微秒
1微秒=1000纳秒（毫微秒）

package com.cclass.demo06;

import java.util.Date;

public class demo08 {
    public static void main(String[] args) {
        //1创建Date对象
        //今天
        Date date1 = new Date();
        System.out.println(date1.toString());//Wed May 04 16:53:31 CST 2022
        System.out.println(date1.toLocaleString());//2022-5-4 16:53:31
        //昨天
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());//2022-5-3 16:53:31
        //2方法after before
        boolean b1 = date1.after(date2);
        System.out.println(b1);//true
        boolean b2 = date1.before(date2);
        System.out.println(b2);//false

        //比较compareTo();
        int d = date1.compareTo(date2);
        System.out.println(d);//1
        //比较是否相等equals()
        boolean b3 = date1.equals(date2);
        System.out.println(b3);//false


    }
}

Calendar类

Calendar提供了获取或设置各种日历字段的方法。

package com.cclass.demo06;

import java.util.Date;

public class demo08 {
    public static void main(String[] args) {
        //1创建Date对象
        //今天
        Date date1 = new Date();
        System.out.println(date1.toString());//Wed May 04 16:53:31 CST 2022
        System.out.println(date1.toLocaleString());//2022-5-4 16:53:31
        //昨天
        Date date2 = new Date(date1.getTime()-(60*60*24*1000));
        System.out.println(date2.toLocaleString());//2022-5-3 16:53:31
        //2方法after before
        boolean b1 = date1.after(date2);
        System.out.println(b1);//true
        boolean b2 = date1.before(date2);
        System.out.println(b2);//false

        //比较compareTo();
        int d = date1.compareTo(date2);
        System.out.println(d);//1
        //比较是否相等equals()
        boolean b3 = date1.equals(date2);
        System.out.println(b3);//false


    }
}

构造方法
- protected Calendar()：由于修饰符是protected，所以无法直接创建该对象。
其他方法

package com.cclass.demo06;

import java.util.Calendar;

public class demo09 {
    public static void main(String[] args) {
        //1创建Calendar对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.getTime().toLocaleString());
        System.out.println(calendar.getTimeInMillis());
        //2获取时间信息
        //获取年
        int year = calendar.get(calendar.YEAR);
        //获取月
        int month = calendar.get(Calendar.MONTH);
        //获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);//or Date
        //获取小时
        int hour = calendar.get(Calendar.HOUR);//HOUR 12小时制， HOUR_OF_DAY 24小时制
        //分钟
        int minute = calendar.get(Calendar.MINUTE);
        //秒
        int second = calendar.get(Calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);//国外月份从0开始
        //3修改时间
        Calendar calendar2 = Calendar.getInstance();
        calendar2.set(calendar.DAY_OF_MONTH,3);
        System.out.println(calendar2.getTime().toLocaleString());//2022-5-3 18:01:55

        //4add方法修改时间
        calendar2.add(Calendar.HOUR,1);
        System.out.println(calendar2.getTime().toLocaleString());//2022-5-3 19:03:23

        //5补充方法
        int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max);//31
        System.out.println(min);//1


    }
}

SimpleDateFormat类

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

package com.cclass.demo06;

import java.text.SimpleDateFormat;
import java.util.Date;

public class demo10 {
    public static void main(String[] args) throws Exception{
        //1创建SimpleDateFormat对象 y 年 M 月 d 日
        //SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        //2创建Date
        Date date = new Date();
        //格式化date（把日期转成字符串）
        String str=sdf.format(date);
        System.out.println(str);
        //解析（把字符串转成日期）
        Date date2 = sdf.parse("1990/05/01");//后面格式需统一，以后学，先抛出异常
        System.out.println(date2);
    }
}

System类

System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。

package com.cclass.demo06;

public class demo11 {
    public static void main(String[] args) {
        //arraycopy:数组的复制
        //src：源数组
        //srcPos：从哪个位置开始复制0
        //dest:目标数组
        //destPos：目标数组的位置
        //length:复制的长度
        int[] arr={20,18,15,8,35,26,45,90};
        int[] dest=new int[8];
        System.arraycopy(arr,0,dest,0,arr.length);

        for (int i=0;i<dest.length;i++){
            System.out.print(dest[i]+" ");//20 18 15 8 35 26 45 90
        }
        //Arrays.copyOf(original, newLength);//看源码，使用的System.arraycopy

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

        long start=System.currentTimeMillis();
        for (int i=0;i<99999;i++){
            for (int j=0;j<99999;j++){
                int result=i+j;
            }
        }
        long end=System.currentTimeMillis();
        System.out.println("用时:"+(end-start));//用时:13

        //System.gc();告诉垃圾回收器回收

        //4推出JVM
        System.exit(0);
        System.out.println("程序结束了");


    }
}

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

Java教程

常用类

Object类

getClass()方法

hashCode()方法

toString()方法

equals()方法

finalize()方法

包装类

类型转换与装箱、拆箱

基本类型和字符串转换

Integer缓冲区

String概述

常用方法

String案例

可变字符串

BigDecimal的使用

Date类

Calendar类

SimpleDateFormat类

System类

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯