为了存储字符串、图片和声音等数据，MySQL提供了字符串和二进制类型。
 
数据类型
 
CHAR——用于表示固定长度的字符串 
 VARCHAR——用于表示可变长度的字符串 
 BINARY——用于表示固定长度的二进制数据 
 VARBINARY——用于表示可变长度的二进制数据 
 BOLB——用于表示二进制大数据 
 TEXT——用于表示大文本数据 
 ENUM——表示枚举类型，只能存储一个枚举字符串值 
 SET——表示字符串对象，可以有零或多个值 
 BIT——表示位字段类型
 
CHAR和VARCHAR类型
 
都用来存储字符串 
 VARCHAR，可以存储可变长度的字符串 
 CHAR，存储定长字符串 
 定义如下 
 CHAR (M)或者VARCHAR (M) 
 M指的是字符串的最大长度 
 比如 
 插入值’ab’ 
 CHAR (4)，需要4个字节 
 VARCHAR (4)，需要3个字节 
 当数据为CHAR (M)类型时，不管插入值的长度是多少，所占用的存储空间都是M个字节。 
 当为VARCHAR (M)类型时，所占用的字节数为实际长度加1。
 
BINARY和VARBINARY类型
 
类似于CHAR和VARCHAR 
 用来表示二进制数据 
 定义如下 
 BINARY (M)或者VARBINARY (M) 
 M指的是二进制数据的最大字节长度 
 注意 
 BINARY类型的长度是固定的，如果数据的长度不足最大长度，在后面用”\0”补齐。 
 比如，数据类型为BINARY (3)，当插入a时，实际存储的是”a\0\0”
 
TEXT类型
 
用于表示大文本数据 
 比如，文章内容、评论等 
 类型分为4中，如下 
 TINYTEXT 
 取值范围：0~255字节 
 TEXT 
 取值范围：0~65535字节 
 MEDIUMTEXT 
 取值范围：0~16777215字节 
 LONGTEXT 
 取值范围：0~4294967295字节
 
BLOB类型
 
一种特殊的二进制类型 
 用于表示数据量很大的二进制数据 
 比如，图片、PDF文档等 
 分为4种，如下 
 TINYBLOB 
 取值范围：0~255字节 
 BLOB 
 取值范围：0~65535字节 
 MEDIUMBLOB 
 取值范围：0~16777215字节 
 LONGBLOB 
 取值范围：0~4294967295字节 
 BLOB和TEXT区别 
 BLOB类型数据，根据二进制编码进行比较和排序 
 TEXT类型数据，根据文本模式进行比较和排序
 
ENUM类型
 
枚举类型 
 定义如下 
 ENUM (‘值1’,’值2’,’值3’,……,’值N’) 
 上述的(‘值1’,’值2’,’值3’,……,’值N’)称为枚举列表 
 ENUM类型的数据，只能从枚举列表中取，而且，只能取一个 
 枚举列表中的值都有一个顺序编号，存入的是这个顺序编号，而不是列表的值
 
SET类型
 
用于表示字符串对象 
 它的值可以有0个，或多个。 
 SET类型的定义和ENUM类型类似 
 SET (‘值1’,’值2’,’值3’,……,’值N’) 
 与ENUM类型相同 
 (‘值1’,’值2’,’值3’,……,’值N’)列表中的每个值，都有一个顺序编号，MySQL中存储的是这个编号，而不是列表中的值
 
BIT类型
 
用于表示二进制 
 定义如下 
 BIT (M) 
 M表示每个值的位数，范围为1~64 
 注意 
 如果分配的BIT (M)的数据长度小于M，在数据的左边用0补齐 
 比如 
 BIT (6)类型的插入值为’101’，实际存储为’000101’

 第02章数据是用二进制数表示的
 
 热身问题
 
 1:32位是几个字节？
 
     4字节：8位为一个字节，所以是4个字节。
 
 
 
 
 2:二进制数0101 1100转换成十进制是多少？
 
     0*128+1*64+0*32+1*16 ＋ 1*8+1*4+0*2+0*0 ＝ 4+8+16+64 ＝ 92：将二进制各位数与位权相乘再相加即可。
 
 
 
 
 3:二进制数0000 1111左移两位后，会变成原数的几倍？
 
     4被：因基数为2，左移1位即为原值两倍，所以左移2位为原值4倍。
 
 
 
 
 4:补码形式表示的8位二进制数1111 1111，用十进制数表示的话是多少？
 
     －1:因＋1为1 0000 0000，9位，溢出一位，即为0，所以为－1；1111 1111的补数为求反加1，为0000 0001，因此补码表示的1111 1111为－1。
 
 
 
 
 5:补码形式表示的8位二进制数1010 1010，用16位的二进制数表示的话是多少？
 
     前面加8个1。此为符号扩充，符号扩充就是指在保持值不变的情况下将其转换成16位和32位的二进制数。不管是正数还是用补数表示的负数，都只需要用符号位的值（0或者1）填充高位即可。这就是符号扩充的方法。
 
 
 
 
 6:数值、字符串和图像等信息在计算机内部是以什么形式表现的？
 
     都是以二进制数值的形式来表现的。
 
 
 
 
 2.1 用二进制数表示计算机信息的原因
 
     IC(集成电路(Integrated Circuit))的特性，决定计算机的信息数据使用二进制数来处理更加合适。计算机处理信息的最小单位－－位，就相当于二进制中的一位。位的英文bit是二进制数位（binary digit）的缩写。二进制数的位数一般是8位、16位、32位等，也就是8的倍数（binary |ˈbaɪnəri| adj 由两部分组成的 二进制的；digit |ˈdɪdʒɪt| noun [0到9中的任何一个] 数字）。
 
     8位二进制数被称为一个字节（由bite一词衍生而来：byte）。字节是最基本的信息计量单位。位是最小单位，字节是基本单位（内存和磁盘都使用字节单位来存储和读写数据，使用位单位则无法读写数据。因此字节是信息最基本的单位）（byte |baɪt| noun 字节）。
 
 
 
 
 2.2 什么是二进制数
 
     二进制数的值转化成十进制数的值，只需要将二进制数的各位的值和位权相乘，然后将相乘的结果相加即可。十进制的基数为10，二进制的基数为2，若最右侧位数为1，以此向左逐个增加位数，各位的位权相当于基数的位数减1次冪。
 
 
 
 
 2.3 移位运算和乘除运算的关系
 
     位移运算指的是将二进制数的值的各个位依次向左或向右移动的运算。分为左移运算与右移运算。对于左移运算，右侧空出来的位直接补0，若移位操作使最高位溢出，溢出部分直接丢弃。在不存在溢出的情况下，每左移一位，二进制数值相应增加1倍。
 
 
 
 
 
 
 
 2.4 便于计算机处理的“补数”
 
     二进制数中表示负数时，一般会把最高位数作为符号使用，因此我们把这个最高位称为符号位。符号位是0时表示正数，符号位是1时表示负数。
 
     计算机在做减法运算时，实际上内部是在做加法运算。用加法运算来实现减法运算，为此，表示负数时就需要使用“二进制的补数”。补数就是使用正数来表示负数。
 
     以用8位表示－1的补数为例：－1的补数为1111 1111，－1的补数加上1等于1 0000 0000，溢出的最高位直接丢弃，即表示0。所以一个数的补数是将二进制的各位取反，再加1。
 
     补数求解的变换方法是“取反＋1”（无论正负一个数取反＋1都得到他的相反数（这些都是建立在使用有限位表示数，溢出的位直接丢弃）。
 
 
 
 
 2.5 逻辑右移和算术右移动的区别
 
     右移位运算分为逻辑右移与算术右移。移动后最高位补0称为逻辑右移动。右移后最高位补原本最高位的值称为算术右移，以负数为例，右移后依然是负数，正数右移后依然是正数。
 
     符号扩充：以8位二进制数为例，符号扩充就是指在保持值不变的情况下将其转换成16位和32位的二进制数。不管是正数还是用补数表示的负数，都只需要用符号位的值（0或者1）填充高位即可。这就是符号扩充的方法。

详解计算机内部存储数据的形式—二进制数
 
前言
 
要想对程序的运行机制形成一个大致印象，就要了解信息（数据）在计算机内部是以怎样的形式来表现的，又是以怎样的方法进行运算的。在 C 和 Java 等高级语言编写的
 程序中，数值、字符串和图像等信息在计算机内部都是以二进制数值的形式来表现的。也就是说，只要掌握了使用二进制数来表示信息的方法及其运算机制，也就自然能够了解程序的运行机制了。那么，为什么计算机处理的信息要用二进制数来表示呢？
 
一、用二进制数表示计算机信息的原因
 
计算机内部是由  IC（集成电路（ Integrated Circuit） ）这种电子部件构成的。 CPU（ 微处理器） 和内存也是 IC 的一种。IC 有几种不同的形状，有的像一条黑色蜈蚣， 在其两侧有数个乃至数百个引脚； 有的则像插花用的针盘， 引脚在 IC 内部并排排列着。== IC 的所有引脚， 只有直流电压0V 或 5VB 两个状态==。 也就是说， IC 的一个引脚， 只能表示两个状态。IC 的这个特性， 决定了计算机的信息数据只能用二进制数来处理。
 
计算机处理信息的最小单位——位， 就相当于二进制中的一位。 位的英文 bit 是二进制数位（ binary digit） 的缩写。
8 位二进制数被称为一个字节
位是最小单位，字节是==(信息的)基本单位==。
用字节单位处理数据时， 如果数字小于存储数据的字节数（二进制数的位数）， 那么高位上就用 0 填补。 例如， 100111 这个 6 位二进制数， 用 8 位（ =1 字节） 表示时为 00100111， 用 16 位（ = 2 字节） 表示时为 0000000000100111。
 
二、什么是二进制数
 
二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2，进位规则是“逢二进一”，借位规则是“借一当二”
二进制数的值转换成十进制数的值， 只需将二进制数的各数位的值和位权相乘，
 然后将相乘的结果相加即可。例如00100111转为十进制数是39
 
 为什么这样计算呢？其实二进制和十进制的思想是一致的，比如十进制数39=(3 x 101) +(9 x 100)，其中幂函数中10是基数， 这里和各个数位的数值相乘的 10 和
 1， 就是位权。二进制和十进制计算方式就是基数不同而已。
 
三、移位运算和乘除运算的关系
 
移位运算指的是将二进制数值的各数位进行左右移位（ shift = 移位） 的运算。 移位有左移（ 向高位方向）和右移（ 向低位方向） 两种。 在一次运算中， 可以进行多个数位的移位操作。
<< 这个运算符表示左移， 右移时使用 >> 运算符。 << 运算符和 >> 运算符的左侧是被移位的值， 右侧表示要移位的位数。
左移后空出来的低位要进行补0 操作
移位操作使最高位或最低位溢出的数字， 直接丢弃就可以了。例如十进制数 39 用 8 位的二进制表示是 00100111， 左移两位后是 10011100， 再转换成十进制数就是 156。
 
移位运算也可以通过数位移动来代替乘法运算和除法运算。左移两位后数值变成
 了原来的 4 倍。 十进制数左移后会变成原来的 10 倍、 100 倍、 1000 倍……同样，二进制数左移后就会变成原来的 2 倍、 4 倍、 8倍 …… 反之， 二进制数右移后则会变成原来的1/2、1/4、1/8…
 
四、表示负数的“补数”
 
二进制数中表示负数值时， 一般会把最高位作为符号来使用， 因此我们把这个最高位称为符号位。符号位是 0 时表示正数 ， 符号位是1 时表示负数。
那么－1 用 8 位二进制数来表示的话是什么样的呢？ 可能很多人会认为“1 的二进制数是 00000001， 因此－1 就是 10000001”，但这个答案是错的， 正确答案是 11111111。
计算机在做减法运算时， 实际上内部是在做加法运算。 用加法运算来实现减法运算， 为此， 在表示负数时就需要使用“二进制的补数”。补数就是用正数来表示负数。
补数如何获得？ 只需要将二进制数的各数位的数值全部取反 ，然后再将结果加 1
用 8 位二进制数表示－ 1 时， 只需求得 1，也就是 00000001 的补数即可。 具体来说， 就是将各数位的 0 取反成 1，1 取反成 0， 然后再将取反的结果加 1， 最后就转化成了 11111111
 
 
 那么，对于一个补数，如何知道它所代表的负数值是多少呢？这时我们可以利用负负得正这个性质。补数代表一个负数，那么补数的补数代表一个正数，这个正数取负就是这个补数的值。如 11111110，最高位是1，因此代表一个负数，11111110取反再加1为00000010。 这个是 2 的十进制数。 因此，11111110 表示的就是-2。
 
五、逻辑右移和算术右移的区别
 
 
当二进制数的值表示图形模式而非数值时，== 移位后需要在最高位补 0==。 类似于霓虹灯往右滚动的效果。 这就称为逻辑右移
 
 
将二进制数作为带符号的数值进行运算时， 移位后要在最高位填充移位前符号位的值（ 0 或 1）。 这就称为算术右移。即如果数值是用补数表示的负数值， 那么右移后在空出来的最高位补 1， 就可以正确地实现 1/2、 1/4、 1/8 等的数值运算。 如果是正数， 只需在最高位补 0即可。
 
 
 
只有在右移时才必须区分逻辑位移和算术位移。 左移时， 无论是图形模式（ 逻辑左移） 还是相乘运算（ 算术左移）， 都只需在空出来的低位补 0 即可。
 
 
符号扩充就是指在保持值不变的前提下将其转换成 16 位和 32 位的二进制数。
 
 
符号扩充的方法：不管是正数还是用补数表示的负数， 都只需用符号位的值（ 0 或者 1） 填充高位即可。如01111111 这个正的 8 位二进制数转换成 16 位二进制数是 0000000001111111 ； 11111111这个用补数表示的负数转换成 16 位二进制数是1111111111111111
 
 
 
在运算中， 与逻辑相对的术语是算术。 我们不妨这样考虑， 将二进制数表示的信息作为四则运算的数值来处理就是算术。 而像图形模式那样， 将数值处理为单纯的 0和 1 的罗列就是逻辑。
 
 
算术运算是指加减乘除四则运算。
 
 
逻辑运算是指对二进制数各数字位的 0 和 1分别进行处理的运算， 包括逻辑非（ NOT 运算）、 逻辑与（ AND 运算）、 逻辑或（ OR 运算） 和逻辑异或（ XOR 运算 A） 四种。
 
 
逻辑非指的是 0 变成 1、 1 变成 0 的取反操作。
 
 
逻辑与指的是“两个都是 1” 时， 运算结果为 1， 其他情况下运算结果都为 0 的运算
 
 
逻辑或指的是“至少有一方是 1” 时， 运算结果为 1， 其他情况下运算结果都是 0 的运算。
 
 
逻辑异或指的是排斥相同数值的运算。“两个数值不同”， 也就是说， 当“其中一方是 1， 另一方是 0” 时运算结果是 1， 其他情况下结果都是 0。
 
 
逻辑真值表如下
 
 

某大型社交互联网公司暑期实习生一面有个面试官出了这么一道题目，求一个数的二进制数中1的个数，如何求呢。
 
我的想法是这样的，对于一个int类型的正数，占了4字节共32位，平时把这个数转成二进制数我是这样计算的，假设这个数为num，先找一个2的n次方的数，这个数刚刚好比待解的数大，然后2的n-1次方比这个数小，即2^n > num > 2^(n-1)，那么我们就可以知道在num = 2^(n-1)+rest ，然后在剩下的部分用同样的方式，知道rest = 0。即用这种方式把这个数num分解成不同的2的幂的组合。
 
举个例子，7这个数，先找到2^3 = 8 ，比7大，即 2^3>7>2^2，所以 7 = 2^2 + 3 ，对于3 用同样的方式进行判断，先判断3是否大于2^（2 - 1）= 2^1，所以有 2^2>3>2^1，这个时候3 = 2^1+1，再判断1， 2^1>1>=2^0 ， 所以1 = 1^1 + 0，此时rest = 0，因此 7 = 2^2+2^1+1 。即 7 的二进制数为 111，因此在程序中，我们可以维持一个32个元素的boolean数组，相应的位置置为true，其他位置默认都是false，所以在7这个数中，数组的第0喂和第1位、第2位都是true，其他都是false。这样就可以得到7的二进制数组。程序用递归比较简单，但是效率不高，所以考虑用while循环替代，在输出的时候是输出一个字符串，由于打印需要多次拼接字符串，所以用StringBuffer这个类来拼接，效率比较高。
 
程序如下：
 
 
/*	程序来源：面试题
 * 	源文件名称：NumToBin.java
 *	要  点：
 *		输入一个数，输出它二进制中1的个数
 */
 
public class NumToBin{
	public static void main(String[] args){
		System.out.println(numToBin(65531));
	}
	
	public static String numToBin(int num){
		
		int c_num = num;	//拷贝副本
		int a = 1;			//初始为2的0次方1
		int pow = 0;		//2的pow次方
		boolean bools[] = new boolean[32];  		//数组变量存储1的位置
		StringBuffer s = new StringBuffer("");   	//由于要循环拼接字符串使用缓冲字符串类效率高
		int flag = 0;								//存储1的个数
		
		
		//从2的0次方开始找，找到刚好2^pow > num > 2^(pow-1)的数a ，这里^表示幂，即2的pow次方
		while(num>a){
			pow++;
			a*=2;
		}
		
		//这里开始由a往后找，每次找到一个小于等于num的数，
		//则num减去这个数，然后对应二进制数组中位置置1
		//然后继续找直到num为0
		while(num>0){
			if(num < a){
				a/=2;
				pow--;
			}else{
				num = num - a;
				bools[pow] = true;
			}
		}
		
		//找到num的二进制数组中的第一个为1的位置
		int index = -1;
		for(int i = 31;i>=0;i--){
			if(bools[i] == true){
				index = i;
				break;
			}
		}
		
		//循环拼接二进制字符串
		if(index>=0)
			for(int i = index;i>=0;i--){
				if(bools[i] == true){
					s.append(1);
					flag++;
				}else{
					s.append(0);
				}	
			}
		
		if(c_num == 0)
			return c_num + "\t二进制为:" + 0000 + "\t总共 ："+ flag +"\t个1";
		else
			return c_num + "\t二进制为:" + s.toString()+ "\t总共 ："+ flag +"\t个1";
	}
}

 

 
 
运行结果如图：
 


 
 
当然还有一种情况是如果int类型的数可能是正数也可能是负数，要是个负数怎么办呢，我们先来看看负数在计算机里面是如何表示的，定义是这样的：
 
---------------------------------------------------------------------分割线----------------------------------------------------------------------------
 
引用自：http://wenwen.sogou.com/z/q127021346.htm
 
 
在2进制中，负数是以它正值的补码形式表达
 
具体来分析一下：
 
原码：一个整数，按照绝对值大小转换成的二进制数，称为原码。
 比如 0000 0000 0000 0000 0000 0000 0000 0101是 5的 原码。
 反码：将二进制数按位取反，所得的新二进制数称为原二进制数的反码。
 
 取反操作指：原为1，得0；原为0，得1。（1变0; 0变1）
 
 比如：将5的二进制表达式的每一位取反，得
 1111 1111 1111 1111 1111 1111 1111 1010
 称：1111 1111 1111 1111 1111 1111 1111 1010 是 0000 0000 0000 0000 0000 0000 0000 0101 的反码。
 
 反码是相互的，所以也可称：
 1111 1111 1111 1111 1111 1111 1111 1010 和 0000 0000 0000 0000 0000 0000 0000 0101 互为反码。
 补码：反码加1称为补码。
 也就是说，要得到一个数的补码，先得到反码，然后将反码加上1，所得数称为补码。
 那么，5的补码为：
 
 1111 1111 1111 1111 1111 1111 1111 1010 + 1 =
 1111 1111 1111 1111 1111 1111 1111 1011
 
 所以，-5 在计算机中的二进制表达为：
 1111 1111 1111 1111 1111 1111 1111 1011
 转换为十六进制：0xFFFFFFFB。 
---------------------------------------------------------------------分割线----------------------------------------------------------------------------
 
所以其实很好解决，求一个负数在计算机中的二进制编码，我们只要求它的绝对值的数的反码再加上1，反码很好求，在我们可以求这个数的正数的二进制数组，我们只要按位取反就可以了，就到到反码的数组，然后还要加1，如何加1，其实可以在取反的时候同时进行，就是设置一个是否进位的标志位，初始化为true，从第一个开始判断，首先第一位是有进位的，因为要加1，这里有两种情况，第一种是如果第一位为0 ，那么取反后为1，然后接受进位加1，则变成0，然后再向前进位；第二种情况，是第一位为1，取反后为0，接受进位加1后为1，那么不需要进位了，则进位标志位false，然后第二位则根据进位标志为false知道不需要进位了。综合这两种情况，在有进位标志的情况下，其实相当于两次取反抵消，还是原来的值，所以直接判断原来的值是否为0，是则继续进位，否则不需要进位，具体代码如下（虚线内为在前一个版本中改动的）：
 
 
/*	程序来源：腾讯面试题
 * 	源文件名称：NumToBin2.java
 *	要  点：
 *		输入一个数，输出它二进制中1的个数，包括负数版本
 */
 
public class NumToBin2{
	public static void main(String[] args){
		System.out.println(numToBin(-1));
		System.out.println(numToBin(15));
		System.out.println(numToBin(-15));
	}
	
	public static String numToBin(int num){
		
		//-----------------------------
		int c_num;
		if(num<0) {
			c_num = num;	//拷贝副本
			num = num*(-1);		//num小于0则取绝对值   
		}else
			c_num = num;	//拷贝副本
		//-----------------------------
		
		int a = 1;			//初始为2的0次方1
		int pow = 0;		//2的pow次方
		boolean bools[] = new boolean[32];  		//数组变量存储1的位置
		StringBuffer s = new StringBuffer("");   	//由于要循环拼接字符串使用缓冲字符串类效率高
		int flag = 0;								//存储1的个数
		
		
		//从2的0次方开始找，找到刚好2^pow > num > 2^(pow-1)的数a ，这里^表示幂，即2的pow次方
		while(num>a){
			pow++;
			a*=2;
		}
		
		//这里开始由a往后找，每次找到一个小于等于num的数，
		//则num减去这个数，然后对应二进制数组中位置置1
		//然后继续找直到num为0
		while(num>0){
			if(num < a){
				a/=2;
				pow--;
			}else{
				num = num - a;
				bools[pow] = true;
			}
		}
		
		//-----------------------------
		//这里如果要转化的数是负数，那么要求其补码
		//如果进位标志位为true，那么要判断当前位置是否还需要进位
		//如果取反之后再加上进位的1后为0，那么需要进位
		boolean carry_flag = true;
		if(c_num<0){
			for(int i = 0;i<31;i++){
				if(carry_flag){
					if(bools[i])
						carry_flag = false;
				}else bools[i] = !bools[i];
			}
			bools[31] = true;
		}
		//-----------------------------
		
		//找到num的二进制数组中的第一个为1的位置
		/*
		int index = -1;
		for(int i = 31;i>=0;i--){
			if(bools[i] == true){
				index = i;
				break;
			}
		}
		*/
		
		//循环拼接二进制字符串
		for(int i = 31;i>=0;i--){
			if(bools[i] == true){
				s.append(1);
				flag++;
			}else{
				s.append(0);
			}
		}
		
		if(c_num == 0)
			return c_num + "\t二进制为:" + 0000 + "\t总共 ："+ flag +"\t个1";
		else
			return c_num + "\t二进制为:" + s.toString()+ "\t总共 ："+ flag +"\t个1";
	}
}
运行结果如下： 
 

 
 
 
自己的想法就是这样实现，暂时没有想到更简单的方法，如果有更巧妙简单的方法或者有什么错误的地方，请大家多多指导~~转载请注明出处。~