JavaSE的包装类，自动装箱和自动拆箱 ,字符窜转换，toString(),equals(), hashCode()的区别

一。基本数据类型和包装类

包装类均位于Java.lang包，包装类和基本数据类型的对应关系如下表所示：

　　Primitive-Type  　　 Wrapper-Class
        byte          　　　　　　  Byte
        short           　　　　　　Short
        int              　　　　　　 Integer
        long            　　　　　　Long
        float            　　　　　　Float
        double            　　　　   Double
        boolean            　　　　 Boolean
        char                                Character

1）作为和基本数据类型对应的类类型存在，方便涉及到对象的操作。

2）包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。

二。自动装箱和自动拆箱

//自动装箱(就是把基本数据类型转换成包装类型)
   Integer cc=111;
   //自动拆箱(就是把包装数据类型转换成基本数据类型)
   int ccparm=cc;

三.基本数据类型和字符窜之间的转化

//基本数据类型转换成字符窜

int aa=1;

System.out.println(Integer.toString(aa));
 System.out.println(String.valueOf(aa));
 System.out.println(aa+"");
 //字符窜转换成基本数据类型
 String bb ="1234";
System.out.println(Integer.parseInt(bb));
System.out.println(Integer.valueOf(bb));

四。向上转型和向下转型

//转型:父类引用指向子类对象
   //向上转型
  Animal animal=new Bird();
  animal.eat();
  //向下转型
  Bird bird=(Bird)animal;
  bird.fly();

五。==和equals方法的区别 

1)基本类型变量的比较
      　　  基本类型变量指向的不是对象,不能调用方法,所以只能使用==进行比较,并且比较的是基本类型变量的简单数值是否相等。
    
  2)引用类型变量的比较
       　　 引用类型变量指向的是对象,所以既可以使用==进行比较,也可以使用equals进行比较

　　 区别在于:
            　　equals是Object中的方法,每个对象都可以调用和其他对象比较是否相等,默认比较的是俩个引用所指向的对象内存地址值(和==号的作用一样),但是也可以在类中对equals方法进行重写,按照自己的逻辑来比较俩个对象。

　　==是java中的基本的操作符,是不能重写的,俩个引用使用==进行比较,那么比较的是引用所指向的内存地址值是否相同。

 六。Object 类中的toString(),equals(),hashCode()方法之间的关系。

   Object 类

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

public boolean equals(Object obj) {
        return (this == obj);
    }

public native int hashCode();

StudentBean类

public class StudentBean {
    private String username;
    private int age;

    @Override
    public String toString() {
        return "StudentBean [username=" + username + ", age=" + age + "]";
    }

    @Override
    public int hashCode() {
        final int prime = ;
        int result = ;
        result = prime * result + age;
        result = prime * result + ((username == null) ?  : username.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        StudentBean other = (StudentBean) obj;
        if (age != other.age)
            return false;
        if (username == null) {
            if (other.username != null)
                return false;
        } else if (!username.equals(other.username))
            return false;
        return true;
    }

}

测试

public class TestStudentBean {
  public static void main(String[] args) {
    StudentBean studentBean=new StudentBean();
    StudentBean studentBean1=new StudentBean();
    System.out.println(studentBean.equals(studentBean));
    //针对不同的对象返回不同的整数
    System.out.println(studentBean.hashCode()); //通过将该对象的内部地址转换成一个整数来实现的
    System.out.println(studentBean.hashCode());
}
}

总结

　　1) 对象相等则hashCode一定相等；

　　2) hashCode相等对象未必相等。也就是说两个不同的对象也有可能hashCode（散列码（取余得出的））相同

　　判断两个对象是否相等的条件：
　　没有重写的话，只要hashCode不相等那么两个对象一定不相同， 
　　重写的话，首先判断hashCode如果不一样，那么两个对象不相等，如果hashCode一样的话，再比较equals，如果true就相同，否则不相等。

　　finalize()：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写 finalize 方法，以配置系统资源或执行其他清除。也就是手动垃圾回收。