mysql TEXT 类型比较
 
类型
大小
大小
TINYTEXT
256 bytes
TEXT
65,535 bytes
~64kb
MEDIUMTEXT
16,777,215 bytes
~16MB
LONGTEXT
4,294,967,295 bytes
~4GB
具体可参考官方文档

之所以记录是因为在开发过程当中，碰到了两次因为个人原因Long类型判断出错导致的bug，因此在此关于Long类型数据比较做一个记录。 
 注意：long类型和Long类型是不一样，long类型属于基本的数据类型，而Long是long类型的包装类，至于区别是什么再次不做过多详细的解释。
 
1. 首先说==和equals()方法的区别： 
 ==号在比较基本数据类型，比如int作比较的时候比较的是值。而当去比较两个对象的时候，便成了比较两个对象的地址，在开始的时候也说Long类型是long的包装类因此当用==比较的时候便会发生错误。 
 equals()方法存在于Object类当中，Object是所有类的直接和间接父类，Object类当中的equals源码当中写了，当没有重写equals()方法时,equals()和==的效果是一样的，但是像Long这种包装类都是重写了equals()方法的。
 
2. 怎么去比较两个Long类型的数据： 
 第一种方法使用Long类型的longValue()方法，这个方法作用是：取到Long类型当中的值，然后我们就可以正常的用==去比较，例如：
 
Long a = new Long(345);
Long b = new Long(345);
System.out.println(a.longValue()==b.longValue())
 
第二种方法使用Long类型的equals()方法，这个方法我们可以去查看一下源码，源码如下：
 
public boolean equals(Object obj) {
        if (obj instanceof Long) {
            return value == ((Long)obj).longValue();
         }
         return false;
     }
 
查看源码我们可以发现，Long类型的equals()方法当中，也调用longValue()方法然后再去比较大小。 
 因此在使用过程当中我们可以采用这两种方式去进行比较Long对象（类型）的大小。 
 其实一开始也解释了，Long属于对象，对于对象来讲大家都知道不能直接用==去比较。 
 注意：这可能是让人费解的一个地方，请看如下代码
 
Long i = 12L;
Long j = 12L;
System.out.println(i==j);//true
 
很神奇，比较i和j的时候是Long类型，然后取比较打印的结果是true，之所以会产生这种现象是因为Long类型内部有一个内部类，维护了一个cache。源码当中是这样写的：
 
//552行
public static Long valueOf(long l) {
    final int offset = 128;
    if (l >= -128 && l <= 127) { // will cache
        return LongCache.cache[(int)l + offset];
    }
        return new Long(l);
}
//528行
private static class LongCache {
    private LongCache(){}

    static final Long cache[] = new Long[-(-128) + 127 + 1];

    static {
        for(int i = 0; i < cache.length; i++)
        cache[i] = new Long(i - 128);
    }
 }
 
也就是说在-128到127的值，都放在了cache中，不会新创建对象，因此==是成立的，当超过了这个范围，便无法使用==进行判断了。
 
关于Long类型的比较就这些，如果有说的不对的请及时指正

基本数据类型的包装类型比较分为两种类型：
 
 
相同类型比较
 
Number类型比较时，只要有一个调用了拆箱，就可以用“==”比较，无论是调用intValue还是longValue。当然对于包装类的比较，建议使用equals比较。
 
Integer id1 = 123456789;
Integer id2= 123456789;
// false
System.out.println(id1 == id2);
// true
System.out.println(id1.longValue() == id2);
// true
System.out.println(id1.equals(id2));
 
 
不同类型比较
 
Number类型比较时，只要有一个调用了拆箱，就可以用“==”比较，无论是调用intValue还是longValue。如果使用equals比较，必须要转成相同类型才能正确比较。
 
Long idL = 123456789L;
Integer idI = 123456789;
// true，注意：Integer转成了Long类型
System.out.println(idL.equals(idI.longValue()));
// false，注意：两者类型相同时才能正确比较
System.out.println(idI.equals(idL.longValue()));
// true
System.out.println(idL == idI.longValue());
System.out.println(idL.intValue() == idI);
System.out.println(idI.equals(idL.intValue()));
 
 
总结：
 
相同类型的包装类型比较时，建议使用equals比较。
不同类型的包装类型比较时，建议使用equals比较，但是要转成相同的类型！例如：Integer.equals(Long.intValue())和Long.equals(Integer.longValue())

引用类型和基本类型的分类，不在写了，网上有很多。
 
我们知道： 
 当两个基本类型使用”==”比较时，他们比较的是值。 
 当两个引用类型使用”==”比较时，他们比较的是地址。 
 当两个引用类型使用方法equals()比较时，他们比较的是值。
 
但当基本类型和他的包装类（引用类型）使用”==”比较时， 
 他们的结果又是如何呢？
 
下面我们使用Integer和int进行说明。 
 Integer是int的包装类。 int 基本类型， Integer 为引用类型。 
 看个例子：
 
int i = 1234;
Integer i1 = new Integer(1234);
Integer i2 = new Integer(1234);
System.out.print("i1 == i2 : "+(i1 == i2));
System.out.println("\ti1.equals(i2) : "+(i1.equals(i2)));
System.out.print("i == i1 : "+(i == i1));
System.out.println("\t\ti1.equals(i) : "+(i1.equals(i)));
System.out.print("i == i2 : "+(i == i2));
System.out.println("\t\ti2.equals(i) : "+(i2.equals(i)));
 
打印： 
 i1 == i2 : false i1.equals(i2) : true 
 i == i1 : true i1.equals(i) : true 
 i == i2 : true i2.equals(i) : true
 
我们可以看到 i == i1, i == i2, i1 != i2, 
 但使用equals()他们都是相等的。
 
接着我们来看看jdk1.8中Integer类中的方法equals()
 
    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }
 
可以观察到使用equals()，他们比较的是值。
 
总结：当比较基本类型和他的包装类（引用类型）使用”==”和方法equals()比较时，他们比较的都是值。
 
Integer和其它基本类型都相同，大家有兴趣可以去证明，在此我都不在写了。