Java中的数据类型
Java提供了两种数据类型:一种是基本类型(原始类型),一种是引用类型。
Java是一种强类型语言,这就意味着必须为每一个变量声明一种类型。
在 Java 中,有 8 种基本数据类型(primitive type),其中有 4 种整型(byte、short、int、long)、2 种浮点型(float、double)、1 种用于表示Unicode编码的字符单元的字符类型 char 和 1 种用于表示真值的 boolean 类型。
Java对基本数据类型特殊对待,是由于用 new 创建对象(特别是小的、简单的变量)并不是非常有效,因为 new 将对象置于“堆”里。对于这些类型,Java 采纳了与 C 、C++相同的方法,不是用 new 创建变量,而是创建一个并非句柄的“自动”变量。这个变量容纳了具体的值,并置于栈中,能够更高效地存取。 Java 决定了每种主要类型的大小,不随着机器结构的变化而变化,这是 Java 程序具有很强移植能力的原因之一。Java 没有任何无符号类型(unsigned)。
此外,Java有 5种引用类型(对象类型):类、接口类型、数组类型、枚举类型、 注解类型。
基本数据类型位数和范围
类型 | 位数 | 最小值 | 最大值 | 默认值 |
---|---|---|---|---|
byte | 8 | -128(-2^7) | 127(2^7-1) | 0 |
short | 16 | -32768(-2^15) | 32767(2^15 - 1) | 0 |
int | 32 | -2,147,483,648(-2^31) | 2,147,483,647(2^31 - 1) | 0 |
long | 64 | -9,223,372,036,854,775,808(-2^63) | 9,223,372,036,854,775,807(2^63 -1) | 0L |
float | 32 | - | - | 0.0f |
double | 64 | - | - | 0.0 |
boolean | 1 | 只有两个取值:true 和 false | - | false |
char | 16 | \u0000(即为0) | \uffff(即为65,535) | \u0000 |
基本数据类型和引用数据类型的比较
基本数据类型 | 引用数据类型 |
---|---|
在栈中进行分配 | 在堆中进行分配,堆的读写速度远不及栈 |
变量名指向具体的数值 | 变量名指向存数据对象的内存地址,即变量名指向hash值 |
变量在声明之后java就会立刻分配给他内存空间 | 它以特殊的方式(类似C指针)指向对象实体(具体的值),这类变量声明时不会分配内存,只是存储了一个内存地址 |
基本类型之间的赋值是创建新的拷贝 | 对象之间的赋值只是传递引用 |
“==”和“!=”是在比较值 | “==”和“!=”是在比较两个引用是否相同,需要自己实现equals()方法 |
基本类型变量创建和销毁很快 | 类对象需要JVM去销毁 |
Java中的值传递
方法的参数分为实际参数和形式参数。
- 形式参数:定义方法时写的参数。
- 实际参数:调用方法时写的具体数值。
Java中只有值传递,没有引用传递。
一般情况下,Java在传递参数的时候,基本数据类型传递值的拷贝,引用数据类型传递引用的地址值。
举例说明
1. 基本数据类型
public static void main(String[] args) {
int num1 = 10;
int num2 = 20;
swap(num1, num2);
System.out.println("num1 = " + num1);
System.out.println("num2 = " + num2);
}
// 交换两个数的值
public static void swap(int num1, int num2) {
int temp = num1;
num1 = num2;
num2 = temp;
}
运行结果:
num1 = 10
num2 = 20
为什么 num1 和 num2 的值没有交换呢?
执行流程:
(1)主函数进栈,num1、num2初始化。
(2)调用swap方法,swap( )进栈,将main方法中的num1和num2的值,复制一份给swap中的参数 。
(3)swap方法中对自己栈内存中的 num1、num2 的值进行交换。
(4)swap方法运行完毕,swap方法中的num1和num2的值已经交换,但不影响主函数中的数据。
(5)swap方法出栈。
(6)主函数出栈。
2. 引用数据类型
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
swap(arr);
System.out.println("arr[0] = " + arr[0] + ", arr[4] = " + arr[4]);
}
// 将数组的第一个元素和最后一个元素交换
public static void swap(int[] arr) {
int temp = arr[0];
arr[0] = arr[arr.length -1];
arr[arr.length - 1] = temp;
}
运行的结果:
arr[0] = 5, arr[4] = 1
为什么数组被改变了呢?
执行流程:
(1)主函数进栈,int[ ] arr初始化。
(2)调用change方法,change( )进栈,将main函数中的arr数组地址值,复制一份给自己参数arr。
(3)change方法中,根据地址值,找到堆中的数组,并将第一个元素的值改为5,最后一个元素改为1。
(4)change方法运行完毕,堆内存数组中第一个元素的值已经改变。
(5)change方法出栈。
(6)主函数出栈。
BUT!请看String类型的操作:
public static void main(String[] args) {
String name = "Bob";
change(name);
System.out.println("name = " + name);
}
// 修改 name
public static void change(String name) {
name = "Alice";
}
执行的结果:
name = Bob
为什么 name 没有改变呢?
这就神奇了!!!
String的API中有这么一句话:“their values cannot be changed after they are created”
意思是:String的值在创建之后不能被更改。
也就是说:对String对象的任何修改 等同于 重新创建一个对象,并将新的地址值赋值给name。
重点是要分清楚 对象引用 和 对象 的区别,name只是对象的引用,并不是对象,只是用它来指向真实的对象,方便操作指向的对象。
所以,就是 swap方法中的 name = "Alice"
等同于 name = new String("Alice")
;
其他引用类型的效果都是一致的,只是String类型的特殊性,看起来不是创建新对象。