6. Java 中的基本数据类型 【连载 6】

从零开始学Java封面6.jpg

数据类型定义了变量可以采用的值，例如，定义变量为 int 类型，则只能取整数值。

在 Java 中有两类数据类型：

1）原始数据类型

2）非原始数据类型 - 数组和字符串是非原始数据类型，将在以后的教程中讨论它们。

这次我们将讨论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类型占用内存空间较大，程序运行速度相对慢。

1.jpg

2）用于存储文本的常用数据类型：String（非原始数据类型）和char

2.jpg

3）用于决策的 boolean数据类型比较常用：

3.jpg

1.1 byte 数据类型

可以保存在-128到127之间的整数。主要用于节省内存。

默认大小：1个字节

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个字节。

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 字节

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 字节

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 字节

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 字节

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

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 个字节

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代表十六进制。比如：

int decimal = 174;
int binary = 0b10101110;
int octal = 0256;
int hexa =  0xAE;

为什么174用二进制表示就是10101110呢？

174是由个位数的4、十位数的7和百位数的1构成：

4.jpg

如果使用二进制，则可以表达为：

5.jpg

上面图片中所有红色的数字就构成了二进制表示10101110。

哪如何将一个十进制数转换为二进制数呢？

将十进制数不断除以2，直到等于0，每次除法产生的余数从后往前合并在一起就是对应的二进制表示：

6.jpg

对于八进制和十六进制，原理是类似的。

3. 类型转换

一个浮点数字面量默认是double类型，如果要定义float类型则要在字面量最后添加f或者F：

double a = 1.23;
float b = 1.23F;
float c = 1.23; // 编译错误

以上代码中，第三行代码将出现编译错误，因为1.23这个字面量是double类型的，不能将其赋值给float类型。

一个整数字面量默认是int类型，如果要定义长整形(long)则要在字面量最后添加l或者L。但是

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，则要进行强制转换：

a = (int)b;

b变量前的(int)表示将b的值强制转换为int类型。注意强制类型转换时，可能导致数据错误，比如b的值超过了int类型的表示范围，此时就会进行数据截断（丢掉箱子装不下的东西），我们应该尽量避免这种情况。

7.jpg

基本类型之间的自动转换关系如下：

8.jpg

4. 包装类

以上8种基本类型都不是类，Java提供了对应的类，称之为包装类。包装类可以认为是将基本类型转换成的一个引用类型。

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

每种基本类型所占用的内存空间大小，最大值和最小值，可以通过其包装类来访问。比如为了我们可以这样访问int类型的相关信息：

 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为例，我们可以将两者进行转换，例如：

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语言数组的例子：

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;

数组下标和元素的关系如下所示：

9.jpg

这样初始化数组比较麻烦，下面是另外一种更加便捷的方式：

int[] anArray = { 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000};

这样会自动创建一个长度为10的int数组。我们通过anArray.length可以得到数组的长度。

6. String 类型数据

一个字符串就是一个字符序列，字符串被广泛应用于 Java 编程。Java语言将字符串作为String类型的对象进行处理。

String并不是基本的数据类型，是一个类。最常用的创建字符串对象的方法如下：

String str = "abc";

字符串可以通过+和+=操作符进行拼接，比如：

String str1 = "abc";    
String str2 = str1 + "def";
str1 += "def";

最后str1和str2所指向的字符串内容为"abcdef"。

字符串和基本数据类型也能通过+进行拼接操作，比如：

int a = 100;
String str = "a=" + a;

str字符串的内容为"a=100"。即基本类型和字符串类型相加时，基本类型会自动转换为其字符串表示，在这个例子中相当于：

String str = "a=" + "100";

回顾包装类这一小节的代码：

System.out.println("int类型的最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE); 

就是将字符串和数据类型的拼接。

String类的实例是一个不可变的对象，意味着对String的操作都会产生一个新的String对象。扣扣交流群：468439140

例如，String有一个substring()方法

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