Java中的long类型和Long类型比较大小

Java中Long和long的区别
Java的数据类型分为两种：
**1、基本类型：
byte(8),short(16),int(32),long(64),float(32),double(64),char(16),boolean(1)
2、对象类型：
Byte,Short,Integer,Long,Float,Double,Character,Boolean

上面的对象类型分别是基本类型的包装类，例如Byte是byte的包装类.

Long数据的大小的比较
对于Long类型的数据，这个数据是一个对象，所以对象不可以直接通过“>”,“==”，“<”的比较，如果要比较两个对象的是否相等的话，我们可以用Long对象的.equals（）方法：

Long l1 = new Long(100);  
Long l2 = new Long(200);  
System.out.println(l1.equals(l2)); 

如果要进行“>”,“<”的比较的话，可以通过Long对象的.longValue()方法：

Long l1 = new Long(100);  
Long l2 = new Long(200);  
System.out.println(l1.longValue()<l2.longValue());

long数据的大小的比较
对于long类型的数据，这个数据是一个基本数据类型，不属于对象，所以可以直接通过“>”,“==”，“<”作比较

long l3 = 300;  
long l4 = 400;  
System.out.println(l3>l4);  
System.out.println(l3<l4);  
System.out.println(l3==l4); 

Java为每个原始类型提供了封装类

为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每 一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。

原始类型: boolean，char，byte，short，int，long，float，double
**封装类类型(对象类型)：**Boolean，Character，Byte，Short，Integer，Long，Float，Double

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在很多的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类（Wrapper Class）

对于包装类说，这些类的用途主要包含两种：
作为和基本数据类型对应的类类型存在，方便涉及到对象的操作。

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

自动装箱：将基本数据类型重新转化为对象

public class Test {
    public static void main(String[] args) {
 
        List<Integer>list=new ArrayList();
        //自动把1装箱成Integer包装类
        list.add(1);
    }
}

自动拆箱：将对象重新转化为基本数据类型

public class Test {
    public static void main(String[] args) {
        //声明一个Integer对象
        Integer num = 9;
 
        //进行计算时隐含的有自动拆箱
        System.out.print(--num);
    }
}

因为对象时不能直接进行运算的，而是要转化为基本数据类型后才能进行加减乘除。

对比：

/装箱
Integer num = 10;

//拆箱
int num1 = num;

深入解析

情况描述

public class Test {
    public static void main(String[] args) {
 
        // 在-128~127 之内的数
        Integer i = 127;
        Integer j = 127;
        System.out.println( i==j );   //true
 
        // 在-128~127 之外的数
        Integer m = 128;
        Integer n = 128;
        System.out.println( m==n );   //false
 
        // 直接在堆中new一个对象
        Integer k = new Integer(100);
    }
}

java在编译Integer x = yyy ;时，会翻译成为Integer x = Integer.valueOf(yyy)。而java API中对Integer类型的valueOf的定义如下，对于-128到127之间的数，会进行缓存，Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，就会直接从缓存中取，就不会new了。如果超过128就会重新new一个新对象

解析原因： 归结于java对于Integer与int的自动装箱与拆箱的设计，是一种模式：叫享元模式（flyweight）。

1.加大对简单数字的重利用，Java定义在自动装箱时对于值从–128到127之间的值，它们被装箱为Integer对象后，会存在内存中被重用，始终只存在一个对象。

2.而如果超过了从–128到127之间的值，被装箱后的Integer对象并不会被重用，即相当于每次装箱时都新建一个 Integer对象。

上图也可以从代码断点看出 i 和 j 的地址相同。

同理， Long 与long, Float 与float，double与Double 等也存在类似的情况。

Float:

    public static void main(String[] args) {

        Float m = Float.valueOf(8280.0f);
        Float k = new Float(8280.0f);
        float n = 8280.0f;
        System.out.println(m==n); //true
        System.out.println(k==n); //true
        System.out.println(m==k); //false

    }

Long:

public static void main(String[] args) {

    Long m = new Long(1280);
    Long n = new Long(1280);
    System.out.println(m==n); //false

}

Double:

public static void main(String[] args) {

        Double m = new Double(128);
        Double n = new Double(128);
        System.out.println(m==n); //false

    }

Boolean：

  public static void main(String[] args) {

        Boolean m = new Boolean(true);
        Boolean n = new Boolean(true);

        System.out.println(m==n); //false

    }

Byte是java.lang中的一个类，目的是为基本数据类型byte进行封装。封装有几种好处，比如：1. Byte可以将对象的引用传递，使得多个function共同操作一个byte类型的数据，而byte基本数据类型是赋值之后要在stack(栈区域)进行存储的；2. 定义了和String之间互相转化的方法。Byte的大小是8个字节。因为Byte是需要通过关键字new来申请对象，而此部分申请出来的对象放在内存的heap(堆区域)。

Byte:

   public static void main(String[] args) {

        Byte by1 = new Byte("123");
        Byte by2 = new Byte("123");
        int length = by1.SIZE;
        int max = by2.MAX_VALUE;
        int min = by2.MIN_VALUE;
        System.out.println(by1 == by2); //false
        by1.equals(by2);    //true
        Byte by3 = by1;
        System.out.println(by3 == by1);  //true
        System.out.println("The length is "+length); //The length is 8
        System.out.println("MAX:"+max+" MIN"+min); //MAX:127 MIN-128
        byte temp = (byte)241; // 241的二进制表示为11110001（补码），其中第一位为符号位，那么剩余的计算结果为15，最终结果为-15
        System.out.println(temp); //-15
    }

Short:

 public static void main(String[] args) {

       Short m =128;
       Short n =128;
       System.out.println(m==n); //false

       Short a =127;
       Short b =127;
       System.out.println(a==b); //true

       short m1=128;
       short a1=127;
       //包装类与值类型比较时，自动拆箱，与范围无关
       System.out.println(m==m1); //true
       System.out.println(a==a1); //true

    }

以上堆，栈，常量池等在java中的概念，可以到 java堆、栈、堆栈，常量池的区别，史上最全总结 学习更多知识。