java核心类库（一） 常用类

最新推荐文章于 2024-06-19 23:43:56 发布
最新推荐文章于 2024-06-19 23:43:56 发布
阅读量770 收藏 3
点赞数
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43835305/article/details/108205718
版权

一、常用类的概述和使用

1.1 API的使用和常用包的概述

  • 查找：模块 -> 包 -> 类
  • 搜索

包的名称和功能

  • Java.lang包 - 该包是Java语言的核心包，并且该包中的所有内容由JVM自动导入
    如：System类、String类、…
  • java.util包 - 该包是Java语言的工具包，里面提供了大量工具类以及集合类等（包含集合框架，一些国际化支持类，服务加载器，属性，随机数生成，字符串解析和扫描类，base64编码和解码，位数组和几个其他实用程序类。 ）
    如：Scanner类、Random类、List集合、…
  • java.io包 - 该包是Java语言中的输入输出包，里面提供了大量读写文件相关的类等（通过数据流，序列化和文件系统提供系统输入和输出）
    如：FileInputStream类、FileOutputStream类、…
  • java.net包 - 该包是Java语言中的网络包，里面提供了大量网络编程相关的类等
    如：ServerSocket类、Socket类、…
  • java.sql 包 - 该包是Java语言中的数据包，里面提供了大量操作数据库的类和接口等。
    如：DriverManager类、Connection接口、…
  • … …
  • Java程序员在编程时可以使用大量类库，因此Java编程时需要记的很多，对编程能力本身要求不是
    特别的高

1.2 Object类的概述（重点）

基本概念

  • java.lang.Object类是Java语言中类层次结构的根类，也就是说任何一个类都是该类的直接或者间
    接子类
  • 如果定义一个Java类时没有使用extends关键字声明其父类，则其父类为 java.lang.Object 类
  • Object类定义了对象的基本行为, 被子类默认继承

常用的方法

方法声明功能介绍
Object()使用无参方式构造对象
boolean equals(Object obj)
（重点）		用于判断调用对象是否与参数对象相等。
该方法默认比较两个对象的地址是否相等，与 == 运算符的结果一致
若希望比较两个对象的内容，则需要重写该方法
若该方法被重写后，则应该重写hashCode方法来保证结果的一致性
int hashCode()用于获取调用对象的哈希码值(内存地址的编号)
若两个对象调用equals方法相等，则各自调用该方法的结果必须相同
若两个调用对象equals方法不相等，则各自调用该方法的结果应该不相同
为了使得该方法与equals方法保持一致，需要重写该方法
String toString()用于获取调用对象的字符串形式
该方法默认返回的字符串为：包名.类名@哈希码值的十六进制
为了返回更有意义的数据，需要重写该方法
使用print或println打印引用或 字符串拼接 *引用变量* 都会自动调用该方法
equals的使用
public class Student extends Object {
    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) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

public class StudentTest {

    public static void main(String[] args) {

        // 使用有参方式构造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
        System.out.println(s1 == s2); // false

    }
}
equals方法的重写实现
public class Student extends Object {
    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) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    /**
     * 为了比较两个对象的学号信息，需要重写equals方法
     */
    // Student this = s1;
    // Object obj = s2;
    @Override
    public boolean equals(Object obj) {
        // 父类对象obj要强转，才能调用子类对象s2中的独有方法getId()
        //return this.getId() == obj.getId();
        // 判断obj指向的对象是否为Student类型的对象，是则条件成立，否则不成立
        if(obj instanceof Student) {
            Student st = (Student)obj;
            return st.getId() == this.getId();
        }
        // 否则类型不一致没有可比性，则内容一定不相同
        return false;
    }
}

public class StudentTest {

    public static void main(String[] args) {

        // 使用有参方式构造Student类型的两个对象并判断是否相等
        Student s1 = new Student(1001, "zhangfei");
        Student s2 = new Student(1001, "guanyu");
        // Student s2 = s1; // 表示s2和s1表示了同一个对象
        // 下面调用从Object类中继承下来并重写的equals方法，该方法比较两个对象的内容
        boolean b1 = s1.equals(s2);
        System.out.println("b1 = " + b1); // true 比较内容
        System.out.println(s1 == s2); // false 比较地址
    }
}

equals方法执行原理图

equals方法的重写优化
public class Student extends Object {
    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) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    /**
     * 为了比较两个对象的学号信息，需要重写equals方法
     */
    // Student this = s1;
    // Object obj = s2;
    @Override
    public boolean equals(Object obj) {
        // 当调用对象和参数对象为同一个对象时，则内容一定相同
        if(this == obj) return true;
        // 当调用对象不为空而参数对象为空时，则内容一定不相同
        if(null == obj) return false;
        // 父类对象obj要强转，才能调用子类对象s2中的独有方法getId()
        //return this.getId() == obj.getId();
        // 判断obj指向的对象是否为Student类型的对象，是则条件成立，否则不成立
        if(obj instanceof Student) {
            Student st = (Student)obj;
            return st.getId() == this.getId();
        }
        // 否则类型不一致没有可比性，则内容一定不相同
        return false;
    }
}

public class StudentTest {

    public static void main(String[] args) {

        // 使用有参方式构造Student类型的两个对象并判断是否相等
        Student s1 = new Student(1001, "zhangfei");
        Student s2 = new Student(1001, "guanyu");
        // Student s2 = s1; // 表示s2和s1表示了同一个对象
        // 下面调用从Object类中继承下来的equals方法，该方法默认比较两个对象的地址
        //boolean b1 = s1.equals(s2);
        Student s3 = null;
        boolean b1 = s1.equals(s3);
        boolean b2 = s1.equals(s1);
        //System.out.println("b1 = " + b1); // false
        System.out.println(s1 == s3); // false
        System.out.println("b2 = " + b2); // true
    }
}
hasCode()方法重写
public class Student extends Object {
    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) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    /**
     * 为了比较两个对象的学号信息，需要重写equals方法
     */
    // Student this = s1;
    // Object obj = s2;
    @Override
    public boolean equals(Object obj) {
        // 当调用对象和参数对象为同一个对象时，则内容一定相同
        if(this == obj) return true;
        // 当调用对象不为空而参数对象为空时，则内容一定不相同
        if(null == obj) return false;
        // 父类对象obj要强转，才能调用子类对象s2中的独有方法getId()
        //return this.getId() == obj.getId();
        // 判断obj指向的对象是否为Student类型的对象，是则条件成立，否则不成立
        if(obj instanceof Student) {
            Student st = (Student)obj;
            return st.getId() == this.getId();
        }
        // 否则类型不一致没有可比性，则内容一定不相同
        return false;
    }

    /**
     * 为了使得该方法的结果与equals方法的结果保持一致，从而满足Java官方的常规协定，需要重写该方法
     */
    @Override
    public int hashCode() {
        //return getId(); // 不再代表内存地址的编号
        final int type = 12;
        return type*31 + getId(); // 随便怎么写，只要依赖于学号就可以了
    }
}

public class StudentTest {

    public static void main(String[] args) {

        // 使用有参方式构造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);
        //Student s3 = null;
        boolean b1 = s1.equals(s2);
        //boolean b2 = s1.equals(s1);
        System.out.println("b1 = " + b1);
        //System.out.println(s1 == s3); // false
        //System.out.println("b2 = " + b2); // true

        System.out.println("--------------------------------");
        // 下面调用从Object类中继承下来的hashCode方法，获取调用对象的哈希码值(内存地址的编号)
        int ia = s1.hashCode();
        int ib = s2.hashCode();
        System.out.println("ia = " + ia);
        System.out.println("ib = " + ib);
    }
}
toString()方法重写
public class Student extends Object {
    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) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    /**
     * 为了比较两个对象的学号信息，需要重写equals方法
     */
    // Student this = s1;
    // Object obj = s2;
    @Override
    public boolean equals(Object obj) {
        // 当调用对象和参数对象为同一个对象时，则内容一定相同
        if(this == obj) return true;
        // 当调用对象不为空而参数对象为空时，则内容一定不相同
        if(null == obj) return false;
        // 父类对象obj要强转，才能调用子类对象s2中的独有方法getId()
        //return this.getId() == obj.getId();
        // 判断obj指向的对象是否为Student类型的对象，是则条件成立，否则不成立
        if(obj instanceof Student) {
            Student st = (Student)obj;
            return st.getId() == this.getId();
        }
        // 否则类型不一致没有可比性，则内容一定不相同
        return false;
    }

    /**
     * 为了使得该方法的结果与equals方法的结果保持一致，从而满足Java官方的常规协定，需要重写该方法
     */
    @Override
    public int hashCode() {
        //return getId(); // 不再代表内存地址的编号
        final int type = 12;
        return type*31 + getId(); // 随便怎么写，只要依赖于学号就可以了
    }

    /**
     * 为了返回更有意义的字符串数据，需要重写该方法
     */
    @Override
    public String toString() {
        return "Student[id = " + getId() + ", name = " + getName() + "]";
    }
}

public class StudentTest {

    public static void main(String[] args) {

        // 使用有参方式构造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);
        //Student s3 = null;
        boolean b1 = s1.equals(s2);
        //boolean b2 = s1.equals(s1);
        System.out.println("b1 = " + b1);
        //System.out.println(s1 == s3); // false
        //System.out.println("b2 = " + b2); // 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("------------------------------");
        // 下面调用从Object类中继承下来的toString方法，获取调用对象的字符串形式：包名.类名@哈希码值的十六进制
        String str1 = s1.toString();
        // 重写toString方法前：com.lagou.task11.Student@55d
        // 重写toString方法后：str1 = Student[id = 1001, name = zhangfei]
        System.out.println("str1 = " + str1);
        // 打印一个引用变量时会自动调用toString方法
        System.out.println(s1); // Student[id = 1001, name = zhangfei]
        // 使用字符串拼接时会自动调用toString方法
        String str2 = "hello" + s1;
        System.out.println("str2 = " + str2); // str2 = helloStudent[id = 1001, name = zhangfei]
    }
}
案例扩展
  • 上述例子是以学号作为基准判断两个对象是否相等。那么如何实现以姓名作为基准来判断两个对象是否相等？以及以学号和姓名同时作为基准来判断两个对象是否相等？
  • 姓名作为基准
public class Student extends Object {
    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) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    /**
     * 为了比较两个对象的学号信息，需要重写equals方法
     */
    // Student this = s1;
    // Object obj = s2;
    @Override
    public boolean equals(Object obj) {
        // 当调用对象和参数对象为同一个对象时，则内容一定相同
        if(this == obj) return true;
        // 当调用对象不为空而参数对象为空时，则内容一定不相同
        if(null == obj) return false;
        // 父类对象obj要强转，才能调用子类对象s2中的独有方法getId()
        //return this.getId() == obj.getId();
        // 判断obj指向的对象是否为Student类型的对象，是则条件成立，否则不成立
        if(obj instanceof Student) {
            Student st = (Student)obj;
            // 以学号作为基准判断两个对象是否相同 学号int是基本数据类型，栈区内存空间中存放数据本身
            // 使用 == 可以判断数据是否相同
            //return st.getId() == this.getId();
            // 以姓名作为基准判断两个对象是否相同，姓名String类型，为引用数据类型，栈区内存空间中放的是地址
            // 使用 == 判断地址是否相同
            // 也就是判断两个对象中姓名字符串的地址是否相同，不够完美
            //return this.getName() == st.getName();
            // 这里this.getName()是String类型，因此调用的equals方法是String类重写后的equals方法(Java官方帮写好了)
            return this.getName().equals(st.getName());
        }
        // 否则类型不一致没有可比性，则内容一定不相同
        return false;
    }

    /**
     * 为了使得该方法的结果与equals方法的结果保持一致，从而满足Java官方的常规协定，需要重写该方法
     */
    @Override
    public int hashCode() {
        //return getId(); // 不再代表内存地址的编号
        final int type = 12;
        //return type*31 + getId(); // 随便怎么写，只要依赖于学号就可以了
        // 因为String类重写了equals方法，因此它也会重写hashCode方法，来保证一致性，可以直接调用
        return type*31 + getName().hashCode();
    }

    /**
     * 为了返回更有意义的字符串数据，需要重写该方法
     */
    @Override
    public String toString() {
        return "Student[id = " + getId() + ", name = " + getName() + "]";
    }
}

public class StudentTest {

    public static void main(String[] args) {

        // 使用有参方式构造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);
        //Student s3 = null;
        boolean b1 = s1.equals(s2);
        //boolean b2 = s1.equals(s1);
        System.out.println("b1 = " + b1);
        //System.out.println(s1 == s3); // false
        //System.out.println("b2 = " + b2); // 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("------------------------------");
        // 下面调用从Object类中继承下来的toString方法，获取调用对象的字符串形式：包名.类名@哈希码值的十六进制
        String str1 = s1.toString();
        // 重写toString方法前：com.lagou.task11.Student@55d
        // 重写toString方法后：str1 = Student[id = 1001, name = zhangfei]
        System.out.println("str1 = " + str1);
        // 打印一个引用变量时会自动调用toString方法
        System.out.println(s1); // Student[id = 1001, name = zhangfei]
        // 使用字符串拼接时会自动调用toString方法
        String str2 = "hello" + s1;
        System.out.println("str2 = " + str2); // str2 = helloStudent[id = 1001, name = zhangfei]
    }
}
  • equals方法和hashCode方法的生成
    在IDEA里可以直接生成
    在平时开发中可以直接生成
    但是遇到笔试题要知道怎么改写

1.3 包装类

包装类概念

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

包装类分类

包装类对应类型
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 TYPE表示int类型的Class实例
常用方法
方法声明功能介绍
Integer(int value)根据参数指定的整数来构造对象（已过时）
Integer(String s)根据参数指定的字符串来构造对象 （已过时）
int intValue()获取调用对象中的整数值并返回
static Integer valueOf(int i)根据参数指定整数值得到Integer类型对象
boolean equals(Object obj)比较调用对象与参数指定的对象是否相等
String toString()返回描述调用对象数值的字符串形式
static int parseInt(String s)将字符串类型转换为int类型并返回
static String toString(int i)获取参数指定整数的十进制字符串形式
static String toBinaryString(int i)获取参数指定整数的二进制字符串形式
static String toHexString(int i)获取参数指定整数的十六进制字符串形式
static String toOctalString(int i)获取参数指定整数的八进制字符串形式

使用案例

public class IntegerTest {

    public static void main(String[] args) {

        // 1.打印Integer类中常用的常用数值
        System.out.println("最大值是：" + Integer.MAX_VALUE); // -2^31
        System.out.println("最大值是：" + Integer.MIN_VALUE); // 2^31-1
        System.out.println("所表示的二进制位数是：" + Integer.SIZE); // 32
        System.out.println("所占字节的个数是：" + Integer.BYTES); // 4
        System.out.println("对应int类型的Class实例是：" + Integer.TYPE); // int

        // 2.使用构造方法来构造Integer类型的对象并引用
        //Integer it1 = new Integer(123);
        //System.out.println("it1 = " + it1); // 自动调用toString方法 123
        Integer it2 = new Integer("456");
        //System.out.println("it2 = " + it2); // 自动调用toString方法 456
        // 上述方法已过时，建议使用valueOf方法取代之
        // int --> Integer
        Integer it3 = Integer.valueOf(123);
        System.out.println("it3 = " + it3); // 456
        // String --> Integer
        Integer it4 = Integer.valueOf("456");
        System.out.println("it4 = " + it4); // 456，此处自动调用toString方法，得到的是String类型
        // 获取调用对象中的整数数值，相当于从Integer类型转换到int类型
        int ia = it4.intValue();
        System.out.println("获取到的整数数据是：" + ia); // 456，得到的是int类型
    }
}
装箱和拆箱机制（笔试题）
  • 装箱：从基本数据类型(如int类型)到包装类(如Integer类型)的转换
  • 拆箱：从包装类(如Integer类型)到i基本数据类型(如int类型)的转换
    在Java5之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作：即运算前将包装类对象拆分为基本数据类型，运算后再将结果封装成包装类对象
    从Java5开始增加了自动拆箱和自动装箱的功能
  • 自动装箱池（笔试）
    在Integer类的内部提供了自动装箱技术，将 -128到127之间的整数(可以根据需要进行范围调整)已经装箱完毕，当程序中使用该范围内的整数时，无需装箱直接取用自动装箱池中的对象即可，从而提高效率
public class IntegerTest {

    public static void main(String[] args) {

        // 1.打印Integer类中常用的常用数值
        System.out.println("最大值是：" + Integer.MAX_VALUE); // -2^31
        System.out.println("最大值是：" + Integer.MIN_VALUE); // 2^31-1
        System.out.println("所表示的二进制位数是：" + Integer.SIZE); // 32
        System.out.println("所占字节的个数是：" + Integer.BYTES); // 4
        System.out.println("对应int类型的Class实例是：" + Integer.TYPE); // 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); // 自动调用toString方法 456
        // 上述方法已过时，建议使用valueOf方法取代之，相当于从int类型到Integer类型的转换，叫做装箱
        // int --> Integer
        Integer it3 = Integer.valueOf(123);
        System.out.println("it3 = " + it3); // 456
        // String --> Integer
        Integer it4 = Integer.valueOf("456");
        System.out.println("it4 = " + it4); // 456，此处自动调用toString方法，得到的是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 = 128;
        Integer it7 = 128;
        Integer it8 = new Integer(128);
        Integer it9 = new Integer(128);
        System.out.println(it6 == it7);         // 比较地址，false
        System.out.println(it6.equals(it7));    // 比较内容，true
        System.out.println(it8 == it9);         // 比较地址，false
        System.out.println(it8.equals(it9));    // 比较内容，true*/
        Integer it6 = 127;
        Integer it7 = 127;
        Integer it8 = new Integer(127);
        Integer it9 = new Integer(127);
        System.out.println(it6 == it7);         // 比较地址，true，受自动装箱池技术的影响
        System.out.println(it6.equals(it7));    // 比较内容，true
        System.out.println(it8 == it9);         // 比较地址，false
        System.out.println(it8.equals(it9));    // 比较内容，true
    }
}


// 实现静态方法的调用
int a = Integer.parseInt("200");	// 200
int b = Integer.parseInt("200a");  // 编译OK，运行发生NumberFormatException数字格式异常，因为有字母
int c = Integer.toBinaryString(200); // 1100 1000
int d = Integer.toString(200); // 200
int e = Integer.toOctalString(200); // 810
int f = Integer.toHexString(); // c8

Double类的概述

基本概念

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

常用常量
常量类型和名称功能介绍
public static final int SIZE表示double类型采用二进制补码形式的位数
public static final int BYTES表示double类型所占的字节个数
public static final Class TYPE表示double类型的Class实例
常用方法
方法声明功能介绍
Double(double value)根据参数指定的浮点数来构造对象（已过时）
Double(String s)根据参数指定的字符串来构造对象 （已过时）
double doubleValue()获取调用对象中的浮点数据并返回
static Double valueOf(int i)根据参数指定整数值得到Double类型对象
boolean equals(Object obj)比较调用对象与参数指定的对象是否相等
String toString()返回描述调用对象数值的字符串形式
static double parseDouble(String s)将字符串类型转换为Double类型并返回
boolean isNaN()判断调用对象的数值是否为非数字
拓展
  • 从Java5开始，也有自动装箱和自动拆箱
  • 没有自动装箱池
  • java.lang.Number类是个抽象类，是上述类的父类来描述所有类共有的成员。

Boolean类的概述

基本概念

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

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

Character类的概述

基本概念

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

常用常量
常量类型和名称功能介绍
public static final int SIZE表示char类型二进制位数
public static final int BYTES表示char类型所占的字节个数
public static final Class TYPE表示char类型的Class实例
常用方法
方法声明功能介绍
Character(char value)根据参数指定的字符数据来构造对象（已过时）
char charValue()获取调用对象中的字符数据并返回
static Character valueOf(char c)根据参数指定布尔数值得到Character类型对象
boolean equals(Object obj)比较调用对象与参数指定的对象是否相等
String toString()返回描述调用对象数值的字符串形式
static Boolean isUpperCase(char ch)判断参数指定字符是否为大写字符
static Boolean isLowerCase(char ch)判断参数指定字符是否为小写字符
static Boolean isDigitCase(char ch)判断参数指定字符是否为数字字符
static char isUpperCase(char ch)将参数指定字符转为为大写字符
static char isLowerCase(char ch)将参数指定字符转为小写字符

包装类（Wrapper）的使用总结

  • 基本数据类型转换为对应包装类的方式（装箱） —> 对象层级
    调用包装类的构造方法或静态方法(valueOf方法)即可
  • 获取包装类对象中基本数据类型变量数值的方式（拆箱）–> 类层级
    调用包装类中的xxxValue方法即可
  • 字符串转换为基本数据类型的方式 —> 类层级
    调用包装类中的parseXxx方法即可

1.4 数学处理类

Math类的概述

基本概念

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

常用方法
方法声明功能介绍
static int max(int a, int b)返回两个参数中的最大值
static int min(int a, 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类型加以描述。

（注意区分：java.lang.Math 和 java.math.BigDecimal）

常用方法
方法声明功能介绍
BigDecimal(String val)根据参数指定的字符串来构造对象
BigDecimal add(BigDecimal augend)用于实现加法运算
BigDecimal subtract(BigDecimal subtrahend)用于实现减法运算
BigDecimal multiply(BigDecimal multiplicand)用于实现乘法运算
BigDecimal divide(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.5
        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("---------------------------------------------------------------");
        // 3.实现精确运算
        System.out.println(0.1 + 0.2); // 0.30000000000000004
        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 divide(BigInteger val)用于实现除法运算
BigInteger remainder(BigInteger val)用于实现取余运算
BigInteger[] divideAndRemainder(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
        }
    }
}

ger 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
        }
    }
}

最后：本内容为个人拉勾教育大数据学习课程笔记！

是你得不到的人
关注
专栏目录
Java 常用类库详解
fudaihb的博客
06-18 1091
Java 作为一种广泛使用的编程语言，提供了丰富的类库来支持各种开发需求。这些类库涵盖了从基础的数据结构、网络通信到图形界面、并发编程等各个方面。本文将详细介绍一些在Java开发中常用的类库，帮助开发者更好地理解和使用这些工具来提升开发效率。
JAVA-核心类库
分享，学习，专注，努力，向上。
06-30 1524
Java核心类库是指Java语言提供的一组基础类和接口，用于处理常见的任务和操作，包括字符串处理、集合操作、IO操作、多线程等。熟练掌握Java核心类库的使用，可以提高开发效率和编写高质量的Java应用程序的能力。
java核心类库
zi2242975806的博客
08-04 279
java核心类库 一、泛型 1.概述 泛型，即“参数化类型”。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 使用 泛型类 定义一个泛型类： public class ClassName<T>{ private T data; public T getData() { return data; } public void setData(T d
Java——常用类库
最新发布
2302_79062950的博客
06-19 1566
Collections接口是集合层次框架的跟接口，是存储单一对象的集合(即每个位置保存的是单一的对象)。1、Collections接口有两个直接扩展的子类：List和SetList接口里存放的集合元素是有顺序的、可以重复的，该接口常用的实现类主要有ArrayList、Vector(顺序储存，支持元素的快速访问,但是插入、删除速度慢)，LinkedList(链式储存，元素插入、删除性能好)；
Java核心类库
Goddjc的博客
08-05 1383
记录一下Java比较核心的以及一些常用的类 1.Objects类 所属包 java.utils 1.1 equals(Object a,Object b)) 方法定义public static boolean equals​(Object a, Object b) 如果参数彼此相等，返回true，其他返回false。 因此，如果这两个参数是null ， 返回true，如果只有一个参数为null ，返回false。 举个例子，新建一个Person类，生成他的equals函数 public class Pe
java核心类库中常用类
最爱谭先森的博客
06-16 288
java核心类库中常用类 java常用类 核心类库中 java核心类库中常用类 1.字符串类 字符串对象可以由String类、StringBuffer类和StingBuilder类实现。 1.1 java.lang.String String用于创建字符串对象，并且创建的字符串(对象)不能被改变。 思考：为什么不能被修改？ 解决方式：查看String类的源码。...
学习java开发应该了解的几个常用的基本核心类库
07-18
学习java开发应该了解的几个常用的基本核心类库
java常用类库java常用类库java常用类库
03-26
Java常用类库是Java编程语言的核心组成部分，它们提供了一系列预定义的类和接口，使得开发者可以方便地进行各种常见任务的处理，而无需从零开始编写所有代码。这些类库覆盖了输入输出、网络通信、数据处理、集合框架...
java类库和常用类简介-PPT.ppt
05-15
本篇文章将详细介绍Java的核心类库及其常用类的基本概念和使用方法。 #### 二、Java类库简介 Java类库主要包括以下几个方面： 1. **`java.lang`**：这是由编译器自动引入的基础类库，涵盖了各种基本类型的封装类...
Java -核心类库 Object类常方法 Math类常用方法 System类常用方法 基本类型包装类常用方法等
05-05
### Java核心类库详解 #### 一、Object类常用方法 在Java中，`Object`类是最基础的类，所有其他类都直接或间接继承自它。因此了解并掌握`Object`类的方法对于深入理解Java编程至关重要。 1. **toString() 方法**...
java之学习记录 1 - 4 （java核心类库下）
dear_zx的博客
11-24 411
记录一： 异常机制（重点） 1、基本概念： 异常就是"不正常"的含义，在Java语言中主要指程序执行中发生的不正常情况。 java.lang.Throwable类是Java语言中错误(Error)和异常(Exception)的超类。 其中Error类主要用于描述Java虚拟机无法解决的严重错误，通常无法编码解决，如：JVM挂掉了等。 其中Exception类主要用于描述因编程错误或偶然外在因素导致的轻微错误，通常可以编码解决，如：0作为除数等。 2、异常的分类：
java核心类库使用大全
05-17
PDF格式的java核心类库详解
java的核心类库_Java核心类库，集合框架
weixin_42355399的博客
02-12 279
Java集合框架的由来：Java最初版本只为最常用的数据结构提供了很少的一组类：比如Vector、Stack、Hashtable、BitSet、Enumerrationr接品，其中Enumerrationr接口提供了一种用于访问任意容器中各个元素的抽象机制。这是一种很明智的选择，但要想建立一个全面的集合类库还需要大量的时间和高超的技能。随着Java SE 1.2的问世，设计人员感到是推出一组功能完...
Java核心类库(一)
m0_37852301的博客
08-19 1305
常用类的概述和使用 在线api https://docs.oracle.com/en/java/javase/11/docs/api/index.html 常用的包 java.lang包 - 该包是Java语言的核心包，并且该包中的所有内容由Java虚拟机自动导入。 如：System类、String类、… java.util包 - 该包是Java语言的工具包，里面提供了大量工具类以及集合类等。 如：Scanner类、Random类、List集合、… java.io包 - 该包是Java语言中的输入输出包，
Java核心类库之（常用API、字符串类、集合类、泛型）
热门推荐
努力让自己发光，对的人才能迎着光而来
07-15 2万+
Java核心类库之（常用API、字符串类、集合类、泛型）
核心类库
fire1192的博客
06-17 194
封装类 基本类型的封装类 除了int 类型的封装类 Integer，char 类型的封装类Character其他类型的封装类都是其类型首字母大写；这些对应的类都是引用数据类型； 封装类还可以实现基本类型变量和字符串之间的转换，将该字符串的值转化为基本类型的值又两种方式： 直接利用封装类的构造方法，即Xxx(String s)的构造方法； 调用封装类提供的 封装类.parseXxx(String s) 静态方法； 基本类型转化为字符串有三种方法： 直接使用一个空字符来连接即可，如：“”+123； 调用封装类
Java的核心类库
weidl001的博客
06-13 1340
方法描述示例length()返回字符串的长度将指定字符串连接到此字符串的末尾");比较此字符串与指定对象是否相等");返回一个新字符串，它是此字符串的一个子字符串将匹配的字符或字符串替换为新字符或字符串将所有字符转换为大写将所有字符转换为小写trim()去除字符串两端的空格str.trim();返回指定索引处的字符返回子字符串第一次出现的索引，如果没有找到则返回-1接口实现类特点示例List有序集合，允许重复元素Set无序集合，不允许重复元素Map。
Java常用类库详解与核心类介绍
"Java类库包含了Java编程中常用的类，这些类分布在不同的包下，提供了各种功能，如创建用户界面、处理数据输入输出、网络通信、安全、数据库访问等。对于初学者而言，理解并掌握这些类库是学习Java的重要步骤。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值