数据类型定义了变量可以采用的值,例如,定义变量为 `int` 类型,则只能取整数值。
**在 Java 中有两类数据类型:**
1)原始数据类型
2)非原始数据类型 - 数组和字符串是非原始数据类型,将在以后的教程中讨论它们。
这次我们将讨论Java中的原始数据类型和字符。
Java 变量必须先指定它的数据类型(变量声明),然后才能使用。
```java
int num;
```
> 像这种变量数据类型在编译时已知,则这种语言称为静态类型的。
## 1. 基本数据类型
**在Java中,我们有八种基本数据类型:**
1)boolean:布尔类型
2)char:字符类型
3)byte:字节类型
4)short:短类型
5)int:整数类型
6)long:长类型
7)float:浮点类型
8)double:双精度类型
**`byte`**、 **`short`** 、**`int`**、 **`long`** 类型用于存储整数类型数据。
**`float`** 和 **`double`** 用于存储分数或者小数类型数据,也可用于存储整数值。
**`char`**用于存储字符(字母)类型数据。
**`boolean`**类型存储 `true`和 `false`,用于逻辑判断。
**3. 常用到的数据类型**
1)**用于存储数值常用到的数据类型有**:`int`、`long`、`double`, `int`类型占用内存空间较小,程序运行速度快,`double`类型占用内存空间较大,程序运行速度相对慢。
![](http://on91wk3hn.bkt.clouddn.com/17-12-18/27114768.jpg)
**2)用于存储文本的常用数据类型**:`String`(非原始数据类型)和`char`
![](http://on91wk3hn.bkt.clouddn.com/17-12-18/1740664.jpg)
**3)用于决策的 `boolean`数据类型比较常用**:
![](http://on91wk3hn.bkt.clouddn.com/17-12-18/38609634.jpg)
### 1.1 byte 数据类型
可以保存在-128到127之间的整数。主要用于节省内存。
默认大小:1个字节
```java
class ByteExample {
public static void main(String[] args) {
byte num;
System.out.println("存储最大值:" + Byte.MAX_VALUE);
System.out.println("存储最小值:" + Byte.MIN_VALUE);
System.out.println("默认存储字节:" + Byte.BYTES);
num = 113;
System.out.println(num);
//num = 160;//编译会抛出错误:不兼容的类型: 从int转换到byte可能会有损失num = 160;
}
}
```
输出:
```
存储最大值:127
存储最小值:-128
默认存储字节:1
113
```
> 如果 num 的值超出范围会在编译时候抛出错误:不兼容的类型: 从int转换到byte可能会有损失
### 1.2. short 类型数据
它的存储数值范围是 -32,768 到 32767。
数据类型默认大小:2个字节。
```java
class ShortExample {
public static void main(String[] args) {
short num;
System.out.println("存储最大值:" + Short.MAX_VALUE);
System.out.println("存储最小值:" + Short.MIN_VALUE);
System.out.println("默认存储字节:" + Short.BYTES);
num = 150;
System.out.println(num);
}
}
```
输出:
```
存储最大值:32767
存储最小值:-32768
默认存储字节:2
150
```
### 1.3. int 数据类型
存储数值范围:-2147483648 到 2147483647
默认大小:4 字节
```java
class IntExample {
public static void main(String[] args) {
int num;
System.out.println("存储最大值:" + Integer.MAX_VALUE);
System.out.println("存储最小值:" + Integer.MIN_VALUE);
System.out.println("默认存储字节:" + Integer.BYTES);
num = 1500;
System.out.println(num);
num = -1500;
System.out.println(num);
}
}
```
输出:
```
存储最大值:2147483647
存储最小值:-2147483648
默认存储字节:4
1500
-1500
```
###
### 1.4. long 数据类型
数值存储范围:-9223372036854775808 到 9223372036854775807
默认大小:8 字节
```java
class LongExample {
public static void main(String[] args) {
long num;
System.out.println("存储最大值:" + Long.MAX_VALUE);
System.out.println("存储最小值:" + Long.MIN_VALUE);
System.out.println("默认存储字节:" + Long.BYTES);
num = 150000000000L;
System.out.println(num);
num = -150000000000L;
System.out.println(num);
}
}
```
> 注意:long类型变量赋值时,数值后面要加上字母`L`或者小写`l`
输出:
```
存储最大值:9223372036854775807
存储最小值:-9223372036854775808
默认存储字节:8
150000000000
-150000000000
```
**总结:**
从 **`byte`**到 **`long`** 类型变量存储范围越来越大,存储空间(字节数)越来越大,程序运行速度越来越小。所以编码过程中根据数值大小选择合适数据类型变量,可以优化程序运行速度。
### 1.5. double 数据类型
足够保存15位十进制数字
默认大小:8 字节
```java
class DoubleExample {
public static void main(String[] args) {
System.out.println("存储最大值:" + Double.MAX_VALUE);
System.out.println("存储最小值:" + Double.MIN_VALUE);
System.out.println("默认存储字节" + Double.BYTES);
double num = -42937737.9d;
}
}
```
> 注意:double 类型变量赋值时,数值后面要加上字母`D`或者小写`d`
输出:
```
存储最大值:1.7976931348623157E308
存储最小值:4.9E-324
默认存储字节8
-4.29377379E7
```
### 1.6 float 数据类型
足够保存6至7位十进制数字
默认大小:4 字节
```java
class DoubleExample {
public static void main(String[] args) {
System.out.println("存储最大值:" + Double.MAX_VALUE);
System.out.println("存储最小值:" + Double.MIN_VALUE);
System.out.println("默认存储字节" + Double.BYTES);
double num = -42937737.9d;
}
}
```
> 注意:float 类型变量赋值时,数值后面要加上字母`F`或者小写`f`
输出:
```
存储最大值:3.4028235E38
存储最小值:1.4E-45
默认存储字节4
-18.9
```
### 1.7. boolean 数据类型
只存储 `true` 和 `false`
```java
class BooleanExample {
public static void main(String[] args) {
boolean b = true;
System.out.println(b);
b = false;
System.out.println(b);
}
}
```
输出:
```
true
false
```
### 1.8. char 数据类型
只存储一个字符
默认存储大小:2 个字节
```java
class CharExample {
public static void main(String[] args) {
char ch = 'z';
System.out.println("默认存储字节:" + Character.BYTES);
System.out.println(ch);
ch = '1';
System.out.println(ch);
//ch = '10';//编译不过,因为char 类型只能存储一个字符
}
}
```
输出:
```
默认存储字节:2
z
1
```
## 2. 整数的不同进制
`byte`、`short`、`int`和`long`都可以用十进制、二进制、八进制以及十六进制的方式来表示。当使用常量字面量时,前缀`0b`表示二进制,`0`表示八进制,而前缀`0x`代表十六进制。比如:
```java
int decimal = 174;
int binary = 0b10101110;
int octal = 0256;
int hexa = 0xAE;
```
为什么`174`用二进制表示就是`10101110`呢?
`174`是由个位数的`4`、十位数的`7`和百位数的`1`构成:
![](http://on91wk3hn.bkt.clouddn.com/17-12-17/63703615.jpg)
如果使用二进制,则可以表达为:
![](http://on91wk3hn.bkt.clouddn.com/17-12-17/74664123.jpg)
上面图片中所有红色的数字就构成了二进制表示`10101110`。
哪如何将一个十进制数转换为二进制数呢?
将十进制数不断除以2,直到等于0,每次除法产生的余数从后往前合并在一起就是对应的二进制表示:
![](http://on91wk3hn.bkt.clouddn.com/17-12-17/61889701.jpg)
对于八进制和十六进制,原理是类似的。
## 3. 类型转换
一个浮点数字面量默认是`double`类型,如果要定义`float`类型则要在字面量最后添加`f`或者`F`:
```java
double a = 1.23;
float b = 1.23F;
float c = 1.23; // 编译错误
```
以上代码中,第三行代码将出现编译错误,因为`1.23`这个字面量是`double`类型的,不能将其赋值给`float`类型。
一个整数字面量默认是`int`类型,如果要定义长整形(`long`)则要在字面量最后添加`l`或者`L`。但是
```java
int a = 100;
long b = 100000L;
long c = 100000;
```
第三行代码`long c = 100000;`不会有编译错误,虽然字面量`100000`是`int`类型的,但是当`int`类型赋值给`long`类型时,可以**自动转换**为`long`类型。
占用内存空间小的类型可以自动转换为占用空间大的类型,反之则不成立。你把一个变量的想象成一个箱子,更小的箱子里的东西可以放入到更大的箱子中,将更大的箱子里的东西放到更小的箱子则可能装不下。比如:
- `b = a;`是合法的赋值
- `a = b;`则是非法的赋值,会有编译错误,这其实也是代码`float c = 1.23;`会发生编译错误的原因
如果一定要将`b`的值(`long`类型)赋值给`a`,则要进行**强制转换**:
```java
a = (int)b;
```
`b`变量前的`(int)`表示将`b`的值强制转换为`int`类型。注意强制类型转换时,可能导致数据错误,比如`b`的值超过了`int`类型的表示范围,此时就会进行数据截断(丢掉箱子装不下的东西),我们应该尽量避免这种情况。
![](http://on91wk3hn.bkt.clouddn.com/17-12-17/95094729.jpg)
基本类型之间的自动转换关系如下:
![](http://on91wk3hn.bkt.clouddn.com/17-12-17/47689568.jpg)
## 4. 包装类
以上8种基本类型都不是类,Java提供了对应的类,称之为包装类。包装类可以认为是将基本类型转换成的一个引用类型。
| 基本类型 | 包装类 |
| ------- | --------- |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
| char | Character |
每种基本类型所占用的内存空间大小,最大值和最小值,可以通过其包装类来访问。比如为了我们可以这样访问`int`类型的相关信息:
```java
System.out.println("int类型的二进制位数:" + Integer.SIZE);
System.out.println("int类型的最小值:Integer.MIN_VALUE=" + Integer.MIN_VALUE);
System.out.println("int类型的最大值:Integer.MAX_VALUE=" + Integer.MAX_VALUE);
```
注意,将一个整数和字符串通过`+`号拼接起来,整数可以自动转换为字符串。
以`Integer`和`int`为例,我们可以将两者进行转换,例如:
```java
Integer in = new Integer(100); // 将int转换为包装类
int m = in.intValue(); // 获取Integer的int值
String s = “123”;
int n = Integer.parseInt(s); // 将字符串转换为整数
String s2 = Integer.toString(n); // 将整数转换为字符串
```
其它数据类型的操作是类似的,不再一一赘述。
`Integer in = new Integer(100);`将int转换为包装类,本质就是通过`new`创建包装类`Integer`,调用`Integer`的构造函数并将`100`这个`int`类型的数作为参数传给构造函数。关于构造函数的细节在后续教程中讲解。
## 5. 数组
数组(Array)是程序设计语言中必不可少的一种结构,它用来描述一系列相同类型的数据。一个数组一旦创建后,它的长度是固定的。
下面的代码,定义了一个长度为10的数组,数据的下标编号从0开始,9是最后一个元素。下面是一个Java语言数组的例子:
```java
int[] anArray;
anArray = new int[10];//初始化一个长度为10的整形数组
anArray[0] = 100;//初始化第一个变量
anArray[1] = 200;
anArray[2] = 300;
anArray[3] = 400;
anArray[4] = 500;
anArray[5] = 600;
anArray[6] = 700;
anArray[7] = 800;
anArray[8] = 900;
anArray[9] = 1000;
```
数组下标和元素的关系如下所示:
![](http://on91wk3hn.bkt.clouddn.com/17-12-17/6616789.jpg)
这样初始化数组比较麻烦,下面是另外一种更加便捷的方式:
```java
int[] anArray = { 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};
```
这样会自动创建一个长度为10的`int`数组。我们通过`anArray.length`可以得到数组的长度。
## 6. String 类型数据
一个字符串就是一个字符序列,字符串被广泛应用于 Java 编程。Java语言将字符串作为`String`类型的对象进行处理。
`String`并不是基本的数据类型,是一个类。最常用的创建字符串对象的方法如下:
```java
String str = "abc";
```
字符串可以通过`+`和`+=`操作符进行拼接,比如:
```java
String str1 = "abc";
String str2 = str1 + "def";
str1 += "def";
```
最后`str1`和`str2`所指向的字符串内容为"abcdef"。
字符串和基本数据类型也能通过`+`进行拼接操作,比如:
```java
int a = 100;
String str = "a=" + a;
```
`str`字符串的内容为"a=100"。即基本类型和字符串类型相加时,基本类型会自动转换为其字符串表示,在这个例子中相当于:
```java
String str = "a=" + "100";
```
回顾包装类这一小节的代码:
```java
System.out.println("int类型的最大值:Integer.MAX_VALUE=" + Integer.MAX_VALUE);
```
就是将字符串和数据类型的拼接。
`String`类的实例是一个不可变的对象,意味着对`String`的操作都会产生一个新的`String`对象。
例如,`String`有一个`substring()`方法
```java
String str = "123456";
str.substring(3); // 从下标3(注意下标从0开始)开始截取一个子字符串
System.out.println(str); // str本身不可变,所以打印出来依然是123456
String str2 = str.substring(3); // 将产生的新对象赋值给一个新的引用变量
System.out.println(str2); // str2的内容为456
```
QQ交流群:468439140