3 数据的类型
- 基本数据类型-原始数据类型
- 引用数据类型
3.1 基本数据类型
基本数据类型:8种 byte,short,int,long,float,double,char,boolean
归纳分类:
整数类型:4种 byte,short,int,long
浮点类型:2种 float,double
字符类型:1种 char
布尔类型:1种 boolean
(1)整数类型:
byte(不常用):也叫字节类型,在内存中占8位二进制,即在内存中占1字节大小的空间,
是数据存储的最小单位。
0000 0000 0 =============>为了计数考虑正负,零开头为正,1开头为负
0111 1111 127
1000 0000 -128
1000 0001 -127
1111 1111 -1
范围:-128~127
幂表示:-2^7~2^7-1
short(不常用):也叫短整型。在内存中占16位二进制,2字节大小。
0000 0000 0000 0000 0
0111 1111 1111 1111 32767
1000 0000 0000 0000 -32768
1111 1111 1111 1111 -1
范围:-32768~32767
幂表示:-2^15~2^15-1
int(常用):也叫整型。在内存占32位二进制,4字节大小。
范围:-2147483648~2147483648
幂表示:-2^31~2^31-1
long(常用):也叫长整型。在内存占64位二进制,8字节大小。
范围:正负922亿亿左右
幂表示:-2^63~2^63-1
/**变量类型例子*/
public class TypeDemo01{
public static void main(String[] args){
/*
在给变量赋值时,直接写的整数值,默认的就是
int类型的数,在内存占32位数。
在给byte,和short类型的变量赋值时,直接写的整数值,
只要没超出相应的类型的范围,就不会出现编译错误(语法错误)
直接写的整数值,叫字面量
*/
int a=10;//0000 0000 0000 0000 0000 0000 0000 0101
byte b=10;
short c=10;
//byte d=128;//类型不匹配,可能会有精度损失
/*
int类型的所有数值计算结果一定都是32位。
0111 1111 1111 1111 1111 1111 1111 1111
+ 0000 0000 0000 0000 0000 0000 0000 0001
= 1000 0000 0000 0000 0000 0000 0000 0000----->-2147483648
封闭式运算:
max+1 等于min
min-1 等于max
*/
int max=2147483647;
int count=max+1;
System.out.println(count);
byte b1=10;
byte b2=10;
int b3=b1+b2;//b1与b2运算期间,又变成32位二进制
System.out.println("--------分割线-------------");
long l1=10;//32位的10,存入l1,自动添加32个0
long l2= -10;//32位的-10,存入12,自动添加32个1
System.out.println(l1);
System.out.println(l2);
long l3=l2;//l2中的数据复制一份到l3中
System.out.println(l3);//-10
l3=1000;
System.out.println(l3);
/*
如果想直接赋值64位的字面量整数时,需要在数值后添加L/1
*/
long l4=12L;//64位的12存入l4中
long l5=-12l;//64位的-12存入l5中
long l6=2147483647+1;/*32位加32位最后还是32位,封闭计算
结果-2147483648*/
System.out.println(l6);
long l7=2147483647+1L;
System.out.println(l7);//32位加64位得出64位
}
}
(2)浮点数类型;2种---小数类型
float:在内存中占4字节大小,32位二进制
范围: -3.403E38~3.403E38
double: 在内存中占8字节大小,64位二进制
范围:-1.79E308~1.79E308
字面量:默认类型为double,即64位的浮点数类型
如果想直接写32位的浮点数,需要在数值后添加f/F
比如: double num=3.14;
float num1=3.14F;
/**
浮点数类型的学习
float,double
数值字面量为double类型,
直接写float类型的数值时,需要添加F/f
*/
public class TypeDemo02{
public static void main(String[] args){
/*浮点数赋值方式;
3.14;1.2E;.512
*/
double a=3.14;
System.out.println(a);
double b=1.2e2;
System.out.println(b);
double c=.512;
System.out.println(c);
double d=.123E2;
System.out.println(d);
float h=3.14F;
System.out.println(h);
//float j=.512FE2;//错误写法
float i=.512E2F;//正确写法
System.out.println(i);
/*
将数值1.1234567890123456789分别存入float的变量m中和double的变量n中,
然后输出,查看结果。
输出的结果分别为:
1.1234568
1.1234567890123457
发现:
浮点数在存储数据时,会有舍入误差,即不够精确,但是double要比float
更精确一些(相比floata,要精确多一倍)
double:双精度浮点数类型
float:单精度浮点数类型
*/
float m=1.1234567890123456789F;
System.out.println(m);
double n=1.1234567890123456789;
System.out.println(n);
/*
浮点数类型无法精准表示1/10,就像10进制数无法表示1/3一样。
所以在运算时,多数情况下都是不精确运算
*/
double n1=3.15;
double n2=2.5;
double n3=n1-n2;
System.out.println(n3);
}
}
(3)字符类型:char 在内存中占2字节大小,16位二进制。
赋值特点:1)值中有且只有一个字符;2)字符必须使用单引号引起来.
另外特点:底层二进制是无符号的整数类型即0~2^16-1---->0~65535
所以赋值时,也可以赋值整数,但是存入变量空间后,其实是其整数对应的字符。
java语言默认使用的字符集为unicode。
unicode字符集:
无论字母,还是汉字,都占两个字节大小
'A'-----00000000 01000001
'a'-----00000000 01100001
'O'-----00000000 00110001
什么是字符集:即二进制与字符的一一对应关系的表
常见字符集: GBK、 GBK2312、 UTF-8
java语言常用的字符: 'A'-'Z'->65~90
'a'-'z'->97-122
'0'-'9'->48-57
java语言中的转义字符: '\':将特殊字符变成相应意义的字符。
java语言中的特殊字符:单引号、双引号、制表符、换行符、回车符号
'\''---->单引号
'\"'---->双引号
'\\'---->反斜线
'\t'---->制表符
'\r'---->换行符(有翻页效果,看不到上一页的数字)
/* 在不同的控制台内部会有不同的效果,
有的平台只有换行效果不翻页 */
'\n'---->回车符
需求:查看字符集中某一字符对应的整数,将字符赋值给int类型的变量即可
(4)布尔类型:用来判断条件是否成立的,在内存中占1字节大小。
只有两个值true/false, true:表示条件成立
false:表示条件不成立
/**
字符类型的学习
凡是能用书写工具写出来的,都是字符,
包括空格、换行符、制表符
*/
public class TypeDemo03{
public static void main(String[] args){
char c1='a';
System.out.println(c1);
char c2='啊';
System.out.println(c2);
//char c3='';//编译错误,不能为空
char c3=' ';//编译正确,可以为空格
//char c4=' ';//编译错误,只能为一个空格
//char c5="b";//编译错误,只能使用单引号
System.out.println("------分割线-------");
char c6=20013;
char c7=20102;
System.out.println(c6);
System.out.println(c7);
char c8=65;
char c9=97;
char c10=48;
System.out.println(c8);
System.out.println(c9);
System.out.println(c10);
System.out.println("------分割线-------");
char c11='\\';
System.out.println(c11);
//char c12=''';没有加\的时候报错,前面加\进行转义
char c12='\'';
System.out.println(c12);
//char c12='"';没有加\的时候也可以正常输出",但特殊字符前面一般加\进行转义
char c13='\"';
System.out.println(c13);
char c14='\t';//char c14='t';t是一个制表符,不加\输出是t但不为制表符
System.out.println("姓名"+c14+"年龄");
System.out.println("小"+c14+"12");/*制表符的输出效果:姓名 年龄
小 12
将上下对应
*/
System.out.println("你\rworld");
System.out.println("中国\n最伟大");
System.out.println("------分割线-------");
int num='高';
int n1='圆';
int n2='圆';
int n3='我';
int n4='爱';
int n5='你';
System.out.println(num);
System.out.println(n1);
System.out.println(n2);
System.out.println(n3);
System.out.println(n4);
System.out.println(n5);
System.out.println("------分割线-------");
boolean f1=true;
boolean f2=false;
System.out.println(f1);
System.out.println(f2);
int age1=33;
int age2=54;
boolean f3=age1>age2;
System.out.println(f3);
boolean f4=age1<=age2;
System.out.println(f4);s
}
}
3.2 不同基本数据类型的范围和进度排序
范围从大到小排序: double>float>long>int>short>byte
(char的范围可以类似=short)
精度从大到小排序:(int,long,float,double)
long>int>double>float
3.3 类型转换
(1)自动转换(隐式转换):占内存小的类型变量赋值给占内存大的类型变量, 会发生自动转换。
byte b=5;
short b1=b;//8位的5赋值给16位的5,在前面自动添加8个零
int c1=-1;
long c2=c1;//32位的-1赋值给了64位的c2里,自动添加了32个1
long c3=-1;
byte--->short--->int--->long--->float--->double
char
(2)强制转换:占内存大的类型变量赋值给占内存小的类型变量,需要强制转换。
语法如下:(占内存小的变量类型名)变量;
注意:有可能出现精度损失。
int a=1;
byta a1=(byte)a;
long b=-10;
int b1=(int)b;
double--->float--->long--->int---->short--->byte
char
public class TypeSwitchDemo01{
public static void main(String[] args){
/*类型转换:
自动转换(隐式转换)
强制转换(显式转换)
*/
/*
练习:
将short类型的b赋值给int类型的a;
将byte类型的c赋值给double类型的d;
将float类型的e赋值给double类型的g;
将double类型的n1赋值给float类型的n2;
将float类型的n2赋值给int类型的n3;
将int类型的n3赋值给byte类型的n4;
分别输出
*/
short b=2;
int a=b;
System.out.println(a);
byte c=4;
double d=c;
System.out.println(d);
float e=0.3F;//float e=0.3;不加F出现错误
double g=e;
System.out.println(g);
double n1=0.618;
float n2=(float)n1;
int n3=(int)n2;
byte n4=(byte)n3;
System.out.println(n2);
System.out.println(n3);
System.out.println(n4);
}
}
3.4 引用数据类型
引用数据类型(无数种,除了现有的,我们还可以自定义类型)
String:字符串类型
赋值特点:(1)必须使用双引号
(2)引号内有0或0个以上字符
(3)字符串的数据之间可以进行拼接操作
(可以和八大基本数据类型进行拼接,拼接后还是字符串类型)
public class StringDemo01{
public static void main(String[] args){
/*字符串类型:String
赋值特点:
1、必须使用双引号
2、引号内有0个或0个以上的字符都可
3、字符串可以做拼接操作,拼接后的数据仍是字符串类型。
*/
String name="小张";
//String n1='小王';//编译错误
String n1="";//编译正确,可以为空字符串
String n2=" ";//编译争取,空格字符串
String m="中国";
String m1="666";
//可以进行拼接操作,拼接符号为+
String m2=m+m1;
System.out.println(m2);
int count=777;
String result=m+count;//做拼接操作
System.out.println(result);
System.out.println(3+2+"中国");//结果为“5中国”
System.out.println(3+"+"+2+"="+(3+2));//3+2=5
System.out.println(3+3+"3"+3*3);//"639"
/*
在做运算时,+前后只要有一个是字符串类型就会做拼接操作。结果是
字符串类型。
*/
}
}
附加:
System.currentTimeMillis();会返回一个long类型的数据,此数据为从1970年1月1日0时0分
0秒到系统当前时间之间的所有毫秒数。
public class TestDemo01{
public static void main(String[] args){
/*
计算10亿*3,输出结果
计算10亿+10亿+10亿,输出结果
计算10亿*3L,输出结果
计算10亿L+10亿L+10亿L,输出结果
*/
int a=1000000000*3;
System.out.println(a);
int b=1000000000+1000000000+1000000000;
System.out.println(b);
long c=1000000000*3L;
System.out.println(c);
long d=1000000000L+1000000000L+1000000000L;
System.out.println(d);
/*
System.currentTimeMillis();会返回一个long类型的数据,
此数据为从1970年1月1日0时0分0秒到系统当前时间之间的
所有毫秒数。
*/
long time=System.currentTimeMillis();
System.out.println(time);
/*
将time的值换算成年份,+1970
*/
long num=time/1000/60/60/24/365;
System.out.println(num+1970);
}
}