java.lang基础包之java基本数据类型解析

java里的八大基础数据类型：
分别是：

long(64)

[-9,223,372,036,854,775,808~ 9,223,372,036,854,775,807]
默认值：0L

int(32)

[-2,147,483,648-2,147,483,647] 20亿左右
默认值： 0

short(16)

[-32768~32767]
默认值： 0

byte(8)

[-128~127]
默认值： 0

float(32)

默认值：0.0f
ps：不能表示精确的值

double(64)

默认值 ：0.0d

boolean(64)

默认值：false

char(16)

char类型是一个单一的 16 位 Unicode 字符

关于被封装的基本类型

他们在java里都被封装成了不同的包装类
区别在于 一个是数据基本类型，而包装类是一个对象。
对于类我们的使用应该是这样的
Integer i= new Integer(1)；
但是在jdk1.5引入了自动装箱与拆箱（注解1）
然后就可以
Integer i=1;
但是实际执行的是Integer i = Integer.valueOf(1);
可以看下这段代码

        Integer a=1000;
        Integer b=1000;
        Integer c=100;
        Integer d=100;
        System.out.println(a==b);
        System.out.println(c==d);

执行输出会是什么呢？

false
true

我们来看下源码

  public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

说白了，就是当新建一个Integer类型的对象，如果其值再-128到127之内，就会将这个值缓存起来 用的时候也是用的同一个缓存对象,所以用==去判断的时候，因为是同一个地址的同一个对象，所以肯定是==的。就不会去新new一个了。但是用equal方法去比较的时候，因为比较的是值，所以就都会返回true了。

public boolean equals(Object obj) {
//先判断该对象是不是 Integer的实例
        if (obj instanceof Integer) {
    //进行值的比较
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

这部分的源码有些是相同的，所以这里只记录下学习的结果，不将全部过程记录下来。

数值类型类比.png

在所有的数值类型里都继承了Number类且实现了Comparable接口【注解2】。
在Number里 最主要都是定义了可以六种数值的获取格式。

注解21：自动装箱与拆箱

自动装箱：
Integer i=1;
系统执行：Integer i = Integer.valueOf(1);
自动拆箱：
int a=i;
系统执行：int t = i.intValue();

注解2：关于Comparale 接口

主要说明下Comparale里面的方法，里面只有一个方法：
public int compareTo(T o);
其实这个的主要作用是暴露这个接口给外部可以重新定义排序的方法

class Grade implements  Comparable<Grade> {
     private Integer grade;
     private String name;

     public Grade(String name,Integer grade ) {
         this.grade = grade;
         this.name = name;
     }

     public Integer getGrade() {
         return grade;
     }

     public void setGrade(Integer grade) {
         this.grade = grade;
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     //重新定义排序
     @Override
     public int compareTo(Grade o){
       if(o.getGrade()>this.getGrade()){
           return 1;
       } else if( o.getGrade()<this.getGrade()) {
           return -1;
       } else {
           return 0;
       }
     }
 }

public  static void main(String[] args){
        int[] test1={1,2,4,3,6,5};
        Arrays.sort(test1);

        for (Integer t:test1){
            System.out.println(t.intValue());
        }

        Grade[] grades={
                new Grade("aa",39),
                new Grade("bb",42),
                new Grade("cc",13),
                new Grade("ee",73),
                new Grade("ff",11),
        };
        Arrays.sort(grades);
        for (Grade t:grades){
            System.out.println(t.getName()+t.getGrade());
      
    }

输出结果为

ee73
bb42
aa39
cc13
ff11

我们就可以根据我们在Grade类里的重写实现 compareTo方法得到我们想要的排序

注解3：如何解决float，double存在精度丢失的问题

 double result = 1.0 - 0.9;

结果为0.09999999999999998

因为浮点数值采用的是二进制表示，二级制中无法精确表示1/10。当不允许有任何四舍五入的误差的时候应该使用BigDecimal类。