1）基本数据类型
Java的基本数据类型有8种，包括byte,char,short,int,long,double,float,boolean。
基本数据类型是基于数值的，因此它并没有类的概念，这一思想与Java是纯面向对象语言这一特点相违背，但是依旧没有将基本数据类型舍弃。
对于基本数据类型明显的优点就是：
<1>存储的是具体数值，没有操作数据的方法，占用的内存空间小；
<2>存储位置是在栈的局部变量表中，并且存储的是具体数值，有更高的性能。
当然，缺点也是显而易见的，就是没有操作数据的方法。
2）包装类
每种基本数据类型都对应一种包装类型。
3）具体行为细节(Integer)
构造方法：
/*根据int构建Integer*/
public Integer(int value) {
this.value = value;
}
/*将字符串转换成Integer类型*/
public Integer(String s) throws NumberFormatException {
this.value = parseInt(s, 10);
}
对于构造一个Integer类型的对象还可以使用下面的方法，但是其与使用new构造的是有区别的：
Integer a = 80;
<1>首先int 与Integer比较Integer会先自动拆箱为int，然后比较
int i9 = 128;
Integer i10 = new Integer(128);
System.out.println(i9==i10);//true
int i11 = 127;
Integer i12 = new Integer(127);
System.out.println(i11==i12);//true
<2>Integer与Integer比较，如果是通过int来创建的，在-128~127范围内是相等的，在范围外是不等的；如果是通过new 出来的则一定不相等(两个不同的对象，不可能相等的)。
因为对于通过int来的Integer对象实际是通过使用valueOf(int i)方法的，而valueOf(int i)中使用到Integer的缓存策略。对于-128 ~ 127内的值在创建Integer对象时候是存放在缓冲区的，当又有Integer创建该对象时候，则直接使用缓冲区里的。而对于范围外的使用int则是通过new一个对象创建的，所以对于int而来的Integer在-128 ~ 127两侧是有区别的
Integer i1 = 127;
Integer i2 = 127;
System.out.println(i1==i2);//true
Integer i3 = 128;
Integer i4 = 128;
System.out.println(i3==i4);//false
Integer i13 = new Integer(127);
Integer i14 = new Integer(127);
System.out.println(i13==i14);//false
Integer i15 = new Integer(128);
Integer i16 = new Integer(128);
System.out.println(i15==i16);//false
<3>Integer与Integer比较，通过int与new方法时候，都是不相等的，首先在范围内，int是直接存放在缓冲区而new是新建了一个对象，肯定不相等的，而范围外，则都是通过new对象新建的，也一定不相等。
Integer i5 = 127;
Integer i6 = new Integer(127);
System.out.println(i5==i6);//false
Integer i7 = 128;
Integer i8 = new Integer(128);
System.out.println(i7==i8);//false
parseInt(s,10);是将字符串s解析成指定参数(这里是10,也就是十进制)的进制，也就是按照指定进制解析字符串,解析成的是十进制的数，下面是源码：
public static int parseInt(String s, int radix)
throws NumberFormatException
{
/*
* WARNING: This method may be invoked early during VM initialization
* before IntegerCache is initialized. Care must be taken to not use
* the valueOf method.
*/
if (s == null) {
throw new NumberFormatException("null");
}
/*MIN_RADIX值为2，如果转成二进制以下，则抛出NumberFormatException异常*/
if (radix < Character.MIN_RADIX) {
throw new NumberFormatException("radix " + radix +
" less than Character.MIN_RADIX");
}
/*MAX_RADIX为36，如果转成36进制以上，也抛出异常*/
if (radix > Character.MAX_RADIX) {
throw new NumberFormatException("radix " + radix +
" greater than Character.MAX_RADIX");
}
//用于存放解析后的数据
int result = 0;
//负数flag
boolean negative = false;
int i = 0, len = s.length();
int limit = -Integer.MAX_VALUE;
int multmin;
int digit;
/*输入的字符串长度>0，方操作*/
if (len > 0) {
/*先对字符串的正负进行判断*/
char firstChar = s.charAt(0);
if (firstChar < '0') { // Possible leading "+" or "-"
if (firstChar == '-') {
negative = true;
limit = Integer.MIN_VALUE;
} else if (firstChar != '+')
throw NumberFormatException.forInputString(s);
if (len == 1) // Cannot have lone "+" or "-"
throw NumberFormatException.forInputString(s);
i++;
}
//正数得到-Integer.MAX_VALUE/radix；负数得到Integer.MIN_VALUE/radix
multmin = limit / radix;
while (i < len) {
// Accumulating negatively avoids surprises near MAX_VALUE
//将每位上的字符转成对应的数值，按照指定进制
digit = Character.digit(s.charAt(i++),radix);
//如果<0说明就不是字符
if (digit < 0) {
throw NumberFormatException.forInputString(s);
}
//如果转换后的超出该进制的范围就抛出异常
if (result < multmin) {
throw NumberFormatException.forInputString(s);
}
//如果转换后的在加上下一位后超出该进制的范围就抛出异常
result *= radix;
if (result < limit + digit) {
throw NumberFormatException.forInputString(s);
}
//采用减法将数加在result上
result -= digit;
}
} else {
/*否则抛出NumberFormatException异常*/
throw NumberFormatException.forInputString(s);
}
//如果是负数直接输出，如果是正数就加个负号输出
return negative ? result : -result;
}
Integer中的常量：
/*int数值所表示的最大值2^31-1。*/
@Native public static final int MIN_VALUE = 0x80000000;
/*int数值所表示的最小值-2^31*/
@Native public static final int MAX_VALUE = 0x7fffffff;
/*int的类实例*/
@SuppressWarnings("unchecked")
public static final Class<Integer> TYPE = (Class<Integer>) Class.getPrimitiveClass("int");
/**
* All possible chars for representing a number as a String
*/
final static char[] digits = {
'0' , '1' , '2' , '3' , '4' , '5' ,
'6' , '7' , '8' , '9' , 'a' , 'b' ,
'c' , 'd' , 'e' , 'f' , 'g' , 'h' ,
'i' , 'j' , 'k' , 'l' , 'm' , 'n' ,
'o' , 'p' , 'q' , 'r' , 's' , 't' ,
'u' , 'v' , 'w' , 'x' , 'y' , 'z'
};
/*用于表示二进制补码二进制形式的 int值的位数*/
public static final int SIZE = 32;
/*用于表示二进制补码二进制形式的 int值的字节数。*/
public static final int BYTES = SIZE / Byte.SIZE;
常用方法：
String toString():返回字符串类型的表示该Integer对象
public String toString() {
return toString(value);
}
String toString(int i):将i按照十进制转成字符串
public static String toString(int i) {
//如果超出Integer的取值范围直接返回最小值
if (i == Integer.MIN_VALUE)
return "-2147483648";
//根据是正数还是负数，然后定义字符串长度
int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
char[] buf = new char[size];
//
getChars(i, size, buf);
//将char数值转成字符串
return new String(buf, true);
}
getChars(int i, int index, char[] buf):
将表示整数i的字符放入字符数组buf中。字符从指定索引处的最低有效数字（不包括）开始向后放入缓冲区，并从那里向后工作。（api中解释）。应该就是将指定的数i装进字符数组buf中。
static void getChars(int i, int index, char[] buf) {
int q, r;
int charPos = index;
char sign = 0;
if (i < 0) {
sign = '-';
i = -i;
}
// Generate two digits per iteration
while (i >= 65536) {
q = i / 100;
// really: r = i - (q * 100);
r = i - ((q << 6) + (q << 5) + (q << 2));
i = q;
buf [--charPos] = DigitOnes[r];
buf [--charPos] = DigitTens[r];
}
// Fall thru to fast mode for smaller numbers
// assert(i <= 65536, i);
for (;;) {
q = (i * 52429) >>> (16+3);
r = i - ((q << 3) + (q << 1)); // r = i-(q*10) ...
buf [--charPos] = digits [r];
i = q;
if (i == 0) break;
}
if (sign != 0) {
buf [--charPos] = sign;
}
}
String toString(int i,int radix):将i按照radix指定的进制转成字符串
public static String toString(int i, int radix) {
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
radix = 10;
/* Use the faster version */
if (radix == 10) {
return toString(i);
}
char buf[] = new char[33];
boolean negative = (i < 0);
int charPos = 32;
if (!negative) {
i = -i;
}
while (i <= -radix) {
buf[charPos--] = digits[-(i % radix)];
i = i / radix;
}
buf[charPos] = digits[-i];
if (negative) {
buf[--charPos] = '-';
}
return new String(buf, charPos, (33 - charPos));
}
对于常用的进制转化有以下方法：
转二进制：
public static String toBinaryString(int i) {
return toUnsignedString0(i, 1);
}
转十六进制
public static String toHexString(int i) {
return toUnsignedString0(i, 4);
}
转八进制
public static String toOctalString(int i) {
return toUnsignedString0(i, 3);
}
valueOf(String s ,int redix):将指定字符串按照指定进制的Integer类型的数
public static Integer valueOf(String s, int radix) throws NumberFormatException {
return Integer.valueOf(parseInt(s,radix));
}
valueOf(int i):将i转成Integer类型实例
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
valueOf(String s):指定字符串转成十进制Integer类型实例
public static Integer valueOf(String s) throws NumberFormatException {
return Integer.valueOf(parseInt(s, 10));
}
parseInt()与valueOf()的区别：
<1>两者都是将字符串转成"整型"；
<2>parseInt()是转成int类型的，而valueOf()是转成Integer类型的，在valueOf()方法中就使用到了parseInt()方法，然后再进行装箱操作。
2.常见面试
1） short s1 = 1;s1 = s1+1;与short s2 = 1;s2 += s2;的分别？
s1是short类型的，而s1 = s1+1;中的1默认是int类型的，s1+i(int类型)会自动将计算结果升为int类型的，而将int类型的值给short类型会出现类型转换错误。而s2+=s2;其中+=是java规定的运算符，会做特殊处理，不会出现错误。
类型转换：Java语言是一种强类型语言，因此变量或者常量必须有类型，而每种类型都是有区别的，不同类型的值在转换的时候是有规则的：
<1>自动类型转换：编译器自动完成，不需要在程序中完成的。其明显特点就是从小到大，有以下顺序：byte->short(char)->int->long->float->double；但是由于在存储时候精度问题会造成数据精度的损失。
<2>强制类型转换：也就是需要在程序中完成的转换，必须通过手动方式完成。顺序与自动类型转换正好相反double->float->long->int->short(char)->byte;语法(int 转short)int i = 10;
short i2 = (short)i;强制类型转换通常都会造成精度损失。
2）int与Integer的区别
<1>int是Java的8种基本数据类型中的一种，并不是类，Integer是Java对int的包装类；
<2>int存储的是具体数值，存放在栈的局部变量表中,并且没有具体的操作方法，而Integer则是对应的对象，应该是在堆内存中的，存在对对象的操作方法；
<3>int类型的初始值是0；而Integer的初始值的null。
3）"=="与equals的区别：
"==",在比较基本数据类型的时候是比较的是数值大小；
在比较引用数据类型的时候是比较的地址，两个对象是否为同一个对象的引用；
equals:只能用于比较基本数据类型，是比较的是内容是否相等。
4）"<<",">>,">>>"的区别
"<<"是无符号左移，不足补0；
">>"是有符号右移，原来是正数补1，负数补0；
">>>"是无符号右移，一律补0。
5）char能否存储一个汉字？
能的，Unicode字符集中包含了汉字，Unicode大多是16位的，而char是取值范围是16位因此能存储，但是对于有些生僻字是不可以的。
6）byte a = 127; a+=5;输出a是多少？
是-124；对于byte的取值范围是-128 ~ 127，当a+=5后应该是132，但是由于取值范围，所以a+=1后a就是-128了，然后a+4就是-124了（通过二进制可以明显看出）。
7）java 中float a = 3.4;是否正确？
是不对的，3.4是双精度类型，属于double,而double转float必须强制类型转换，这里没用，是不对的，应该float a = (float)3.4;或者使用f标识3.4为单精度，也就是float a = 3.4f;
8)float及double的组成：
浮点型都是使用科学计数法存储的，也就是分成三部分，分别是:
符号位：0为正数，1为负数
指数位：指数数据
尾数部分：尾数数据。
注意：浮点型在进行运算的时候大多会出现精度损失！！
9）switch语句能否作用在byte,short,long,String上？
jdk1.7之前是除了String,long,double,float都可以的，jdk1.7之后除了long,double,float都是可以的。switch是支持int类型的，而byte、char、short都是可以隐式转换的，而long,,double,float不可以，因此long始终是不可以的。
