和所有面向对象的语言一样,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×102
- 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 |
按照数学定律,我们知道:
- 负数/0 = ,正数/0 =
- 0/0 = 非数,
在Java里,这三条定律依然适用,只是定律2有一些的变化:浮点数除零得正负无穷大,整数除零抛出异常.
其中POSITIVE_INFINITY
、NEGATIVE_INFINITY
、NaN
分别表示
,
,非数,用于处理浮点算数异常,用法如下:
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里是不相等的,这也符合常理,非数本身就不可能有确定值,非数不和任何数/非数相等