JAVA核心类库--1、常用类的概述和使用

1、常用得包

1.1、包得名称和功能

• java.lang包，该包是JAVA语言得核心包，并且该包中得所有内容由JAVA虚拟机自动导入

=》如：System类，String类。。。

• java.util包，该包是java语言得工具包，里面提供了大量工具类以及集合类

=》如：Scanner类，Random类，List集合

• java.io包，该包是JAVA语言中得输入输出包，里面提供了大量读写文件相关得类

=》如：File'InputStream类，File'OutputStream类

• java.net包，该包是JAVA语言中得网络包，里面提供了大量网络编程相关得类

=》如：ServerSocket类，Socket类

• java.sql包，该包是JAVA语言中得数据包，里面提供了大量操作数据库得类和接口

=》如：DriverManager类，Connection接口

---

1.2、Object类得概述

1.2.1、基本概念

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

1.2.2、常用得方法

方法声明	功能介绍
Object()	使用无参方式构造对象
boolean equals(Object obj)	用于判断调用对象是否与参数对象相等。 该方法默认比较两个对象的地址是否相等，与 == 运算符的结果一致 若希望比较两个对象的内容，则需要重写该方法。 若该方法被重写后，则应该重写hashCode方法来保证结果的一致 性。
int hashCode()	用于获取调用对象的哈希码值(内存地址的编号)。 若两个对象调用equals方法相等，则各自调用该方法的结果必须相 同 若两个调用对象equals方法不相等，则各自调用该方法的结果应该 不相同。 为了使得该方法与equals方法保持一致，需要重写该方法。
String toString()	用于获取调用对象的字符串形式 该方法默认返回的字符串为：包名.类名@哈希码值的十六进制 为了返回更有意义的数据，需要重写该方法 使用print或println打印引用或字符串拼接引用都会自动调用该方法
Class getClass()	用于返回调用对象执行时的Class实例，反射机制使用

**
 * @author XiceSberg
 * @date 2020/7/28 22:04
 * @description
 */
public class Student extends Object {
    private String name;
    private int age;

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

    public Student(String name, int age) {
        setName(name);
        setAge(age);
    }
}


/**
 * @author XiceSberg
 * @date 2020/7/28 22:05
 * @description
 */
public class StudentTest {
    public static void main(String[] args) {
        //父类类型的引用指向子类类型的对象形成多态
        Student st=new Student("张飞",33); // 栈区  --》堆区
        Student st2=new Student("关羽",24);// 栈区  --》堆区

        //下面调用从Object类中继承下来的equals方法，该方法默认比较两个对象的地址
        boolean b = st.equals(st2);  //false  这两地址指向不一样
        /**
         * public boolean equals(Object obj) {
         *         return this == obj;
         *     }
         *  this代表正在调用的对象，而这个正在调用的对象此处时st.
         *  obj是形参，obj代表的是实参，此处是st2
         */

        Student st3=st; //st3和st都指向了同一个地址
        boolean b1=st.equals(st3); //true
    }
}

• 当把equals进行重写后，对比学生ID，那么st.equals(st2) 学号相同就为true，而st == st2还是不相等

/**
 * @author XiceSberg
 * @date 2020/7/28 22:04
 * @description
 */
public class Student extends Object {
    private String name;
    private int id;

    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 Student(String name, int id) {
        setName(name);
        setId(id);
    }

    /**
     * 为了比较两个对象的内容，也就是学号信息需要重写
     */
    //Student this = s1;
    //Object obj = s2;
    @Override
    public boolean equals(Object obj){
        //此处obj需要进行Student强制转换才可以做对比
        if(obj instanceof Student)
        {
            Student ts= (Student) obj;
            return this.getId() == ts.getId();
        }
        //类型不一致肯定不相同
        return false;
    }
}


/**
 * @author XiceSberg
 * @date 2020/7/28 22:05
 * @description
 */
public class StudentTest {
    public static void main(String[] args) {
        //父类类型的引用指向子类类型的对象形成多态
        Student st=new Student("张飞",24); // 栈区  --》堆区
        Student st2=new Student("关羽",24);// 栈区  --》堆区

        //下面调用从Object类中继承下来的equals方法，该方法默认比较两个对象的地址
        boolean b = st.equals(st2);  //true
        /**
         * public boolean equals(Object obj) {
         *         return this == obj;
         *     }
         *  this代表正在调用的对象，而这个正在调用的对象此处时st.
         *  obj是形参，obj代表的是实参，此处是st2
         */
        System.out.println(st == st2);  //false

        Student st3=st; //st3和st都指向了同一个地址
        boolean b1=st.equals(st3); //true
    }
}

• 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(y)始终返回true或始终返回false ，前提是未修改对象上的equals比较中使用的信息。

=》对于任何非空的参考值x ， x.equals(null)应该返回false 。

• equals优化重写

    //Student类
    /**
     * 为了比较两个对象的内容，也就是学号信息需要重写
     */
    //Student this = s1;
    //Object obj = s2;
    @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;
            return this.getId() == ts.getId();
        }
        //类型不一致肯定不相同
        return false;
    }

• hashCode

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

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

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

    //main类    
    //下面调用从Object类中继承下来的hashCode方法，获取调用对象的哈希码值(内存地址的编号)
    int ia = st.hashCode();
    int ib = st2.hashCode();
    System.out.println("ia="+ia);  //764977973
    System.out.println("ib="+ib);  //381259350
    //它两不等，但是违背了官网文档中说常规规定，与equals结果不一样

    //Student类
    /**
     * 韦了使得该方法得结果与equals方法得结果保持一致，从而满足官方得常规协定，需要重写方法
     */
    @Override
    public int hashCode(){
        final int type=12; //暂时性得这样写，12和31是随便输入得
        return type*31+getId();
    }

• 注意：下面代码中的注释解析的很清楚，需要理解和记牢

//main类

//下面调用从Object类中继承下来得toStirng方法，获取调用对象对象得字符串形式：包名.类名@哈希码值的十六进制
String str1=st.toString();
System.out.println("str="+str1); //com.task12.Student@195
//当Student类中重写toString方法后，调用重写以后的版本 //Student[id=33,name=张飞]
//当打印一个引用变量时会自动调用toString方法
System.out.println(str1);//Student[id=33,name=张飞]
//当打印一个字符串拼接的时候也会自动调用toString方法
System.out.println("str2="+str1); //str2=Student[id=33,name=张飞]

    //Student类

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

• 用姓名作为基准的重写方法（笔试的时候需要自己写），下面的代码和上面的代码需要牢记

    /**
     * 为了比较两个对象的内容，也就是学号信息需要重写
     */
    //Student this = s1;
    //Object obj = s2;
    @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().equals(ts.getName());
        }
        //类型不一致肯定不相同
        return false;
    }

    /**
     * 韦了使得该方法得结果与equals方法得结果保持一致，从而满足官方得常规协定，需要重写方法
     */
    @Override
    public int hashCode(){
        final int type=12; //暂时性得这样写，12和31是随便输入得
        //return type*31+getId();
        //String继承Object，而String重写了equals，
        // 而官方的规范是equals需要一致性，hashCode也需要一致性，所以String也重写了hashCode
        return type*31+getName().hashCode();
    }

• 开发中不用自己书写，可以采用JDK来生成

//    Generate  选中equals()  and  hashCode() 和 toString()方法进行一键输出

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return id == student.id &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id=" + id +
                '}';
    }

---

1.3、包装类的概念

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

1.3.1、包装类的分类

包装类	对应的基本类型
java.lang.Byte	byte
java.lang.Short	short
java.lang.Integer	int
java.lang.Long	long
java.lang.Float	float
java.lang.Double	double
java.lang.Boolean	boolean
java.lang.Character	char

1.3.2、基础概念

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

1.3.3、常用的常量

常量类型和名称	功能介绍
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实例

1.3.4、常用的方法

方法声明	功能介绍
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)	获取参数指定整数的八进制字符串形式

        System.out.println(Integer.MAX_VALUE); //2147483647
        System.out.println(Integer.MIN_VALUE); //-2147483648
        System.out.println(Integer.SIZE); //32
        System.out.println(Integer.BYTES); //4
        System.out.println(Integer.TYPE); //int

        Integer it1=new Integer(123);
        Integer it2=new Integer("234");
        //上面的方法已经过时，使用下面的方法
        Integer it3=Integer.valueOf(123);
        //相当于String类型的Integer类型的转换
        Integer it4=Integer.valueOf("456");
        //获取调用对象中的整数值，相当于从Integer类型到int类型的转换
        int iaa=it4.intValue();
        System.out.println("iaa="+iaa); //456

1.3.5、装箱和拆箱的概念

• 在Java5发布之前使用包装类对象进行运算时，需要较为繁琐的“拆箱”和“装箱”操作；即运算前先将包装类对象拆分为基本类型数据，运算后再将结果封装成包装类对象。从Java5开始增加了自动拆箱和自动装箱的功能。

        //从JAVA5开始增加了自动装箱和自动拆箱得机制
        Integer it5=100; //直接通过赋值运算符实现自动装箱
        int ib2=it5;     //直接通过赋值运算符实现自动拆箱

        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

1.3.6、自动装箱池

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

        //上面得128，it6和it7为false，是不是很奇怪 
        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

算术异常			ArithmeticException
数组下标越界异常	IndexOutOfBoundsException
空指针异常			NullPointerException
数据类型转换异常	ClassCastException
数字格式异常		NumberFormatException

1.3.7、包装类（Wrapper）的使用总结

• 基本数据类型转换为对应包装类的方式
• 调用包装类的构造方法或静态方法即可
• 获取包装类对象中基本数据类型变量数值的方式
• 调用包装类中的xxxValue方法即可
• 字符串转换为基本数据类型的方式
• 调用包装类中的parseXxx方法即可

1.4、BigInteger类的概念

1.4.1、基本概念

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

1.4.2、常用的方法

方法声明	功能介绍
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)	用于实现取商和余数的运算

1.5、BigDecimal类的概述

1.5.1、基本概念

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

1.5.2、常用的方法同BigInteger

//精确计算，double计算钱的时候会有很小的误差，而BigDecimal是没有误差的
        BigDecimal bd1=new BigDecimal(2);
        BigDecimal bd2=new BigDecimal(0.3);
        //java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
        //System.out.println(bd1.divide(bd2)); 
        System.out.println(bd1.divide(bd2, RoundingMode.HALF_UP)); //四舍五入 为7