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 = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((username == null) ? 0 : 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 方法，以配置系统资源或执行其他清除。也就是手动垃圾回收。