1.Int
int与integer的区别从大的方面来说就是基本数据类型与其包装类的区别：
int 是基本类型，直接存数值，而integer是对象，用一个引用指向这个对象
1.Java 中的数据类型分为基本数据类型和复杂数据类型
int 是前者而integer 是后者（也就是一个类）；因此在类进行初始化时int类的变量初始为0.而Integer的变量则初始化为null.
初始化时，int i =1；Integer i= new Integer(1);(要把integer 当做一个类看)；但由于有了自动装箱和拆箱
使得对Integer类也可使用：Integer i= 1；
int 是基本数据类型（面向过程留下的痕迹，不过是对java的有益补充），Integer 是一个类，是int的扩展，定义了很多的转换方法
类似的还有：float Float;double Double;string String等，而且还提供了处理 int 类型时非常有用的其他一些常量和方法
再如：
举例说明
ArrayList al=new ArrayList();
int n=40;
Integer nI=new Integer(n);
al.add(n);//不可以
al.add(nI);//可以
并且泛型定义时也不支持int: 如：List<Integer> list = new ArrayList<Integer>();可以 而List<int> list = new ArrayList<int>();则不行
总之，
如果我们定义一个int类型的数，只是用来进行一些加减乘除的运算or作为参数进行传递，那么就可以直接声明为int基本数据类型，但如果要像
对象一样来进行处理，那么就要用Integer来声明一个对象，因为java是面向对象的语言，因此当声明为对象时能够提供很多对象间转换的方式，与一些常用
的方法。自认为java作为一们面向对象的语言，我们在声明一个变量时最好声明为对象格式，这样更有利于你对面向对象的理解。
2.Short
这里，我首先说一下，Java中整数类型的使用大同小异，只是使用的时候注意下数据的范围即可。好了，我们继续向下学习，给出使用short的例子先：
Java代码
- publicclass MainClass {
- public static void main(String[] arg) {
- short Number = 1234;
- out.println(Number);
- }
- }
上面代码中我们声明了一个short型变量名为smallNumber，并给它赋值为1234，然后在控制台打印出来。例子代码大家可以自己运行下，这里没有什么可讲解的，还是提醒注意变量的范围。
short间的计算
我给出一个short间计算的例子，大家稍微注意下代码：
Java代码
- publicclass MainClass {
- public static void main(String[] args) {
- short A = 5;
- short B = 10;
- short C = 0;
- C = (short) (A + B);
- out.println(C);
- }
- }
代码在上面，我们看看要注意的地方是什么。大家注意第7行，看到(short)。这里对它做下解释，(DataType)的意思是强制类型转换，在Java里short间的计算的结果会被转换为integer，因此要赋值给short型的变量numC的时候需要强制转换为对应的short类型，否则Java编译器会报错。大家可以自己试试！
short 16位 最大是 2^15,最小－32768
shortint -128..128 1 带符号8位
inteter -32768..32767 2 带符号16位
longint -2147483648..2147483647 4 带符号32位
byte 0..255 1 带符号8位
word 0..65535 2 带符号16位
实例
<blockquote>
public class MainClass {
public static void main(String[] arg) {
short smallNumber = 1234;
System.out.println(smallNumber);
}
}
</blockquote>
short s = 1;
为什么s = 1没错,
s = s 1就有错?问题补充：
原来是赋值的时候类型不匹配,而不是相加的时候类型不匹配,
s = (short)(s 1);
解析
首先看“s = s 1”为什么错。
Java编译器认为一个像“1”这样的直接数是一个int型。Java的自动类型转换是一个占用空间少的类型可以自动转换成占用空间大的类型，反之则必须强制类型转换，否则报错。“s 1”这个表达式因为是short型和int型相加，因此自动转换成了int型，此时再用“s = s 1”赋值给一个short型而没有强制类型转换那么自然报错。
而至于为什么 s = 1 没有错我认为没有必要深入研究，你既然发现了这个事实，那么知道就行了，也许Java的设计者当初对它做了特殊处理
3.Long
long 是java中的基本数据类型，叫做长整型
long: 64位整数 -9,223,372,036,854,775,808—— 9,223,372,036,854,775,807，一般不需要用
long首字母区分大小写。所以long和Long是不一样的
Long是对象类型（类）
Long又叫 long的包装类
Java中long和Long有什么区别(转)
Java的数据类型分两种：
1.基本类型：long,int,byte,float,double,char
2. 对象类型（类）： Long,Integer,Byte,Float,Double,Char,String,其它一切java提供的，或者你自己创建的类。
其中Long又叫 long的包装类。而Byte和Float也类似，一般包装类的名字首写是数值名的大写开头。
什么叫包装类？
在java中有时候的运算必须是两个类对象之间进行的，不充许对象与数字之间进行运算。所以需要有一个对象，这个对象把数字进行了一下包装，这样这个对象就可以和另一个对象进行运算了。
比如我们也可以定义一个类：
class Long {
int i=0;
public Long (int i){
this.i=i;
}
}
这样这个Integer就是一个包装类，他包装了一个整数值，然后可以在里面写一些运算符重载的方法使它支持某些运算。这个时候可以赋值：
Long it=new Long(10);
现在变量it就是一个对象，不是一个数字。
long 是长整型，在怎么长本身也是整型，12.10的整形部分是12，当然结果是12，
byte: 八位整数 -128——127，可用来节省内存的使用。
short: 16位整数 -32768——32,767，也比较省内存。
int: 32位整数 -2,147,483,648——2,147,483,647，一般来说整数都够用了
long: 64位整数 -9,223,372,036,854,775,808—— 9,223,372,036,854,775,807，一般不需要用
float: 32位浮点，如果浮点需要节省内存用这个。
Double: 64位浮点，一般非整数浮点可用这个。
但是要记住float和double都不是精确的，如果要储存钱一类的必须精确的，用java.math.BigDecimal
4.Byte
最近因为在做金融项目，里面对byte的操作要求比较多，所以在这里整理了一下关于Java中的byte类型。
Java虚拟机中没有byte类型
恩。。。怎么说呢，个人感觉这个说法有点儿唬人的意思。的确，当这个想法刚刚出现在我的脑海中的时候我觉得也有些胡扯，毕竟byte类型就在那里，怎么能说Java虚拟机中没有byte类型呢？
好吧，我来稍稍的解释一下。Java虚拟机对基本类型的操作基本都是在栈上完成的（这个是可信的，因为不是我说的）。我们知道，Java在处理一个语句的时候，首先它会先把用到的操作数压到栈中，然后再从栈中弹出进行计算，最后将结果再压回到栈中。任何对byte的操作也会如此。因此，Java对byte类型操作之前会将其压入到栈中。实际上，Java压入栈的不是byte类型，而是一个标准的int类型（32位，byte是8位），也就是说，Java虚拟机将我们短小可爱的byte类型压入栈之前，会先把它拉长成int类型再压栈。（不过事实上在压栈之前也是int类型）这样一来，我们不管是在栈里还是从栈里弹出的byte类型实际上都是用int的长度存储的。这也就是我为什么说，Java虚拟机中没有byte类型。因为它们都被变成了int。
int？还是byte？
这么说来在Java虚拟机中处理来处理去的都是32位长的int，那么byte怎么办？换句话说，如果我们看到一个32位的int，那我们应该管它叫int呢还是叫byte呢？（这句话有些拗口，我会在下次换一种描述的）
对于这个问题，我个人的答案是你叫丫虾米丫就是虾米。举个例子来说吧：现在栈顶端有两只。。。恩。。。32位长的。。。恩。。。你明白我的意思。你想对它们进行相加运算。在这个时候你的作用就很明显了，当你对虚拟机说把它们俩给我相加成一个整数（int），那么Java虚拟机会弹出这两个东西，然后相加，将结果以int类型压回到栈中。但是如果你对虚拟机说：把这两个byte相加成一个byte或者把它们俩相加成一个byte，那么Java虚拟机还是会弹出这两个东西相加，只不过前面那句会先将它们俩转换成byte再变成int，然后相加；而后面那句会直接相加。两句的最后结果都是将相加的和先转换成byte然后在变成int压入栈中。
类型转换
那么，类型转换呢？这个总该是一个byte了吧！
可惜，我只能说类型转换的过程中会出现真正的byte，但是它活不到最后就被拉长了。举个例子吧，看看下面我从有意义的程序中找出的两句毫无意义的代码吧：
| int a = 1; byte b = (byte)a; |
好吧，我承认会这么写的代码，程序也不会有意义到哪儿去。但是我们就事论事。当我刚开始看到这个的时候，我非常兴奋的认为上面的那个变量b总应该是byte了吧。如果你和我一样，那么恭喜你离天才又进了一步。
我只能说答案是否定的。不是为了打击你，而确确实实是否定的。是的，第二句在执行的时候确实产生了一个byte，但是很不幸，它没能活到最后。最终它被拉长成了int压入了栈中，用来做为byte变量b的值。虽然它被拉长成了32位的int，但是毕竟它是byte来的，所以身上还是有byte的血统的。怎么说呢，那就是它是被虚拟机带着符号扩展出来的。这个很好理解，byte本身就是8位0或者1的组合，你就是把8位上每一位0或者1拉的再长，充其量也就是长的长一些的0或者1的byte。所以要想变成32位，你得给byte填补24位进去。那么这24位从哪里来呢？Java虚拟机的做法就是从byte的符号位（也就是最高位）来。这就是所谓的带符号扩展。就拿上面的程序举例子吧，将1压缩成byte用二进制来看是00000001，这个我想大家都不陌生。接下来就是扩展，我们byte的符号位是正，也就是0，那么Java虚拟机就会用0来填充剩下的24位，结果就是00000000000000000000000000000001。自己数一下看我是不是漏掉了。
大家可能觉得我举的例子有些太简单了，好吧，我来说一个难的。让byte变量b等于-1。当然，不是简简单单的从-1的int类型变成-1的byte类型，而是找一个正整数的int类型，让Java虚拟机截短成-1的byte类型。那么这个正整数是几呢？说实话，我拿高级计算器试了一天，最后从google上找到了它：2147483647。只要把上面语句中a的值改成这个，byte变量b的值就会是-1。非常简单，我觉得不需要解释。
。。。
。。。
我还是解释一下吧：那个2147483647整数的二进制是这样的：01111111111111111111111111111111，仔细数，是32位。现在我们要把它强制转换成byte，只有8位，所以Java虚拟机不假思索的给咱们砍掉24位，剩下8位都是1：11111111，这个当然就是那个-1了。什么？你说不是？是-127？不不不不，不要忘了，Java虚拟机中使用补码来表示的，你看到的是补码。这次再算算，-1了吧。好了，接下来就是扩充回int类型了。简单的把符号位复制24个出来就好了，结果就是11111111111111111111111111111111。这个是几？自己算吧。
总结
好了，说了这么多，我们也看到了，虽然Java虚拟机中的操作数可以是一个byte，但是不管是运算也好还是类型转换也好，最终的结果都是int。至于在执行过程中如何区别，那就全靠写程序的人自己了。如果你自己都模棱两可的话，不要指望Java虚拟机会明白你的意思。
Java中的byte类型及用法
在学习编程的过程中，我觉得不止要获得课本的知识，更多的是通过学习技术知识提高解决问题的能力，这样我们才能走在最前方，更多Java学习，请登陆疯狂Java培训官网。
Java中的byte类型及用if-else对三个数排序
1、byte类型是Java的基本数据类型，占一个字节，2^8，表数范围：-128~127
[java]
public class TestByte {
public static void main(String[] args) {
byte b1 = 1;
b1++;
b1 = b1 + 1;
}
}
编译时出现以下错误：
TestByte.java:5: 错误: 可能损失精度
b1 = b1 + 1;
需要: byte
找到: int
1 个错误
是因为 b1 + 1 中的常量 1 是默认为一个 int 类型数据，相加结果不能赋给byte 类型
[java]
byte b1 = 1;
byte b2 = 1;
byte b3 = 1 + 1;
byte b4 = b1 + b2; //可以改为byte b4 = (byte)(b1 + b2)
编译时第 4 行还是出现同样的问题，因为 byte 在计算时首先要转换为 int 类型，其结果也不能赋给 byte 类型。
3 行和4 行的区别：编译器在编译时，在判断右边数值的时候发现是 int 类型(是“常量”)，但会判断是不是在 byte 类型(-128~127)范围之内，如果在这个范围之中的话，会给右边的 int 类型做默认的强制转换，把最后的一个字节赋值到了 b3 这个变量当中，b1 和 b2 是“变量”意味着这两个值不确定、可能随时变化，编译器无法检查，也无法确定是否在 byte 类型范围之内，检查不了就会报错(可能丢失精度)，如果是“常量”编译器就能够判断。
2、输入 3 个数，再按从小到大的顺序输出过程：
1，导入类 util.java
2，创建 scanner 对象
3，调用 scanner 对象的 nextInt() 方法返回一个 int 类型数据
4，排序，先对 num1 和 num2 排序，num1 存放小的，num2 存放大的，num3 就
只有三个可能
?num3? num1 ?num3? num2 ?num3?
—————-+———————-+—————>
小 大
code list:
[java]
import java.util.Scanner;
public class TestSort {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print(“num1=”);
int num1 = scanner.nextInt();
System.out.print(“num2=”);
int num2 = scanner.nextInt();
System.out.print(“num3=”);
int num3 = scanner.nextInt();
int tmp;
if (num1 > num2) {
tmp = num1;
num1 = num2;
num2 = tmp;
}
if (num3 > num2) {
System.out.print(num1 + ” ” + num2 + ” ” + num3);
} else if (num3 > num1) {
System.out.print(num1 + ” ” + num3 + ” ” + num2);
} else {
System.out.print(num3 + ” ” + num1 + ” ” + num2);
}
}
}
5.Boolean
”boolean“类型的值只有两个，即:false和true；通常都用在条件判断中
boolean bl = true;
if(bl){ //代码分支}else{//另外一个代码分支}；
解释：上面定义了一个波尔类型，它的值为真，下面的条件判断中会直接走进第一个”真“的分支。、
备注：以上方法只是一个简单的举例，实际应用中”boolean“的值需要大量的条件判断，最后获取到是”真“或者”假“，但实现思路都是一致的，当”真“的时候做某些操作，其他情况进行相应的操作。
boolean类型是指 真和假 的类型.只有两种值:true和false
boolean[] bool = new boolean[n];这句是指创建一个布尔型的数据(boolean默认值为false).
由于变量bool是布尔数组,所以数组中的某一个元素 bool[num]就表示真或者假,可以用它直接作为判断条件.
只能是true或false两个值之一的变量就是布尔（boolean）类型变量，true和false是布尔型直接量。你可以用下面的语句定义一个名称为state的布尔型变量：
| 1 | boolean state=true |
该语句用true值对变量state进行了初始化。你也可以使用赋值语句为一个boolean型变量赋值。例如，语句，
| 1 | state=false |
设置变量state的值为false.
目前，我们除了为布尔变量赋值外，还不能进行更多的操作，但正像你在下一章中将要看到的，布尔型变量在程序做判定时，特别是在我们能够用表达式产生一个boolean型结果时显得更加有用。
有几个组合布尔型数值的运算符，包括：布尔与（AND）,布尔或（oR）和布尔非（它们分别对应&&、11、！）,以及产生boolean型结果的比较运算符。与其现在抽象地学习它们，到不如我们推迟到下一章，在那里，我们可以在练习中看到如何应用它们改变程序的执行顺序。
有一点你需要注意，boolean型变量不同于其他的基本数据类型，它不能被转换成任何其他的基本类型，其他的基本类型也不能被转换成boolean类型。
Java生成Boolean对象的三种方法之比较
Java生成Boolean对象的第一种常见方法是通过new操作符
| 1 | Boolean boolean1 = new Boolean(1==1); |
第二种是通过静态方法valueOf
| 1 | Boolean boolean1 = Boolean.valueOf(1==1); |
第三种是JDK1.5之后的自动装箱
| 1 | Boolean boolean1 = 1==1; |
这三种方法有什么区别呢？
先看一段代码
| 1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Boolean[] boolean1 = new Boolean[100];
Boolean[] boolean2 = new Boolean[100]; Boolean[] boolean3 = new Boolean[100]; for (int i = 0; i < 100;i++){ boolean1[i] = Boolean.valueOf(1==1); } for (int i = 0;i < 100;i++){ boolean2[i] = new Boolean(1==1); } for (int i = 0; i < 100;i++){ boolean3[i] = 1==1; } System.out.println(“valueOf: ” + String.valueOf(boolean1[1] == boolean1[2])); System.out.println(“new Boolean: ” + String.valueOf(boolean2[1] == boolean2[2])); System.out.println(“auto wrap: ” + String.valueOf(boolean3[1] == boolean3[2])); |
输出结果是：
| 1
2 3 |
valueOf: true
new Boolean: false auto wrap: true |
为什么会这样呢？
原因就在于用new创建的Boolean对象是不断的新创建一个实例对象，而valueOf则是返回Boolean类里的静态成员变量，不会产生大量相同的实例变量。自动包装和valueOf类似.
实际上jdk文档也是建议用valueOf代替new方式来创建Boolean类对象。
6.Float AND 7.Double
float表示单精度浮点数在机内占4个字节，用32位二进制描述。
double表示双精度浮点数在机内占8个字节，用64位二进制描述。
浮点数在机内用指数型式表示，分解为：数符，尾数，指数符，指数四部分。
数符占1位二进制，表示数的正负。
指数符占1位二进制，表示指数的正负。
尾数表示浮点数有效数字，0.xxxxxxx,但不存开头的0和点
指数存指数的有效数字。
指数占多少位，尾数占多少位，由计算机系统决定。
可能是数符加尾数占24位，指数符加指数占8位 — float.
数符加尾数占48位，指数符加指数占16位 — double.
知道了这四部分的占位，按二进制估计大小范围，再换算为十进制，就是浮点数的数值范围。
对编程人员来说，double 和 float 的区别是double精度高，有效数字16位，float精度7位。但double消耗内存是float的两倍，double的运算速度比float慢得多，java语言中数学函数名称double 和 float不同，不要写错，能用单精度时不要用双精度（以省内存，加快运算速度）。
- char
java中的char类型
- 编辑
- 删除
一：char的初始化
char是Java中的保留字，与别的语言不同的是，char在Java中是16位的，因为Java用的是Unicode。不过8位的ASCII码包含在Unicode中，是从0~127的。
Java中使用Unicode的原因是，Java的Applet允许全世界范围内运行，那它就需要一种可以表述人类所有语言的字符编码。Unicode。但是English，Spanish，German, French根本不需要这么表示，所以它们其实采用ASCII码会更高效。这中间就存在一个权衡问题。
因为char是16位的，采取的Unicode的编码方式，所以char就有以下的初始化方式：
char c=’c’; //字符，可以是汉字，因为是Unicode编码
char c=十进制数，八进制数，十六进制数等等; //可以用整数赋值
char c=’\u数字’; //用字符的编码值来初始化，如：char=’\0′,表示结束符，它的ascll码是0，这句话的意思和 char c=0 是一个意思。
二：关于char占几个字节的问题如下：
1：“字节”是byte，“位”是bit ；
2： 1 byte = 8 bit ；
char 在java中是2个字节。java采用unicode，2个字节（16位）来表示一个字符。
例子代码如下：
[java] 代码
- publicclass Test {
- public static void main(String[] args) {
- String str= “中”;
- char x =’中’;
- byte[] bytes=null;
- byte[] bytes1=null;
- try {
- bytes = str.getBytes(“utf-8”);
- bytes1 = charToByte(x);
- } catch (UnsupportedEncodingException e) {
- // TODO Auto-generated catch block
- printStackTrace();
- }
- out.println(“bytes 大小：”+bytes.length);
- out.println(“bytes1大小：”+bytes1.length);
- }
- public static byte[] charToByte(char c) {
- byte[] b = new byte[2];
- b[0] = (byte) ((c & 0xFF00) >> 8);
- b[1] = (byte) (c & 0xFF);
- return b;
- }
- }
运行结果：
bytes 大小：3
bytes1大小：2
java是用unicode来表示字符，”中”这个中文字符的unicode就是2个字节。
String.getBytes(encoding)方法是获取指定编码的byte数组表示，
通常gbk/gb2312是2个字节，utf-8是3个字节。
如果不指定encoding则取系统默认的encoding。
本文来自网络–原地址已丢失（若原作者看到请留下原链接）
