JavaSE 包装类、equals()、toString() 2021.05.24-25

重心一定要放在学习上了，该做什么不该做什么，什么事情尽量不做应该要清楚
现在相当于浪费了3天的宝贵学习时间，还要抽点时间出来学英语。呜呜呜，提高效率！
最近狂神阶段一的课程看完，但是缺失了一些课，要在尚硅谷继续学习，不同学习的风格，适应适应！

== 与 equals

一、 ==
1.基本数据类型：根据基本数据类型的值判断是否相等。相等返回true，否则返回false
注意：两端数据类型可以不同，在不同的情况下，也可以返回true；==两边变量类型一致（不是完全相同）
2.引用数据类型：比较引用类型变量的地址值是否相等

        int a= 12;
        int b= 12;
        char c =12;
        float f =12.0F;

        System.out.println(a==b);//true
        System.out.println(a==c);//true
        System.out.println(a==f);//true

        int d=65;
        char e='A';
        System.out.println(d==e);//true

        Demo01 d1 = new Demo01();
        Demo01 d2 = new Demo01();
        Demo01 d3 = d1;

        System.out.println(d1);//@1b6d3586  ,System.out.println(d1.toString());
        System.out.println(d2);//@4554617c
        System.out.println(d1==d2);//false
        System.out.println(d1==d3);//true

二、equals()

1.只能处理引用类型变量，是一种方法，不是运算符。
2.在Object类中，equals()比较的仍然是两个引用变量的地址值是否相等，与==作用相同

        //Object类中equals()方法的定义
        public boolean equals(Object obj) {
              return (this == obj);
        }

java.lang.Object类，是所有类的根父类

---

        Demo02 d1 = new Demo02();
        Demo02 d2 = new Demo02();
        System.out.println(d1.equals(d2));//false，继承了Object类的equals()方法
        System.out.println(d1 == d2);//false

        String str1=new String("AA");
        String str2=new String("AA");

        System.out.println(str1 == str2);//false
        System.out.println(str1.equals(str2));//true，因为String类重写了equals()方法，比较的是两个对象的“实体内容”是否完全相等。

像String、Date、File、包装类这些重写Object类的equals()方法，比较的是两个对象的“实体内容”是否完全相等。

如果自定义类的equals()方法重写，原则也是比较两个对象的实体内容是否相同（即类中的属性是否相同），快捷键Alt + Insert

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

---

• 对称性：如果 x.equals(y)返回值是true，则y.equals(x)也是true
• 传递性：如果 x.equals(y)返回值是true，且y.equals(z)是true，那么z.equals(x)也是true
• 自反性：x.equals(x)一定是true
• 一致性：如果x.equals(y)返回值是true，只要x和y不变，不管重复多少次x.equals(y)，返回值都是true
• 任何情况下，x.equals(null)和x.equals(和x不同类型的对象)返回值永远是false

toString()

Object类中toString()的使用：

• 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()

        Demo01 d1 = new Demo01();
        System.out.println(d1);//com.beckham.toString.Demo01@1b6d3586
        System.out.println(d1.toString());//com.beckham.toString.Demo01@1b6d3586

• Object类中toString()的定义：

    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

• 像String、Date、File、包装类等都重写了Object类中的toString()方法，使得在调用对象的toString()时，返回实体信息,快捷键Alt + Insert

        String s = new String("abc");
        System.out.println(s);//abc
        System.out.println(s.toString());//abc

        Date date = new Date();
        System.out.println(date);//Mon May 24 16:19:47 GMT+08:00 2021
        System.out.println(date.toString());//Mon May 24 16:19:47 GMT+08:00 2021

自定义类也可以重写toString()方法，当调用此方法时，返回对象的“实体内容”,快捷键Alt + Insert

public class Demo01 {
    int age;
    String name;

    @Override
    public String toString() {
        return "Demo01{age=" + age + ", name='" + name +  "'}";
    }
    
    public static void main(String[] args) {

        Demo01 d1 = new Demo01();
        System.out.println(d1);//Demo01{age=0, name='null'}
        System.out.println(d1.toString());//Demo01{age=0, name='null'}
    }
}

包装类（Wrapper）

• 针对八种基本数据类型定义相应的引用类型-包装类（封装类）
• 有了类的特点，就可以调用类中的方法，Java才是真正的面向对象
  

基本数据类型、包装类、String类间的转化

一、基本数据类型 → 包装类

• 调用包装类的构造器

Integer:

        int num1=10;
        Integer i1 = new Integer(num1);//形参是int类型
        System.out.println(i1.toString());//10
        Integer i2 = new Integer("123");//形参是String类型
        System.out.println(i2.toString());//123

Float:

        Float f1 = new Float(12.3f);//形参可以是double类型、float类型、String类型

报异常，NumberFormatException

        Integer i3 = new Integer("123abc");

Boolean：

        Boolean b1 = new Boolean(true);//true，形参可以是boolean值类型、String类型
        Boolean b2 = new Boolean("true");//true
        Boolean b3 = new Boolean("TrUe");//true
        Boolean b4 = new Boolean("True123");//false
        
//源码：不为null，且忽略大小写内容是true，输出结果为true。否则为false   
    public static boolean parseBoolean(String s) {
        return ((s != null) && s.equalsIgnoreCase("true"));
    }

//默认值
public class Demo02 {
    boolean flag1;
    Boolean flag2;

    public static void main(String[] args) {
        Demo02 demo02 = new Demo02();
        System.out.println(demo02.flag1);//false，基本类型
        System.out.println(demo02.flag2);//null，引用类型
    }
}

二、包装类 → 基本数据类型

• 调用包装类xxx的xxxValue()

        Integer int1= new Integer(12);
        int a =int1.intValue();
        System.out.println(a);//System.out.println(int1.intValue());

        Float f1 = new Float("12.3");
        System.out.println(f1.floatValue());

三、自动装箱和自动拆箱 JDK 5.0新特性

        int a=10;
        Integer integer = a;//自动装箱
        int b = integer;//自动拆箱

        Boolean flag=true;//自动装箱
        boolean flag2=flag;//自动拆箱

四、基本数据类型、包装类 → String类型

• 连接运算

        int a =10;
        boolean flag =true;
        String str = a+"个";
        String str1=flag+"的";
        System.out.println(str);//10个
        System.out.println(str1);//true的

• 调用String的valueOf()方法

        float f1 =12.3f;
        String str2= String.valueOf(f1);

        Float f2 = new Float(12.3);
        String str3 = String.valueOf(f2);

        System.out.println(str2);
        System.out.println(str3);

五、String类型 → 基本数据类型、包装类

• 调用包装类的parsexxx(String s )方法

        String str ="123";
        int i1=Integer.parseInt(str);//可能会报NumberFormatException

        String str2 = "true";
        boolean flag =Boolean.parseBoolean(str2);

        System.out.println(i1+1);//124
        System.out.println(flag);//true

包装类面试题

一、

三元运算符。要求后面两个类型统一成一个类型

        Object o1= true?new Integer(1):new Double(2.0);
        System.out.println(o1);//1.0

        Object o2;
        if (true){
            o2=new Integer(1);
        }else{
            o2=new Double(2);
        }
        System.out.println(o2);//1

二、

如果使用自动装箱的方式，给Integer赋值在-128~127范围内时，可以直接使用IntegerCashe中数组的元素，不用再去new

        Integer a1=new Integer(1);
        Integer a2=new Integer(1);
        System.out.println(a1==a2);//false

/*
Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[]，保存了-128~127范围的整数。
如果我们使用自动装箱的方式，给Integer赋值在-128~127范围内时，可以直接使用数组中的元素，不用再去new
目的：提高效率
*/
        Integer b1=1;
        Integer b2=1;
        System.out.println(b1==b2);//true

        Integer c1=128;//相当于new了一个Integer对象
        Integer c2=128;//相当于new了一个Integer对象
        System.out.println(c1==c2);//false

        Float f1= 1f;
        Float f2= 1f;
        System.out.println(f1==f2);//false