一、数据类型
基本数据类型
- 整型
- byte
- short
- int
- long
- 浮点型
- float
- double
- 字符型
- char
- 布尔型
- boolean
基本数据类型 | 位数 | 默认值 | 取值范围 | 示例 |
---|---|---|---|---|
byte | 8 | 0 | -2^7 ~ 2^7-1 | byte b = 10 |
short | 16 | 0 | -2^15 ~ 2^15-1 | short s = 10 |
int | 32 | 0 | -2^31 ~ 2^31-1 | int i = 10 |
long | 64 | 0 | -2^63 ~ 2^63-1 | long l = 10l / long l =10L |
float | 32 | 0.0 | 1.4E-45 ~3.4E+38 | float f = 0.3f |
double | 64 | 0.0 | 4.9E-324 ~1.7E308 | double d = 0.3d |
char | 16 | ‘\u0000’ | 0~65535 | char c = ‘a’ |
boolean | 1 | false | true / false | boolean b = true |
public class Test {
public static void main(String[] args) {
System.out.println("Byte.MAX_VALUE=" + Byte.MAX_VALUE);
System.out.println("Byte.MIN_VALUE=" + Byte.MIN_VALUE);
System.out.println("Short.MAX_VALUE=" + Short.MAX_VALUE);
System.out.println("Short.MIN_VALUE=" + Short.MIN_VALUE);
System.out.println("Integer.MAX_VALUE=" + Integer.MAX_VALUE);
System.out.println("Integer.MIN_VALUE=" + Integer.MIN_VALUE);
System.out.println("Long.MAX_VALUE=" + Long.MAX_VALUE);
System.out.println("Long.MIN_VALUE=" + Long.MIN_VALUE);
System.out.println("Float.MAX_VALUE=" + Float.MAX_VALUE);
System.out.println("Float.MIN_VALUE=" + Float.MIN_VALUE);
System.out.println("Double.MAX_VALUE=" + Double.MAX_VALUE);
System.out.println("Double.MIN_VALUE=" + Double.MIN_VALUE);
System.out.println("Character.MAX_VALUE=" + (int)Character.MAX_VALUE);
System.out.println("Character.MIN_VALUE=" + (int)Character.MIN_VALUE);
}
}
/**
Byte.MAX_VALUE=127
Byte.MIN_VALUE=-128
Short.MAX_VALUE=32767
Short.MIN_VALUE=-32768
Integer.MAX_VALUE=2147483647
Integer.MIN_VALUE=-2147483648
Long.MAX_VALUE=9223372036854775807
Long.MIN_VALUE=-9223372036854775808
Float.MAX_VALUE=3.4028235E38
Float.MIN_VALUE=1.4E-45
Double.MAX_VALUE=1.7976931348623157E308
Double.MIN_VALUE=4.9E-324
Character.MAX_VALUE=65535
Character.MIN_VALUE=0
*/
引用数据类型
-
类
- 基类:System.Object
- 字符串:String
- 自定义类:class
-
接口
- interface
-
数组
- int[]
- string[]
二、整型溢出
原因
Java中的基本数据类型都有自己的取值范围,且在Java中数值是“有符号”的,即在二进制存储中最高位表示正负。
以int类型为例。Java中int为32位,即最大值为 2^31-1,最高位为0表正数。当数值过大超出int范围,计算机会将最高位变为1,但仍旧按之前方式处理,导致结果为负,造成整型溢出。
示例
/**
* 一个人每分钟心跳100次,60年的心跳数
*/
public class Test {
public static void main(String[] args) {
int heartBeatNum = 100 * 60 * 24 * 365 * 60;
System.out.println(heartBeatNum); // -1141367296
}
}
说明:60年的心跳数已经超出了int的取值范围,导致整型溢出。
解决方法
强制类型转换
/**
* 解决方案
*/
public class Test {
public static void main(String[] args) {
long heartBeatNum = 100l * 60 * 24 * 365 * 60;
System.out.println(heartBeatNum); // 3153600000
}
}
说明:因为导致溢出的是 100 * 60 * 24 * 365 * 60 这一表达式计算之后的结果,所以heartBeatNum使用long类型是不够的,需要使其中一个数,如100,在计算时强转为long类型。
三、基本数据类型的包装类
基本数据类型 | 包装类 | 高频区间数据缓存 |
---|---|---|
byte | Byte | -128 ~ 127 |
short | Short | -128 ~ 127 |
int | Integer | -128 ~ 127 |
long | Long | -128 ~ 127 |
float | Float | 无 |
double | Double | 无 |
char | Character | 0 ~ 127 |
boolean | Boolean | [true, false] |
高频区间缓存区示例验证
以 int 类型为例
public class Test {
public static void main(String[] args) {
Integer varInteger1 = 127 ; // 自动装箱
Integer varInteger2 = Integer.valueOf(127);
System.out.println(varInteger1 == varInteger2); // ture
Integer varInteger3 = -129 ; // 自动装箱
Integer varInteger4 = Integer.valueOf(-129);
System.out.println(varInteger3 == varInteger4); // false
}
}
说明:
- 127处于高频区间缓存区,varInteger2 会复用之前对象而不会创建新对象,地址相同,所以为true
- -129已经超出高频区间缓存区,所以会创建新对象,地址不同,所以为false
四、自动装箱/拆箱
自动装箱
自动将基本数据类型转换为包装器类型
Integer i = 10
原理:
- 通过调用包装器的 valueOf() 方法实现
- 返回该整数值的Integer对象
自动拆箱
自动将包装器类型转换为基本数据类型
int i = 10
原理:
- 通过调用包装器的 *xxxValue() *方法实现
- 返回该Integer对象中的整数值
五、Integer VS int
区别
1. 概念:int 是基本数据类型,Integer 是int的包装类
2. 默认值: int 为 0 ,Integer为 null
3. 使用:int 需声明后才可以使用,Integer 需实例化后使用
4. 实质:int 是存储数值,Integer 是对象引用,存储地址
转化
使用自动装箱和自动拆箱的方法
六、逻辑运算符&和&&的区别以及和位运算符&的区别
逻辑运算符&和&&的区别
逻辑运算符&&具有短路特性
public class Test {
public static void main(String[] args) {
int out = 10;
boolean b1 = false;
if ((b1 == true) && (out += 10) ==20){
System.out.println("相等,out="+out);
} else {
System.out.println("不等,out="+out);
}
}
} // 不等, out=10
public class Test {
public static void main(String[] args) {
int out = 10;
boolean b1 = false;
if ((b1 == true) & (out += 10) ==20){
System.out.println("相等,out="+out);
} else {
System.out.println("不等,out="+out);
}
}
} // 不等, out=20
逻辑运算符&和位运算符&的区别
- 逻辑运算符两侧必须是结果为布尔值的表达式
- 位运算符两侧是数值
七、跳出循环语句
break
- break:跳出本层循环
- beak lab:跳出多重循环的外层循环(lab为自己定义的标识)
public class Test {
public static void main(String[] args) {
A:
for(int i =0; i<2; i++) {
for(int j=0; j<10; j++) {
if (j >1) {
break A;
}
System.out.println("break");
}
}
}
}
/**
break
break
*/
continue
- continue:跳出本层的本次循环,继续本层的下一次循环
- continue lab:跳出外层的本次循环,继续外层的下一次循环
public class Test {
public static void main(String[] args) {
A:
for(int i =0; i<2; i++) {
for(int j=0; j<10; j++) {
if (j >1) {
System.out.println("###########");
continue A;
}
System.out.println("continue");
}
System.out.println("************");
}
}
}
/**
continue
continue
###########
continue
continue
###########
*/
总结
内容涉及Java的入门知识,通过拆分知识点的方式对Java这一语言的基础语法有了认识,并能够较为熟练的运用。但涉及到包装类或是较为底层的机制时还需要研读源码做到真正的理解与掌握。
在整理博客的过程中参考了一些资料以及许多他人优秀的文章,就不一一列举,在此表示感谢。