基本数据类型和引用类型

和所有面向对象的语言一样,Java有两大数据类型:基本类型和引用类型.

基本类型是简单数据类型,是不可再分的最小单位,如int.引用类型是基本数据类型的重组与结合,如类.

基本数据类型

Java一共有如下8种基本数据类型:

基本类型	属性	表示范围
byte	整型	[-27,27)
short	整型	[-215,215)
int	整型	[-231,231)
long	整型	[-263,263-1)
char	字符型	0~65535
boolean	布尔型	true/false
float	浮点型	1位符号,8位阶数,23位尾数
double	浮点型	1位符号,11位阶数,52位尾数

需要注意以下几点:

• Java兼容C所有的转义字符,且支持Unicode字符,\uXXXX,其中XXXX代表一个十六进制整数,具体可查表
• Java中,整数默认以int方式存放,因此程序里不要直接写超过int范围的数值
• 对于一个超过int不到long范围的整数,应该使用整数+l(或L)的形式表示,如4294967296L
• 不管是整数还是浮点数,数值中都可以使用下划线分割,如3.14_15_92_6
• boolean就是boolean,不能转换为其它类型,也不能由其他类型转换而来
• 默认的浮点数是double,若想用float,使用小数+f(或F)的形式,如3.14F
• 科学计数法适用于浮点数,如1.52e2或1.52E2表示1.52×10²
• Java支持十进制以外进制的整数,其表示对应如下:

进制	形式
二	0b(或0B)+二进制数
八	0+八进制数
十六	0x(或0X)+十六进制数

• Java中特殊的三个浮点数:POSITIVE_INFINITY,NEGATIVE_INFINITY和NaN将在引用类型介绍

以下程序用来展示Java基本数据类型变量的用法:

public class BaseTypeTest {
    public static void main(String[] args) {
        char c = 'a';
        byte b = 125;
        short s = 130;
        int i = 32770;
        long l = 1_000_000_000L;
        double d = 1.55_555_555_555_555;
        float f = 1.55_555F;
        boolean bo = true;
        System.out.println(c);
        System.out.println(b);
        System.out.println(s);
        System.out.println(i);
        System.out.println(l);
        System.out.println(d);
        System.out.println(f);
        System.out.println(bo);
        c = '\u9999';
        b = 0b1001;
        s = 0777;
        i = 0xffff;
        System.out.println(c);
        System.out.println(b);
        System.out.println(s);
        System.out.println(i);
    }
}

引用类型

不可能将所有引用类型背下来,要善于查看API文档,这里介绍几个常用的引用类型.

String类

Java不提供字符串的基本类型,而是和C++一样用一个封装好的引用类型代替,它的基本用法如下:

构造:一般使用最多的是空的构造器和以声明时直接赋初值的构造,如:

String str;	//空的构造;
String str1 = "abc";	//初值构造;

其中String str1 = "abc";,相当于调用参数为char数组的构造器:

char data[] = {'a', 'b', 'c'};
String str = new String(data);

关于构造器就说到这,让我们看看String的其他常用方法:

方法	返回类型	用途
isEmpty()	boolean	判断字符串是否为空,为空返回true
length()	int	返回字符串的长度
substring(int st)	String	返回从st开始,到字符串结束的子串
substring(int st,int ed)	String	返回[st,ed)区间内的子串
toCharArray()	char[]	将字符串转换为字符数组
toUpperCase()	String	返回字符串全大写形式
toLowererCase()	String	返回字符串全小写形式
charAt(int pos)	char	返回字符串pos位置的字符
getBytes()	byte[]	将字符串转化为byte数组(按照ASCII码)
trim()	String	返回去除字符串前置和后置空格的字符串

方法介绍得差不多了,没什么需要注意的地方,知道String位置是从0开始编号的即可,下面是样例程序:

public class StringTest {
    public static void main(String[] args) {
        String str1 = "Hello World!";
        String str2 = str1.substring(6);
        String str3 = str1.substring(0,5);
        String str4 = str1.toLowerCase();
        String str5 = str1.toUpperCase();
        char[] c = str1.toCharArray();
        String str6 = "    Hello World    ";
        String str7 = str6.trim();
        boolean bl = str1.isEmpty();
        int len = str6.length();
        char ch = str6.charAt(6);
        byte[] bt = str1.getBytes();
        System.out.println(str1+"\n"+str2+"\n"+str3+"\n"+str4+"\n"+str5);
        System.out.println(str6+"\n"+str7+"\n"+bl+"\n"+len+"\n"+ch);
        for(int i = 0; i < c.length; i++)
            System.out.print(c[i]);
        System.out.println("");
        for(int i = 0; i < bt.length; i++)
            System.out.print(bt[i]);
        System.out.println("");
    }
}

Scanner类

Scanner对于我来说最大的用途在于输入,Java默认的输入比较繁琐,用Scanner轻松解决,基本用法如下:

方法	返回类型	用途
hasNext()	boolean	判断输入流是否为空
hasNextLine()	boolean	判断输入流是否有下一行
hasNextByte()	boolean	判断输入流中是否存在能通过nextByte()转化为byte类型的数据
hasNextShort()	boolean	判断输入流中是否存在能通过nextShort()转化为short类型的数据
hasNextInt()	boolean	判断输入流中是否存在能通过nextInt()转化为int类型的数据
hasNextLong()	boolean	判断输入流中是否存在能通过nextLong()转化为long类型的数据
hasNextFloat()	boolean	判断输入流中是否存在能通过nextFloat()转化为float类型的数据
hasNextDouble()	boolean	判断输入流中是否存在能通过nextDouble()转化为double类型的数据
hasNextBoolean()	boolean	判断输入流中是否存在boolean类型的数据
nextByte()	byte	从输入流读取下一个byte类型的数据
nextShort()	Short	从输入流读取下一个short类型的数据
nextInt()	int	从输入流读取下一个int类型的数据
nextLong()	long	从输入流读取下一个long类型的数据
nextBoolean()	boolean	从输入流读取下一个boolean类型的数据
nextFloat()	float	从输入流读取下一个float类型的数据
nextDouble()	double	从输入流读取下一个double类型的数据
next()	String	从当前到下一个数据的内容以String类型返回
nextLine()	String	跳过当前行,并把跳过的内容以String类型返回

解释Scanner对"下一个"数据的判定:在输入流中,每个数据都用空格或者换行符隔开,遇到换行符则进入下一行,因此next()方法是从当前位置到下一个空格/换行符之前,nextLine()是从当前位置到下一个换行符之前,这些内容以String类型返回即next()不读取空格和换行符,nextLine()读取并将其存入字符串,其它的nextXXX()方法也是一样,指的是以空格/换行符为界的下一个,输入时要注意格式,可能会抛出异常

注意:Scanner不能直接读取char,要先以String读取,再转换为char

Scanner使用时导入对应的包,且构造时应该传入系统输入流:

import java.util.Scanner;
Scanner cin = new Scanner(System.in);

Scanner的具体用例:

import java.util.Scanner;

public class ScannerTest {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);    //扫描来自终端的输入;
        byte aByte = cin.nextByte();
        short aShortInteger = cin.nextShort();
        int anInteger = cin.nextInt();
        long aLongInteger = cin.nextLong();
        float aFloat = cin.nextFloat();
        double aDouble = cin.nextDouble();
        String str1 = cin.next();   //不读取无效符号,如' '或'\n';
        String str2 = cin.nextLine();   //读取所有字符,以'\n'结束;
        boolean aBoolean = cin.nextBoolean();
        char[] c = str1.toCharArray();  //字符串转换为字符数组;
        char ch = c[0]; //提取字符;
        System.out.println(aByte+"\n"+aShortInteger+"\n"+anInteger+"\n"+aLongInteger);
        System.out.println(aFloat+"\n"+aDouble+"\n"+str1+"\n"+str2+"\n"+aBoolean+"\n"+ch);
    }
}

输入样例和输出结果如下:

# 输入
120
999
9999
99999
999.9 
99999.99999
I'm_ok~ We're good~
true

# 输出
120
999
9999
99999
999.9
99999.99999
I'm_ok~
 We're good~
true
I

可见nextLine()从"I’m_ok~"后面的空格开始,读取到整行结束,字符没有对应输入方法,要从字符串转换得到

Double/Float类

主要介绍一下上文提及的三个特殊浮点数的用法,如下表:

浮点数	存在的类
POSITIVE_INFINITY	java.lang.Float/java.lang.Double
NEGATIVE_INFINITY	java.lang.Float/java.lang.Double
NaN	java.lang.Float/java.lang.Double

按照数学定律,我们知道:

• $+\infin = -\infin$
• 负数/0 = $-\infin$,正数/0 = $+\infin$
• 0/0 = 非数, $负数非数\sqrt{负数} = 非数$

在Java里,这三条定律依然适用,只是定律2有一些的变化:浮点数除零得正负无穷大,整数除零抛出异常.

其中POSITIVE_INFINITY、NEGATIVE_INFINITY、NaN分别表示 $+\infin$, $-\infin$,非数,用于处理浮点算数异常,用法如下:

import java.lang.Double;

public class FloatDoubleTest {
    public static void main(String[] args) {
        double d1 = -100.0;
        double d2 = 100.0;
        double ne = Double.NEGATIVE_INFINITY;
        double po = Double.POSITIVE_INFINITY;
        double d3 = d1/0.0;
        double d4 = d2/0.0;
        double d5 = 0.0/0.0;
        //System.out.println(0/0);	//这里将抛出除0异常;
        if(d3 == ne) System.out.println("-100.0/0.0 == NEGATIVE_INFINITY");
        if(d4 == po) System.out.println("100.0/0.0 == POSITIVE_INFINITY");
        if(d5 == Double.NaN) System.out.println("0.0/0.0 == NaN");
        System.out.println(d5);
    }
}

尝试编译运行以上程序,得到输出:

-100.0/0.0 == NEGATIVE_INFINITY
100.0/0.0 == POSITIVE_INFINITY
NaN

可见两个非数在Java里是不相等的,这也符合常理,非数本身就不可能有确定值,非数不和任何数/非数相等