Java--常用类

已于 2023-09-04 18:46:50 修改
阅读量104 收藏
点赞数
分类专栏： java 文章标签： java 开发语言
于 2023-07-09 14:23:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56537698/article/details/131365633
版权

目录

Object类

hashCode方法

to String()

包装类

Integer类的概述

装箱和拆箱的概念

自动装箱池

Double类的概述

boolean类型

Character类

包装类（Wrapper）的使用总结

数学处理类

Math类的概述

BigDecimal类的概述

BigInteger类的概念

Object类

定义了“对象”的基本行为，被子类默认继承。

equals方法比较两个对象的地址是否相同。

equals方法在非null对象引用上实现等价关系。

自反性：对于任何非空的参考值X，x.equals(x)应该返回true

对称性：对于任何非空引用值x和y,x.equals(y)应该返回true当且仅当y.equals(x)返回true

传递性：对于任何非空引用值x，y和z,如果x.equals(y)回报true个y.equals(z)回报true,然后x.equals(z)应该返回true.

它是一致的：对于任何非空引用值x和y,多次调用x.equals始终返回true或始终返回false，前提是未修改对象上的equals比较中使用的信息。

对于任何非空的参考值x,x.equals(null)应该返回true.

hashCode方法

返回对象的哈希码值。支持此方法的是散列表，例如HashMap提供的散列表。

hashCode的总合同是：

只要在执行java应用程序期间多次在同一对象上调用它，hashCode方法必须始终返回相同的整数，前提是不修改对象上的equals比较中使用的信息。从应用程序的一次执行到同一应用程序的另一次执行。该整数不需要保持一致。

如果两个对象根据equals(Object)方法相等，则对两个对象中的每个对象调用hashCode方法必须生成相同的整数结果。

这个不是必需的，如果两个对象根据不相等equals(java.lang.obiect)方法，然后调用hashCode,在各两个对象的方法必须产生不同的整数结果，但是程序员应该知道为不等对象生成不同的整数结果可能会提高哈希表的性能。

尽管合理可行，但是类Object定义的hashCode方法确实为不同的对象返回不同的整数。

to String()

用于获取调用对象的字符串形式

该方法默认返回的字符串为：包名.类名.@哈希码值的十六进制

为了返回更有意义的数据，需要重新该方法

使用print或println打印引用或字符串拼接引用都会自动调用该方法

public class Student {
    private int id;//用于描述学号的成员变量
    private String name;//用于描述姓名的成员变量

    public Student() {
    }

    public Student(int id, String name) {
        setId(id);
        setName(name);
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        if (id > 0) {
            this.id = id;
        }   else    {
            System.out.println("输入的学号不合理！！！");
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    /**
     * 为了比较两个对象的内容，重写该方法
     */
    @Override
    public boolean equals(Object obj) {
        //当调用对象和参数对象指向同一个对象时，内容一定相同
        if (this == obj) return true;
        //当调用对象不为空而参数对象为空时，内容一定不相同
        if (null == obj) return false;
        //判断obj指向的对象是否为Student类型的对象，若是则条件成立，否则条件不成立。
        if (obj instanceof Student) {
            Student ts = (Student) obj;
            //以学号作为基准判断两个对象是否相等 int类型时基本数据类型，内存空间中放的就是数据本身，使用==可以判断数据是否相同
            //return this.getId() == ts.getId();
            //以姓名作为基准判断两个对象是否相等 String是引用数据类型，内存空间中放的是地址，使用==判断地址是否相同
            //也就是判断两个对象中姓名字符串的地址是否相同，不构完美。
            //return this.getName() == ts.getName();
            return this.getName().equals(ts.getName());
        }
        //否则类型
        return false;
    }
    /**
     * 为了使得该方法的结果与equals方法的结果保持一致，从而满足java官方的常规协定，需要重写该方法
     * @return
     */

    @Override
    public int hashCode() {
        //return getId(); //不再代表内存地址的编号类
        final int type = 12;
        //return type*31 + getId();
        return type*31 + getName().hashCode();
    }
    /**
     * 为了返回更有意义的字符串数据，则需要重写该方法
     */
    @Override
    public String toString() {
        return "Student[id = " + getId() +",name = " + getName() + "]";
    }
}

public class StudentTest {
    public static void main(String[] args) {

        //1.使用有参方法构造Student类型的对象
        Student s1 = new Student(1001,"zhangfei");
        Student s2 = new Student(1002,"guanyu");
        //Student s2 = s1; 表示s2与s1都指向类同一个对象，地址相同
        //下面调用从Object类中继承下来的equals方法，该方法默认比较两个对象的地址。
        boolean b1 = s1.equals(s2);
        System.out.println("b1 = " + b1);//false  true
        System.out.println(s1 == s2);//比较地址 false  true
        System.out.println("----------------------------");
        //下面调用从Object类中继承下来的hashCode方法，获取调用对象的哈希码值（内存地址的编号）
        //当student类中重写hashCode方法后，则调用重写以后的版本
        int ia = s1.hashCode();
        int ib = s2.hashCode();
        System.out.println("ia = " + ia);
        System.out.println("ib = " + ib);

        System.out.println("------------------------------");
        //下面调用从Objedt类中继承下来的to String方法，获取调用对象的字符串形式：包名.类名.@哈希码值的十六进制
        //当Student类中重写toString方法后，则调用重写以后的版本
        String str1 = s1.toString();
        System.out.println("str1 = " + str1);//str1 = com.lagou.task11.Student@14ae5a5  str1 = Student[id = 1001,name = zhangfei]
        System.out.println(s1);//当打印一个变量时会自动调用toString方法 Student[id = 1001,name = zhangfei]
        String str2 = "hello" + s1;
        System.out.println("str2 = " + str2);//str2 = helloStudent[id = 1001,name = zhangfei]
    }
}

包装类

        通常情况下基本数据类型的变量不是对象，为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象处理的相关类，就叫包装类。

Person p = new Person();

int num = 10;

public class Myint {

private int num = 10;

}

包装类

对应的基本类型

java.lang.Bytebyte
java.lang.Shortshort
java.lang.Integerint
java.lang.Longlong
java.lang.Floatfloat
java.lang.Doubledouble
java.lang.Booleanboolean
java.lang.Characterchar

Integer类的概述

Java.lang.integer类内部包装了一个int类型的变量作为成员变量，主要用于实现对int类型的包装并提供int类型到String类型之间的转换等方法。

常量类型和名称功能介绍
public static final int MAX_VALUE表示int类型可以描述的最大值，即2^31-1
public static final int MIN_VALUE表示int类型可以描述的最小值，即-2^31
public static final int SIZE表示int类型采用二进制补码形式的位数
public static final int BYTES表示int类型所占的字节个数
public static final class<integger>TYPE表示int类型的Class实例
方法声明功能介绍
integer(int value)根据参数指定的整数来构造对象（已过时）
interger(String s)根据参数指定的字符串来构造对象（已过时）
int intValue获取调用对象中的整数值并返回
static Integer valueOf(int)根据参数指定整数值得到integer类型对象
boolean equals(Object obj)比较调用对象与参数指定的对象是否相等
String tiString()返回描述调用对象数值的字符串形式
static int parseint(String s)将字符串类型转换为int类型并返回
static String tiString(int i)获取参数指定整数的十进制字符串形式
static String toBinaryString(int i)获取参数指定整数的二进制字符串形式
static String toHexString(int i)获取参数指定整数的十六进制字符串形式
static String toOctalString(int i)获取参数指定整数的八进制字符串形式

装箱和拆箱的概念

在java5发布之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作；即运算前先将包装类对象拆分为基本类型数据，运算后再将结果封装成包装类对象。

        从Java5开始增加了自动拆箱和自动装箱的功能。

自动装箱池

在Integer类的内部提供了自动装箱池技术，将-128到127之间到整数已经装箱完毕，当程序中使用该范围之间到整数时，无需装箱直接采取自动装箱池中的对象即可，从而提高效率。

public class IntegerTest {
    public static void main(String[] args) {
        //1.打印integer类中常用的常量数值
        System.out.println("最大值是：" + Integer.MAX_VALUE);//2^31-1 最大值是：2147483647
        System.out.println("最小值是：" + Integer.MIN_VALUE);//-2^31 最小值是：-2147483648
        System.out.println("所表示二进制的位数是：" + Integer.SIZE);//所表示二进制的位数是：32
        System.out.println("所占字节个数是：" + Integer.BYTES);//所占字节个数是：4
        System.out.println("对应int类型的Class实例是:" + Integer.TYPE);//对应int类型的Class实例是:int
        System.out.println("----------------------------------------------");
        //2.使用构造方法来构造Integer类型的对象并打印
        Integer it1 = new Integer(123);
        System.out.println("it1 = " + it1);//自动调用toString方法 123
        Integer it2 = new Integer("456");
        System.out.println("it2 = " + it2);//456
        //上述方法已过时建议使用valueof方法，相当于从int类型到Integer类型的转换，叫做装箱。
        Integer it3 = Integer.valueOf(123);
        System.out.println("it3 = " + it3);//123
        Integer it4 = Integer.valueOf("456");
        System.out.println("it4 = " + it4 );//456 自动调用tiString方法得到的是String类型
        //获取调用对象中的整数数值,相当于从Integer类型到int类型的转换，叫做拆箱
        int ia = it4.intValue();
        System.out.println("获取到的整数数据是：" + ia);//456 得到的是int类型
        System.out.println("--------------------------");
        //3.从java5开始增加来自动装箱和自动拆箱的机制
        Integer it5 = 100;//直接通过赋值运算符实现自动装箱
        int ib = it5;     //直接通过赋值运算符实现自动拆箱
        System.out.println("--------------------------");
        //4.装箱和拆箱的笔试考点
        Integer it6 = 127;//128;
        Integer it7 = 127;//128;
        Integer it8 = new Integer(127);//new Integer(128);
        Integer it9 = new Integer(127);//new Integer(128);
        System.out.println(it6 == it7);         //true说明地址一样         //比较地址 false
        System.out.println(it6.equals(it7));    //比较内容 true
        System.out.println(it8 == it9);         //比较地址 false
        System.out.println(it8.equals(it9));    //比较内容 true

        System.out.println("--------------------------");
        //5.实现静态方法的调用
        int ic = Integer.parseInt("200");
        //int ic = Integer.parseInt("200a");//编译OK，运行发生NumberFormatException数字格式异常，因为有字母
        System.out.println("字符串转换为整数的结果是：" + ic);//200
        System.out.println("根据参数指定的整数获取对应的十进制字符串是：" + Integer.toString(200));//根据参数指定的整数获取对应的十进制字符串是：200
        System.out.println("根据参数指定的整数获取对应的二进制字符串是：" + Integer.toBinaryString(200));//根据参数指定的整数获取对应的二进制字符串是：11001000
        System.out.println("根据参数指定的整数获取对应的十六进制字符串是：" + Integer.toHexString(200));//根据参数指定的整数获取对应的十六进制字符串是：c8
        System.out.println("根据参数指定的整数获取对应的十六进制字符串是：" + Integer.toOctalString(200));//根据参数指定的整数获取对应的十六进制字符串是：310
     }

}

Double类的概述

java.lang.double类型内部包装类一个double类型的变量作为成员变量，主要用于实现对double类型的包装并提供double类型到String类型之间的转换等方法。

常用常量

常量类型和名称功能介绍
public static final int SIZE表示double类型的二进制整数
public static final int BYTES表示double类型的字节个数
public static final Class<Double>TYPE表示double类型的Class实例

常用方法 

方法声明功能介绍
Double(double value)根据参数指定的浮点数据来构造对象（已过时）
Double(String)根据参数指定的字符串来构造对象（已过时）
double doubleValue()获取调用对象中的浮点数据并返回
static Double valueOf(double d)根据参数指定浮点数据得到Double类型对象
boolean equals(Object ob)比较调用对象与参数指定对象是否相等
String toString()返回描述调用对象数值的字符串形式
static double parseDouble(String s)将字符串类型转换为double类型并返回
boolean IsNaN()判断调用对象的数值是否为非数字

public class DoubleTest {
    public static void main(String[] args) {

        //1.在Java5之前装箱和拆箱的实现
        //实现来从double类型到Double类型的转换，装箱
        Double db1 = Double.valueOf(3.14);
        System.out.println("db1 = " + db1);//3.14
        //实现来从Double类型到double类型的转换，拆箱
        double d1 = db1.doubleValue();
        System.out.println("d1 = " + d1);//3.14

        System.out.println("-------------------");
        //2.从Java5开始实现自动装箱自动拆箱
        Double db2 = 3.14;
        double d2 = db2;
        System.out.println("-------------------");
        //3. 实现静态方法和成员方法的调用
        double d3 = Double.parseDouble("13.14");
        System.out.println("d3 = " + d3);//13.14

        System.out.println("db2对象的判断结果是：" + db2.isNaN());//false
        Double db3 = Double.valueOf(0/0.0);
        System.out.println(db3);
        System.out.println("db3对象的判断结果是：" + db3.isNaN());//true

    }
}

boolean类型

Java.lang.Boolean类型内部包装了一个boolean类型的变量作为成员变量，主要用于实现对boolean 类型的包装并提供boolean类型到String类之间到转换方法。

常量类型和名称功能介绍
public static final Boolean FALSE对应基值为false的对象
public static final Boolean TRUE对应基值为true的对象
public statuc fianl Class<Boolean>TYPE 表示boolean类型的Class实例
方法声明功能介绍
Boolean(boolean value)根据参数指定的布尔数值构造对象（已过时）
Boolean(String s)根据参数指定的字符串来构造对象（已过时）
boolean booleanValue()获取调用对象的布尔数值并返回
static Boolean valueOf(boolean b)根据参数指定布尔数值得到Boolean类型对象
boolean equals(Obiect obj)比较调用对象与参数指定的对象是否相等
String toString()返回描述调用对象数值的字符串形式
static boolean parseBoolean(String s)将字符串类型转换为boolean类型并返回
public class BooleanTest {
    public static void main(String[] args) {

        //1.在java5之前采用方法进行装箱和拆箱
        //相当于从boolean类型到Boolean类型的转换,装箱
        Boolean bo1 = Boolean.valueOf(true);
        System.out.println("bo1 = " + bo1);//true

        boolean b1 = bo1.booleanValue();
        System.out.println("b1 = " + b1);
        System.out.println("----------------------");
        //2.从Java5开始支持自动装箱拆箱
        Boolean bo2 = false;
        boolean b2 = bo2;
        System.out.println("b2 = " + b2);
        System.out.println("----------------------");
        //3.实现从String类型到boolean类型的转换
        boolean b3 = Boolean.parseBoolean("true");
        System.out.println("b3 = " + b3);
    }
}

Character类

java.lang.Character类型内部包装了一个char类型的变量作为成员变量，主要用于实现对char类型的包装并提供字符类别的判断和转换等方法。

常量类型和名称功能名称
public static final int SIZE表示char类型的二进制位数
public static final int BYTES表示char类型的字节个数
public static final Class<Character>TYPE表示char类型Class实例
方法声明功能介绍
Character(char value)根据参数指定的字符数据来构造对象
char charValue()获取调用对象中的字符数据并返回
static Charcter valueOf(char c)根据参数指定字符数据得到Charcter类型对象
boolean equals(Object obj)比较调用对象与参数指定的对象是否相等
String toString()返回描述调用对象数值的字符串形式
static boolean isUpperCase(char ch)判断参数指定字符是否为大写字符
static boolen isLowerCase(char ch)判断参数指定字符是否为小写字符
satic boolwan isDigit(char ch)判断参数指定字符是否为数字字符
static char toUpperCase(char ch)将参数指定字符转换为大写字符
static char toLowerCase(char ch)将参数指定的字符转换为小写字符
public class CharacterTesr {
    public static void main(String[] args) {
        //1.在Java5之前调用方法实现装箱和拆箱机制
        //相当于从char类型到Character类型的转换，装箱
        Character ca1 = Character.valueOf('a');
        System.out.println("ca1 = " + ca1);
        //从Character到char类型的转换，拆箱
        char c1 = ca1.charValue();
        System.out.println("c1 = " + c1);

        System.out.println("---------------------------");
        //2.从Java5开始自动拆箱和装箱
        Character ca2 = 'b';
        char c2 = ca2;
        System.out.println("c2 = " + c2);

        System.out.println("---------------------");
        //3.实现字符类型的判断以及转换
        System.out.println(Character.isUpperCase(c2));//fase
        System.out.println(Character.isLowerCase(c2));//true
        System.out.println(Character.isDigit(c2));//false
        System.out.println("转换为大写字符是：" + Character.toUpperCase(c2));//B
        System.out.println("转换为小写字符是：" + Character.toLowerCase(c2));//b
    }
}

包装类（Wrapper）的使用总结

基本数据类型转换为对应包装类的方式：调用包装类的构造方法或静态方法即可。

获取包装类对象中基本数据类型变量数值的方式：调用包装类中的***Value方法即可。

字符串转换为基本数据类型的方式：调用包装类中的parse***方法即可。

数学处理类

Math类的概述

Java.lang.Math类主要用于提供执行数学运算的方法：对数、平方根。

方法声明功能介绍
static int max(int a,int b)返回两个参数中的最大值
static int min(ina ,int b)返回两个参数中的最小值
static double pow(double a,double b)返回第一个参数的幂
static int abs(int a)返回参数指定数值的绝对值
static long round(double a)返回参数四舍五入的结果
static double sqrt(double a)返回参数的平方根
static double random()返回0.0到1.0的随机数
/**
 * 编程实现对Math类中常用方法的测试
 */
public class MathTest {
    public static void main(String[] args) {

        System.out.println("获取两个整数中最大值的结果是：" + Math.max(10,20));//20
        System.out.println("获取两个整数中最小值的结果是：" + Math.min(10,20));//10
        System.out.println("获取次方的结果是:" + Math.pow(2,3));//8.0 体现double类型
        System.out.println("获取绝对值的结果是：" + Math.abs(-5));//5
        System.out.println("进行四舍五入的结果是：" + Math.round(3.14));//3
        System.out.println("该整数的平方根是：" + Math.sqrt(16));//4.0
        System.out.println("生产的随机数是：" + Math.random());//随机数
    }
}

BigDecimal类的概述

由于float类型和double类型在运算时可能会有误差，若希望实现精确运算则借助java.math.BigDecimal类型加一描述。

方法声明功能介绍
BigDecimal(String val)根据参数指定的字符串来构造对象
BigDecimal add(BigDecimal augend)用于实现加法运算
BigDecimal subtract(BigDecimal subtrahend)用于实现减法运算
BigDecimal multiply(BigDecimal multiplicand)用于实现乘法运算
BigDecimal dlvide(BigDecimal divisor)用于实现除法运算
import java.math.BigDecimal;
import java.math.RoundingMode;

public class BigDecimalTest {
    public static void main(String[] args) {
        //1.构造BigDecimal类型的两个对象
        BigDecimal bd1 = new BigDecimal("5.2");
        BigDecimal bd2 = new BigDecimal("1.3");
        //2。使用构造完毕的对象实现加减乘除
        System.out.println("实现加法运算的结果是：" + bd1.add(bd2));//6
        System.out.println("实现减法运算的结果是：" + bd1.subtract(bd2));//3.9
        System.out.println("实现乘法运算的结果是：" + bd1.multiply(bd2));//6.76
        System.out.println("实现除法运算的结果是：" + bd1.divide(bd2));//4

        System.out.println("-----------------------");
        System.out.println(0.1+0.2);//0.30000000000000004
        //3.实现精确运算
        BigDecimal bd3 = new BigDecimal("0.1");
        BigDecimal bd4 = new BigDecimal("0.2");
        System.out.println("精确运算的结果是：" + bd3.add(bd4));//精确运算的结果是：0.3

        System.out.println("-----------------------");
        //4.注意事项
        BigDecimal bd5 = new BigDecimal("2");
        BigDecimal bd6 = new BigDecimal("0.3");
        System.out.println("除法运算的结果是：" + bd5.divide(bd6, RoundingMode.HALF_UP));//算术异常 增加四舍五入 除法运算的结果是：7
    }
}

BigInteger类的概念

若希望表示比long类型范围还大的整数数据，则需要借助java.math.BigInteger类型描述。

方法声明功能介绍
BigInteger(String val)根据参数指定的字符串来构造对象
BigInteger add(BigInteger val)

用于实现加法运算

BigInteger subtract(BigInteger val)用于实现减法运算
BigInteger multiply(BigInteger val)用于实现乘法运算
BigInteger dibide(BigInteger val)用于实现除法运算
BigInteger remainder(BigInteger val)用于实现取余运算
BigInteger[] divideAridRemainder(BigInteger val)用于实现取商和余数的运算
import java.math.BigInteger;

public class BigIntegerTest {
    public static void main(String[] args) {
        //1.构造两个BigInteger类型的对象并指定初始值
        BigInteger bi1 = new BigInteger("20");
        BigInteger bi2 = new BigInteger("8");
        //2.实现加减乘除取余操作并打印
        System.out.println("实现加法运算的结果是：" + bi1.add(bi2));//28
        System.out.println("实现减法运算的结果是：" + bi1.subtract(bi2));//12
        System.out.println("实现乘法运算的结果是：" + bi1.multiply(bi2));//160
        System.out.println("实现除法运算的结果是：" + bi1.divide(bi2));//2
        System.out.println("实现取余运算的结果是：" + bi1.remainder(bi2));//4

        System.out.println("----------------------------");
        //3.一次性得到商和余数
        BigInteger[] arr = bi1.divideAndRemainder(bi2);
        for (int i = 0;i < arr.length;i++) {
            System.out.println("下标为：" + i + "的元素是：" + arr[i]);// 2 4 下标为：0的元素是：2下标为：1的元素是：4
        }
    }
}

觉哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值