1.3.1 Object类 equals,hashMode,toString重写, 包装类的装拆箱, 数学处理类

最新推荐文章于 2024-04-06 08:00:00 发布

CH_ENN

最新推荐文章于 2024-04-06 08:00:00 发布

阅读量200

点赞数 2

分类专栏： Java

删除

本文链接：https://blog.csdn.net/chengh1993/article/details/108927342

版权

Java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

&&&&&总结&&&&&

1.常用的包(熟悉)

lang , util , io , net , sql ...

2.Object类(重点)

概念, equals(), hashCode(), toString(), ...

3. 包装类(熟悉)

概念, Integer类, Double类, Boolean类, Character类, ...

4. 常用的数学处理类(熟悉)

Math类, BigDecimal类, BigInteger类,

11. 常用的包(熟悉)

1.1 包的名称和功能

java.lang包,language,核心包,JVM自动导入,如System类,String类...

           java.util包,utility,工具包,工具类集合类,如Scanner类,Random类,List集合...

           java.io包,input,output,输入输出包,读写文件,FileInputStream类,FileOutputSteam类...

           java.net包,网络包,网络编程,ServerSocket类,Socket类...

           java.sql包,数据包,操作数据库,DriverManager类,Connection接口,...

1.2 lang包 Object类（重点）

11.2.1 概念

               类Object是类层次结构的根。每个类都有Object作为超类。
               所有对象（包括数组）都实现此类的方法。

               若定义一个Java类时未声明其父类,则其父类为Object类

               本类定义了"对象"的基本行为,子类默认继承

11.2.2常用方法

11.2.2.1 equals和hashcode

equals方法在非null对象引用上实现等价关系(若为null,则引发空指针异常)

重写equals方法后需要覆盖hashCode方法(两个对象的equals结果为true, 则两个对象的hashCode要相同 )

11.2.2.2 toString

代码: Student类的封装, equals(), hashCode(), toString()方法的重写

package com.lagou.task11;

import java.util.Objects;

/**
 * @author CH
 * @date 2020/9/27 14:43
 * Student类的封装, 方法的重写
 */

//子类可以继承父类的构造方法,私有方法以外的所有方法
public class Student {
    private int id; //描述学号
    private String name; //描述姓名

    public int getId() {
        return id;
    }

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

    public Student() {
    }

    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 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);    //这边调用的是Objects内的方法,方法内已判断空指针
    }

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

    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
/*//11.3//直接生成重写方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (id != student.id) return false;
        return name != null ? name.equals(student.name) : student.name == null; //11.4//该行防止空指针异常
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }*/
/*public boolean equals(Object obj) {       //equals源码
        return (this == obj);
    }*/

    /**
     *  1.为了比较两个对象的内容,也就是学号信息,需要重写该方法
     */
    //this = s1;
    //Object obj = s2;  多态

/*  11.1//
   @Override
    public boolean equals(Object obj) {     //这里面参数this和obj在栈区开内存
       // 3.//当调用对象和参数对象指向同一个对象时,内容一定相同
        if(this == obj) return true;
       // 2.//当调用对象不为空,参数对象为空时,一定不相同
        if(null == obj) return false;           //处理一下比较好
        //判断obj指向的对象是不是Student类型的对象,是则条件成立,否则条件不成立
        if(obj instanceof Student) {
            Student ts = (Student)obj;
            //10.2//以学号为基准判断两个对象是否相等    int是基本数据类型,内存空间中放的就是数据本身,使用 == 可以判断数据是否相同
            //父类中没有getId(),因此要强转为子类
            //10.1//return this.getId() == ts.getId();
            //10.3//以姓名作为基准判断两个对象是否相等, String是引用数据类型,使用 == 是判断地址是否相同
            //10.3//也就是判断两个对象中姓名字符串的地址是否相同,不够完美
            //10.4//return this.getName() == ts.getName();
            return this.getName().equals(ts.getName());     //10.5//比较姓名字符串的内容是否相同
        }
        //否则类型不一致没有可比性,则内容一定不相同
        return false;
    }
*/


    /**
     * 4.为了使得该方法的结果与equals方法的结果一直,从而满足Java官方的常规协定,需要重写该方法
     */
   /* 11.2//
    @Override
    public int hashCode() {
        //8.3//return getId(); //流氓手法,不再代表内存地址的编号了
        int type = 12;      //8.4//用这种手法修改
        //10.6//return type*31 + getId();
        return type * 31 + getName().hashCode();    //10.7//调用的是String类内重写的hashCode方法
    }

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

代码: Student类的测试

package com.lagou.task11;

/**
 * @author CH
 * @date 2020/9/27 14:47
 */
public class StudentTest {

    public static void main(String[] args) {

        //1.//使用有参方式构造Student对象,两个. 并判断是否相等
        Student s1 = new Student(1001,"zhangfei");
        //5.//Student s2 = new Student(1002,"guanyu");
        Student s2 = new Student(1001,"guanyu");
        //3.//Student s2 = s1;  //3.//表示下面的s1和s2都指向同一地址,结果变成true

        //4.//当Student类中重写equals方法后调用重写以后的版本,比较的是内容学号
        //2.//调用继承自父类Object类的方法,默认比较两者地址,可以查看源码验证
        //public boolean equals(Object obj)
        //6.//boolean b1 = s1.equals(s2);
        //7.//Student s3 = null;
        //7.//boolean b1 = s1.equals(s3);
        //8.2//Student s3 = s1;
        //8.2//boolean b1 = s1.equals(s3);
        boolean b1 = s1.equals(s2);
        System.out.println("b1 = " + b1); //false  true
        System.out.println(s1 == s2);     //比较地址false

        System.out.println("------------------------------------------");
        //8.1//调用从Object类中继承下来的hashCode方法,获取对象的哈希码值
        //8.5//当Student类中重写hashCode方法后,则调用重写以后的版本
        int ia = s1.hashCode();
        int ib = s2.hashCode();
        System.out.println("ia = " + ia);   //ia = 1627960023   哈希码不相同,因为没
        System.out.println("ib = " + ib);   //ib = 357863579

        System.out.println("------------------------------------------");
        //9.1//下面调用从Object中继承下来的toString方法,获取调用对象的字符串形式: 包名.类名@哈希码值得十六进制
        String str1 = s1.toString();
        //9.2// System.out.println("str1 = " + str1);   //com.lagou.task11.Student@55d
        //9.3// 当Student类中重写toString方法后,则调用重写以后的版本  Student[id = 1001,name = zhangfei]
        System.out.println("str1 = " + str1);   //Student[id = 1001,name = zhangfei]
        System.out.println(s1);     //9.4//打印引用变量时,会自动调用toString方法
        String str2 = "hello" + s1;  //9.5// 打印时,或者字符串拼接时,都会自动调用该方法
        System.out.println("str2 = " + str2);


    }
}

11.3 包装类（熟悉）

11.3.1 包装类的概念

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

如： Person p = new Person(); // 是对象

int num = 10; // 不是对象

11.3.2 包装类的分类

11.3.3 Integer类的概述

（1）基本概念

java.lang.Integer类内部包装了一个int类型的变量作为成员变量，

主要用于实现对int类型的包装并提供int类型到String类之间的转换等方法。

（2）常用的常量

（3）常用的方法

（4）装箱和拆箱的概念

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

（5）自动装箱池

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

代码: Integer类的常量, 常用方法测试

{valueOf(), intValue(), parseInt(), equals() , 进制转换字符串}

package com.lagou.task11;

/**
 * @author CH
 * @date 2020/9/27 18:14
 */
public class IntegerTest {

    public static void main(String[] args) {

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

        System.out.println("-------------------------------------------------------");
        //1.2//使用构造方法来构造Integer类型的对象
        Integer it1 = new Integer(123);
        System.out.println("it1 = " + it1); // 123  //1.3// 自动调用toString方法
        Integer it2 = new Integer("456");
        System.out.println("it2 = " + it2);

        System.out.println("-------------------------------------------------------");
        //1.4//上述方法已过时,建议使用valueof方法取代之,相当于int到Integer类型的转换     //1.7//叫做装箱
        Integer it3 = Integer.valueOf(123);
        System.out.println("it3 = " + it3); //123
        Integer it4 = Integer.valueOf("456");
        //1.5//从String类型到Integer类型的转换
        System.out.println("it4 = " + it4); //456  得到String类型
        //1.6//获取调用对象中的整数数值,相当于从Integer类型到int类型的转换  //1.7//叫做拆箱
        int ia = it4.intValue();
        System.out.println("获取到的整数数据是:" + ia);  //456  得到int类型

        System.out.println("-------------------------------------------------------");
        //1.8//Java5开始,增加了自动装箱拆箱的机制
        Integer it5 = 100;  //1.8//直接通过赋值运算符实现自动装箱
        int ib = it5;       //1.8//直接通过赋值运算符实现自动拆箱

        System.out.println("-------------------------------------------------------");
        //1.9//装箱和拆箱的笔试考点
        Integer it6 = 127; //128;
        Integer it7 = 127; //128;
        Integer it8 = new Integer(127); //1.10//new Integer(128);
        Integer it9 = new Integer(127); //1.10//new Integer(128);
        System.out.println(it6 == it7);      //比较地址 false   //1.10//true  地址是一样的   自动装箱池
        System.out.println(it6.equals(it7)); //比较内容 true
        System.out.println(it8 == it9);      //比较地址 false
        System.out.println(it8.equals(it9)); //比较内容 true

        System.out.println("-------------------------------------------------------");
        //1.11//实现静态方法的调用
        int ic = Integer.parseInt("200");  //编译OK,运行发生NumberFormatException数字格式异常,因为有字母
        //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


    }

}

11.3.4 Double类的概述

（1）基本概念

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

（2）常用的常量

（3）常用的方法

扩展： java.lang.Number类是个抽象类，是上述类的父类来描述所有类共有的成员。

代码: Double类的常用方法测试

{valueOf(), doubleValue(), parseDouble(), isNaN() }

package com.lagou.task11;

/**
 * @author CH
 * @date 2020/9/27 19:36
 */
public class DoubleTest {

    public static void main(String[] args) {

        //1.1// Java5之前装箱和拆箱
        //1.2// 实现了double到 Double的转换 ,装箱
        Double db1 = Double.valueOf(3.14);
        System.out.println("db1 = " + db1);     //3.14
        //1.3// 实现了从Double到double类型的转换,拆箱
        double d1 = db1.doubleValue();
        System.out.println("d1 = " + d1);//3.14

        System.out.println("-------------------------------------");
        //2.1//从Java5开始,实现自动装箱拆箱
        Double db2 = 3.14;
        System.out.println("db2 = " + db2);//3.14
        double d2 = db2;
        System.out.println("d2 = " + d2);//3.14

        System.out.println("-------------------------------------");
        //3.1//实现静态方法和成员方法的调用
        double d3 = Double.parseDouble("13.14");
        System.out.println("d3 = " + d3);//13.14

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


    }
}

11.3.5 Boolean类的概述

（1）基本概念

java.lang.Boolean类型内部包装了一个boolean类型的变量作为成员变量，

主要用于实现对 boolean类型的包装并提供boolean类型到String类之间的转换等方法。

（2）常用的常量

（3）常用的方法

代码: Boolean类的常用方法测试

{valueOf(), booleanValue(), parseBoolean() }

package com.lagou.task11;

/**
 * @author CH
 * @date 2020/9/27 21:47
 */
public class BooleanTest {

    public static void main(String[] args) {

        //1.1// Java5之前的装箱拆箱
        //1.1// 从boolean到Boolean的转换, 装箱
        Boolean bo1 = Boolean.valueOf(true);
        System.out.println("bo1 = " + bo1); //true
        boolean b1 = bo1.booleanValue();
        System.out.println("b1 = " + b1);    //true

        System.out.println("-------------------------------------------");
        //2.1//Java5 开始自动装箱拆箱
        Boolean bo2 = false;
        boolean b2 = bo2;
        System.out.println("bo2 = " + bo2);
        System.out.println("b2 = " + b2);

        System.out.println("-------------------------------------------");
        //3.1// 实现String到Boolean类型的转换
        //Boolean b3 = Boolean.parseBoolean("123");
        // 3.2// 该方法执行原理: 只要参数数值不为true或TRUE, 则结果均为false,
        Boolean b3 = Boolean.parseBoolean("TRUE");
        System.out.println("b3 = " + b3); //true





    }
}

11.3.6 Character类的概述

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

（2）常用的常量

（3）常用的方法

代码: Character类的常用方法测试

{valueOf(), charValue(), parseCharacter(), isUpperCase(), isLowerCase(), isDigit, toUpperCase(), toLowerCase() }

package com.lagou.task11;

/**
 * @author CH
 * @date 2020/9/27 22:00
 */
public class CharacterTest {

    public static void main(String[] args) {

        //1.1// Java5之前的装箱拆箱
        //1.1// 相当于从char类型到Character类型的转换,装箱
        Character ca1 = Character.valueOf('a');
        System.out.println("ca1 = " + ca1); //a
        //1.2// Character -> char
        char c1 = ca1.charValue();
        System.out.println("c1 = " + c1);   //a

        System.out.println("----------------------------------------");
        //2.1// Java5之后的  装箱拆箱
        Character ca2 = 'b';
        char c2 = ca2;
        System.out.println("ca2 = " + ca2); //b
        System.out.println("c2 = " + c2);   //b

        System.out.println("----------------------------------------");
        //3.1//实现字符类型的判断以及转换
        System.out.println(Character.isUpperCase(c2));  //false
        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


    }
}

11.3.7 包装类（Wrapper）的使用总结

基本数据类型转换为对应包装类的方式

调用包装类的构造方法或静态方法即可大类名引用 = 大类名 . valueOf(参数);

获取包装类对象中基本数据类型变量数值的方式

调用包装类中的xxxValue方法即可小类名变量 = 引用 . 小类名Value();

字符串转换为基本数据类型的方式

调用包装类中的parseXxx方法即可大类名引用 = 大类名 . parse小类名(字符串);

11.4 数学处理类（熟悉）

11.4.1 Math类的概述

（1）基本概念

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

（2）常用的方法

代码: Math类中常用方法的测试

{ max(), min(), pow(), abs(), round(), sqrt(), random() }

package com.lagou.task11;

import com.lagou.task10.Man;

/**
 * @author CH
 * @date 2020/9/27 22:53
 * 编程实现对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)); //20
        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     体现double类型
        System.out.println("生成的随机数是: " + Math.random());    //随机数
    }
}

11.4.2 BigDecimal类的概述

（1）基本概念

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

（2）常用的方法

代码: BigDecimal类中常用方法的测试精确运算及Rounding类中四舍五入测试

{ 构造, add, subtract, multiply, divide } , { RoundingMode.HALF_UP }

package com.lagou.task11;

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * @author CH
 * @date 2020/9/28 10:37
 */
public class BigdecimalTest {

    public static void main(String[] args) {

        //1.1//构造BigDecimal类型的两个对象
        BigDecimal bd1 = new BigDecimal("5.2"); //一定要注意这里有双引号
        BigDecimal bd2 = new BigDecimal("1.3");
        //1.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("---------------------------------------------------");
        //1.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("---------------------------------------------------");
        //1.4//注意事项
        BigDecimal bd5 = new BigDecimal("2");
        BigDecimal bd6 = new BigDecimal("0.3");
        //System.out.println("实现除法的运算结果是:" + bd5.divide(bd6));    // 编译OK 运行发生 ArithmeticException,无法精确表示
        System.out.println("实现除法的运算结果是:" + bd5.divide(bd6, RoundingMode.HALF_UP));    // 7 要使用math包的Rounding.HALF_UP

    }
}

11.4.3 BigInteger类的概念

（1）基本概念

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

（2）常用的方法

代码: BigInteger类中常用方法测试

{构造 add, subtract, multiply, divide, remainder, divideAndRemainder, }

package com.lagou.task11;

import java.math.BigInteger;
import java.util.Arrays;

/**
 * @author CH
 * @date 2020/9/28 11:03
 */
public class BigIntegerTest {

    public static void main(String[] args) {

        //1.1// 构造2对象,并初始值
        BigInteger bi1 = new BigInteger("20");
        BigInteger bi2 = new BigInteger("8");
        //2.1// 实现加减乘除操作并打印
        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.1// 一次性求商和取余
        BigInteger[] arr = bi1.divideAndRemainder(bi2);
        System.out.println(Arrays.toString(arr));
        for(int i = 0; i < arr.length; i++) {
            System.out.println("数组中第" + (i+1) + "个元素是:" + arr[i]);
        }
    }
}