第一部分我们整理了一些Java的基础知识点,详情可戳👉紫薇星上的Java——JavaOO(1)
第二部分我们整理了修饰符、运算符与逻辑控制的知识点,详情可戳👉紫薇星上的Java——JavaOO(2)
第三部分我们正式进入了JavaOO的世界,学习了类与对象,数组以及方法的使用,详情可戳👉紫薇星上的Java——JavaOO(3)
这一部分我们来整理一些实用的类与方法,大噶冲冲冲!
13.Number & Math 类
一般地,当需要使用数字的时候,我们通常使用内置数据类型,如:byte、int、long、double 等,如:
int a = 5000;
float b = 13.65f;
byte c = 0x4a;
然而,在实际开发过程中,我们经常会遇到需要使用对象,而不是内置数据类型的情形。为了解决这个问题,Java 语言为每一个内置数据类型提供了对应的包装类。
所有的包装类(Integer、Long、Byte、Double、Float、Short)都是抽象类 Number 的子类。
这种由编译器特别支持的包装称为装箱,所以当内置数据类型被当作对象使用的时候,编译器会把内置类型装箱为包装类,相似的,编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包,下面是一个使用 Integer 对象的实例
public class Test{
public static void main(String args[]){
Integer x = 5;
x = x + 10;
System.out.println(x);
}
}
当上面的代码被编译时,它会产生下列结果:
15
当 x 被赋为整型值时,由于x是一个对象,所以编译器要对x进行装箱。然后,为了使x能进行加运算,所以要对x进行拆箱。
13.1 Java Math 类
Java 的 Math 包含了用于执行基本数学运算的属性和方法,如初等指数、对数、平方根和三角函数,Math 的方法都被定义为 static 形式,通过 Math 类可以在主函数中直接调用。
public class Test {
public static void main (String []args){
System.out.println("90 度的正弦值:" + Math.sin(Math.PI/2));
System.out.println("0度的余弦值:" + Math.cos(0));
System.out.println("60度的正切值:" + Math.tan(Math.PI/3));
System.out.println("1的反正切值: " + Math.atan(1));
System.out.println("π/2的角度值:" + Math.toDegrees(Math.PI/2));
System.out.println(Math.PI);
}
}
当上面的代码被编译时,它会产生下列结果:
90 度的正弦值:1.0
0度的余弦值:1.0
60度的正切值:1.7320508075688767
1的反正切值: 0.7853981633974483
π/2的角度值:90.0
3.141592653589793
13.2 Number & Math 类方法
下面的表中列出的是 Number & Math 类常用的一些方法:
序号 | 方法与描述 |
---|---|
1 | xxxValue() 将 Number 对象转换为xxx数据类型的值并返回。 |
2 | compareTo() 将number对象与参数比较。 |
3 | equals() 判断number对象是否与参数相等。 |
4 | valueOf() 返回一个 Number 对象指定的内置数据类型 |
5 | toString() 以字符串形式返回值。 |
6 | perseInt() 将字符串解析为int类型。 |
7 | abs() 返回参数的绝对值。 |
8 | cell() 返回大于等于( >= )给定参数的的最小整数,类型为双精度浮点型。 |
9 | floor() 返回小于等于(<=)给定参数的最大整数 。 |
10 | rint() 返回与参数最接近的整数。返回类型为double。 |
11 | round() 四舍五入,算法为 Math.floor(x+0.5),即将原来的数字加上 0.5 后再向下取整,所以Math.round(11.5) 的结果为12,Math.round(-11.5) 的结果为-11。 |
12 | min() 返回两个参数中的最小值。 |
13 | max() 返回两个参数中的最大值。 |
14 | exp() 返回自然数底数e的参数次方。 |
15 | log() 返回参数的自然数底数的对数值。 |
16 | pow() 返回第一个参数的第二个参数次方。 |
17 | sqrt() 求参数的算术平方根。 |
18 | sin() 求指定double类型参数的正弦值。 |
19 | cos() 求指定double类型参数的余弦值。 |
20 | tan() 求指定double类型参数的正切值。 |
21 | asin() 求指定double类型参数的反正弦值。 |
22 | acos() 求指定double类型参数的反余弦值。 |
23 | atan() 求指定double类型参数的反正切值。 |
24 | atan2() 将笛卡尔坐标转换为极坐标,并返回极坐标的角度值。 |
25 | toDegrees() 将参数转化为角度。 |
26 | toRadians() 将角度转换为弧度。 |
27 | random() 返回一个随机数。 |
接下来我们一一来说明,下面这段会有些长,主要是对上表的内容进行进一步解释与举例,需要跳过请点击13.3 Math 的 floor,round 和 ceil 方法实例比较:
- Java xxxValue() 方法
xxxValue() 方法用于将 Number 对象转换为 xxx 数据类型的值并返回。相关的方法有:
类型 | 方法及描述 |
---|---|
byte | byteValue() :以 byte 形式返回指定的数值。 |
abstract double | doubleValue() :以 double 形式返回指定的数值。 |
abstract float | floatValue() :以 float 形式返回指定的数值。 |
abstract int | intValue() :以 int 形式返回指定的数值。 |
abstract long | longValue() :以 long 形式返回指定的数值。 |
short | shortValue() :以 short 形式返回指定的数值。 |
参数:以上各函数不接受任何的参数。
返回值:转换为 xxx 类型后该对象表示的数值。
public class Test{
public static void main(String args[]){
Integer x = 5;
// 返回 byte 原生数据类型
System.out.println( x.byteValue() );
// 返回 double 原生数据类型
System.out.println(x.doubleValue());
// 返回 long 原生数据类型
System.out.println( x.longValue() );
}
}
当上面的代码被编译时,它会产生下列结果:
5
5.0
5
- Java compareTo() 方法
compareTo() 方法用于将 Number 对象与方法的参数进行比较,可用于比较 Byte, Long, Integer等,该方法用于两个相同数据类型的比较,两个不同类型的数据不能用此方法来比较。语法格式如下:
public int compareTo( NumberSubClass referenceName )
参数:referenceName -- 可以是一个 Byte, Double, Integer, Float, Long 或 Short 类型的参数。
返回值:如果指定的数与参数相等返回0;如果指定的数小于参数返回 -1;如果指定的数大于参数返回 1。
public class Test{
public static void main(String args[]){
Integer x = 5;
System.out.println(x.compareTo(3));
System.out.println(x.compareTo(5));
System.out.println(x.compareTo(8));
}
}
当上面的代码被编译时,它会产生下列结果:
1
0
-1
- Java equals() 方法
equals() 方法用于判断 Number 对象与方法的参数进是否相等,语法格式为:
public boolean equals(Object o)
参数:o -- 任何对象。
返回值:如 Number 对象不为 Null,且与方法的参数类型与数值都相等返回 True,否则返回 False。
public class Test{
public static void main(String args[]){
Integer x = 5;
Integer y = 10;
Integer z =5;
Short a = 5;
System.out.println(x.equals(y));
System.out.println(x.equals(z));
System.out.println(x.equals(a));
}
}
当上面的代码被编译时,它会产生下列结果:
false
true
false
-
Java valueOf() 方法
valueOf() 方法用于返回给定参数的原生 Number 对象值,参数可以是原生数据类型, String等,该方法是静态方法。该方法可以接收两个参数一个是字符串,一个是基数,该方法有以下几种语法格式:
static Integer valueOf(int i)
static Integer valueOf(String s)
static Integer valueOf(String s, int radix)
参数
-
i -- Integer 对象的整数。
-
s -- Integer 对象的字符串。
-
radix --在解析字符串 s 时使用的进制数,用于指定使用的进制数。
返回值
-
Integer valueOf(int i):返回一个表示指定的 int 值的 Integer 实例。
-
Integer valueOf(String s):返回保存指定的 String 的值的 Integer 对象。
-
Integer valueOf(String s, int radix): 返回一个 Integer 对象,该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。
public class Test{
public static void main(String args[]){
Integer x =Integer.valueOf(9);
Double c = Double.valueOf(5);
Float a = Float.valueOf("80");
Integer b = Integer.valueOf("444",16); // 使用 16 进制
System.out.println(x);
System.out.println(c);
System.out.println(a);
System.out.println(b);
}
}
当上面的代码被编译时,它会产生下列结果:
9
5.0
80.0
1092
- Java toString() 方法
toString() 方法用于返回以一个字符串表示的 Number 对象值,如果方法使用了原生的数据类型作为参数,返回原生数据类型的 String 对象值,如果方法有两个参数, 返回用第二个参数指定基数表示的第一个参数的字符串表示形式。以 String 类为例,该方法有以下几种语法格式:
String toString()
static String toString(int i)
参数:i -- 要转换的整数。
返回值:toString(): 返回表示 Integer 值的 String 对象;toString(int i): 返回表示指定 int 的 String 对象。
public class Test{
public static void main(String args[]){
Integer x = 5;
System.out.println(x.toString());
System.out.println(Integer.toString(12));
}
}
当上面的代码被编译时,它会产生下列结果:
5
12
- Java parseInt() 方法
parseInt() 方法用于将字符串参数作为有符号的十进制整数进行解析,如果方法有两个参数, 使用第二个参数指定的基数,将字符串参数解析为有符号的整数。所有 Number 派生类 parseInt 方法格式类似如下:
static int parseInt(String s)
static int parseInt(String s, int radix)
参数
-
s -- 十进制表示的字符串。
-
radix -- 指定的基数。
返回值
-
parseInt(String s): 返回用十进制参数表示的整数值。
-
parseInt(int i): 使用指定基数的字符串参数表示的整数 (基数可以是 10, 2, 8, 或 16 等进制数) 。
public class Test{
public static void main(String args[]){
int x =Integer.parseInt("9");
double c = Double.parseDouble("5");
int b = Integer.parseInt("444",16);
System.out.println(x);
System.out.println(c);
System.out.println(b);
}
}
当上面的代码被编译时,它会产生下列结果:
9
5.0
1092
- Java abs() 方法
abs() 返回参数的绝对值,参数可以是 int, float, long, double, short, byte类型。各个类型的方法格式类似如下:
double abs(double d)
float abs(float f)
int abs(int i)
long abs(long lng)
参数:任何原生数据类型。
返回值:返回参数的绝对值。
public class Test{
public static void main(String args[]){
Integer a = -8;
double d = -100;
float f = -90;
System.out.println(Math.abs(a));
System.out.println(Math.abs(d));
System.out.println(Math.abs(f));
}
}
当上面的代码被编译时,它会产生下列结果:
8
100.0
90.0
- Java ceil() 方法
ceil() 方法可对一个数进行上舍入,返回值大于或等于给定的参数,类型为双精度浮点型。该方法有以下几种语法格式:
double ceil(double d)
double ceil(float f)
参数:double 或 float 的原生数据类型。
返回值:返回 double 类型,返回值大于或等于给定的参数。
public class Test{
public static void main(String args[]){
double d = 100.675;
float f = -90;
System.out.println(Math.ceil(d));
System.out.println(Math.ceil(f));
System.out.println(Math.floor(d));
System.out.println(Math.floor(f));
}
}
当上面的代码被编译时,它会产生下列结果:
101.0
-90.0
100.0
-90.0
- Java floor() 方法
floor() 方法可对一个数进行下舍入,返回给定参数最大的整数,该整数小于或等给定的参数。该方法有以下几种语法格式:
double floor(double d)
double floor(float f)
参数:double 或 float 的原生数据类型。
返回值:返回 double 类型数据,小于或等于给定的参数。
public class Test{
public static void main(String args[]){
double d = 100.675;
float f = -90;
System.out.println(Math.floor(d));
System.out.println(Math.floor(f));
System.out.println(Math.ceil(d));
System.out.println(Math.ceil(f));
}
}
当上面的代码被编译时,它会产生下列结果:
100.0
-90.0
101.0
-90.0
- Java rint() 方法
rint() 方法返回最接近参数的整数值。该方法有以下几种语法格式:
double rint(double d)
参数:double 原始数据类型。
返回值:返回 double 类型数组,是最接近参数的整数值。
public class Test{
public static void main(String args[]){
double d = 100.675;
double e = 100.500;
double f = 100.200;
System.out.println(Math.rint(d));
System.out.println(Math.rint(e));
System.out.println(Math.rint(f));
}
}
当上面的代码被编译时,它会产生下列结果:
101.0
100.0
100.0
- Java round() 方法
round() 方法返回一个最接近的 int、long 型值,四舍五入。round 表示"四舍五入",算法为Math.floor(x+0.5) ,即将原来的数字加上 0.5 后再向下取整,所以 Math.round(11.5) 的结果为 12,Math.round(-11.5) 的结果为 -11。该方法有以下几种语法格式:
long round(double d)
int round(float f)
参数:d -- double 或 float 的原生数据类型;f -- float 原生数据类型
返回值:返回一个最接近的int、long型值,方法会指定返回的数据类型。
public class Test{
public static void main(String args[]){
double d = 100.675;
double e = 100.500;
float f = 100;
float g = 90f;
System.out.println(Math.round(d));
System.out.println(Math.round(e));
System.out.println(Math.round(f));
System.out.println(Math.round(g));
}
}
当上面的代码被编译时,它会产生下列结果:
101
101
100
90
- Java min() 方法
min() 方法用于返回两个参数中的最小值。该方法有以下几种语法格式:
double min(double arg1, double arg2)
float min(float arg1, float arg2)
int min(int arg1, int arg2)
long min(long arg1, long arg2)
参数:该方法接受两个原生数据类型作为参数。
返回值:返回两个参数中的最小值。
public class Test{
public static void main(String args[]){
System.out.println(Math.min(12.123, 12.456));
System.out.println(Math.min(23.12, 23.0));
}
}
当上面的代码被编译时,它会产生下列结果:
12.123
23.0
- Java max() 方法
max() 方法用于返回两个参数中的最大值。该方法有以下几种语法格式:
double max(double arg1, double arg2)
float max(float arg1, float arg2)
int max(int arg1, int arg2)
long max(long arg1, long arg2)
参数:该方法接受两个原生数据类型作为参数。
返回值:返回两个参数中的最大值。
public class Test{
public static void main(String args[]){
System.out.println(Math.max(12.123, 18.456));
System.out.println(Math.max(23.12, 23.0));
}
}
当上面的代码被编译时,它会产生下列结果:
18.456
23.12
- Java exp() 方法
exp() 方法用于返回自然数底数e的参数次方,该方法有以下几种语法格式:
double exp(double d)
参数:d -- 任何原生数据类型。
返回值:返回自然数底数e的参数次方。
public class Test{
public static void main(String args[]){
double x = 11.635;
double y = 2.76;
System.out.printf("e 的值为 %.4f%n", Math.E);
System.out.printf("exp(%.3f) 为 %.3f%n", x, Math.exp(x));
}
}
当上面的代码被编译时,它会产生下列结果:
e 的值为 2.7183
exp(11.635) 为 112983.831
- Java log() 方法
log() 方法用于返回参数的自然数底数的对数值。语法格式如下:
double log(double d)
参数:d -- 任何原生数据类型。
返回值:返回参数的自然数底数的对数值。
public class Test{
public static void main(String args[]){
double x = 11.635;
double y = 2.76;
System.out.printf("e 的值为 %.4f%n", Math.E);
System.out.printf("log(%.3f) 为 %.3f%n", x, Math.log(x));
}
}
当上面的代码被编译时,它会产生下列结果:
e 的值为 2.7183
log(11.635) 为 2.454
- Java pow() 方法
pow() 方法用于返回第一个参数的第二个参数次方。格式如下:
double pow(double base, double exponent)
参数:base -- 任何原生数据类型;exponent -- 任何原生数据类型。
返回值:返回第一个参数的第二个参数次方。
public class Test{
public static void main(String args[]){
double x = 11.635;
double y = 2.76;
System.out.printf("e 的值为 %.4f%n", Math.E);
System.out.printf("pow(%.3f, %.3f) 为 %.3f%n", x, y, Math.pow(x, y));
}
}
当上面的代码被编译时,它会产生下列结果:
e 的值为 2.7183
pow(11.635, 2.760) 为 874.008
- Java sqrt() 方法
sqrt() 方法用于返回参数的算术平方根。格式如下:
double sqrt(double d)
参数:d -- 任何原生数据类型。
返回值:返回参数的算术平方根。
public class Test{
public static void main(String args[]){
double x = 11.635;
double y = 2.76;
System.out.printf("e 的值为 %.4f%n", Math.E);
System.out.printf("sqrt(%.3f) 为 %.3f%n", x, Math.sqrt(x));
}
}
当上面的代码被编译时,它会产生下列结果:
e 的值为 2.7183
sqrt(11.635) 为 3.411
- Java sin() 方法
sin() 方法用于返回指定double类型参数的正弦值。格式如下:
double sin(double d)
参数:d -- 任何原生数据类型。
返回值:返回指定double类型参数的正弦值。
public class Test{
public static void main(String args[]){
double degrees = 45.0;
double radians = Math.toRadians(degrees);
System.out.format("pi 的值为 %.4f%n", Math.PI);
System.out.format("%.1f 度的正弦值为 %.4f%n", degrees, Math.sin(radians));
}
}
当上面的代码被编译时,它会产生下列结果:
pi 的值为 3.1416
45.0 度的正弦值为 0.7071
- Java cos() 方法
cos() 方法用于返回指定double类型参数的余弦值。格式如下:
double cos(double d)
参数:d -- 任何原生数据类型。
返回值:返回指定double类型参数的余弦值。
public class Test{
public static void main(String args[]){
double degrees = 45.0;
double radians = Math.toRadians(degrees);
System.out.format("pi 的值为 %.4f%n", Math.PI);
System.out.format("%.1f 度的余弦值为 %.4f%n", degrees, Math.cos(radians));
}
}
当上面的代码被编译时,它会产生下列结果:
pi 的值为 3.1416
45.0 度的余弦值为 0.7071
- Java tan() 方法
tan() 方法用于返回指定double类型参数的正切值。格式如下:
double tan(double d)
参数:d -- 任何原生数据类型。
返回值:返回指定double类型参数的正切值。
public class Test{
public static void main(String args[]){
double degrees = 45.0;
double radians = Math.toRadians(degrees);
System.out.format("pi 的值为 %.4f%n", Math.PI);
System.out.format("%.1f 度的正切值是 %.4f%n", degrees, Math.tan(radians));
}
}
当上面的代码被编译时,它会产生下列结果:
pi 的值为 3.1416
45.0 度的正切值是 1.0000
- Java asin() 方法
asin() 方法用于返回指定double类型参数的反正弦值。格式如下:
double asin(double d)
参数:d -- 任何原生数据类型。
返回值:返回指定double类型参数的反正弦值。
public class Test{
public static void main(String args[]){
double degrees = 45.0;
double radians = Math.toRadians(degrees);
System.out.format("pi 的值为 %.4f%n", Math.PI);
System.out.format("%.4f 的反正弦值为 %.4f 度 %n", Math.sin(radians),
Math.toDegrees(Math.asin(Math.sin(radians))));
}
}
当上面的代码被编译时,它会产生下列结果:
pi 的值为 3.1416
0.7071 的反正弦值为 45.0000 度
- Java acos() 方法
acos() 方法用于返回指定double类型参数的反余弦值。格式如下:
double acos(double d)
参数:d -- 任何原生数据类型。
返回值:返回指定double类型参数的反余弦值。
public class Test{
public static void main(String args[]){
double degrees = 45.0;
double radians = Math.toRadians(degrees);
System.out.format("pi 的值为 %.4f%n", Math.PI);
System.out.format("%.4f 的反余弦值为 %.4f 度 %n", Math.cos(radians),
Math.toDegrees(Math.acos(Math.sin(radians))));
}
}
当上面的代码被编译时,它会产生下列结果:
pi 的值为 3.1416
0.7071 的反余弦值为 45.0000 度
- Java atan() 方法
atan() 方法用于返回指定double类型参数的反正切值。格式如下:
double atan(double d)
参数:d -- 任何原生数据类型。
返回值:返回指定double类型参数的反正切值。
public class Test{
public static void main(String args[]){
double degrees = 45.0;
double radians = Math.toRadians(degrees);
System.out.format("pi 的值为 %.4f%n", Math.PI);
System.out.format("%.4f 的反正切值 %.4f 度 %n", Math.cos(radians),
Math.toDegrees(Math.atan(Math.sin(radians))));
}
}
当上面的代码被编译时,它会产生下列结果:
pi 的值为 3.1416
0.7071 的反正切值 35.2644 度
- Java atan2() 方法
atan2() 方法用于将矩形坐标 (x, y) 转换成极坐标 (r, theta),返回所得角 theta。该方法通过计算 y/x 的反正切值来计算相角 theta,范围为从 -pi 到 pi。语法格式如下:
double atan2(double y, double x)
参数:y -- 纵坐标;x -- 横坐标。
返回值:与笛卡儿坐标中点 (x, y) 对应的极坐标中点 (r, theta) 的 theta 组件。
public class Test{
public static void main(String args[]){
double x = 45.0;
double y = 30.0;
System.out.println( Math.atan2(x, y) );
}
}
当上面的代码被编译时,它会产生下列结果:
0.982793723247329
- Java toDegrees() 方法
toDegrees() 方法用于将参数转化为角度。格式如下:
double toDegrees(double d)
参数:d -- 任何原生数据类型。
返回值:该方法返回 double 值。
public class Test{
public static void main(String args[]){
double x = 45.0;
double y = 30.0;
System.out.println( Math.toDegrees(x) );
System.out.println( Math.toDegrees(y) );
}
}
当上面的代码被编译时,它会产生下列结果:
2578.3100780887044
1718.8733853924698
- Java toRadians() 方法
toRadians() 方法用于将角度转换为弧度。格式如下:
double toRadians(double d)
参数:d -- 任何原生数据类型。
返回值:该方法返回 double 值。
public class Test{
public static void main(String args[]){
double x = 45.0;
double y = 30.0;
System.out.println( Math.toRadians(x) );
System.out.println( Math.toRadians(y) );
}
}
当上面的代码被编译时,它会产生下列结果:
0.7853981633974483
0.5235987755982988
- Java random() 方法
random() 方法用于返回一个随机数,随机数范围为 0.0 =< Math.random < 1.0。格式如下:
static double random()
参数:这是一个默认方法,不接受任何参数。
返回值:该方法返回 double 值。
public class Test{
public static void main(String args[]){
System.out.println( Math.random() );
System.out.println( Math.random() );
}
}
当上面的代码被编译时,它会产生下列结果:
0.5444085967267008
0.7960235983184115
13.3 Math 的 floor,round 和 ceil 方法实例比较
参数 | Math.floor | Math.round | Math.ceil |
---|---|---|---|
1.4 | 1 | 1 | 2 |
1.5 | 1 | 2 | 2 |
1.6 | 1 | 2 | 2 |
-1.4 | -2 | -1 | -1 |
-1.5 | -2 | -1 | -1 |
-1.6 | -2 | -2 | -1 |
public class Main {
public static void main(String[] args) {
double[] nums = { 1.4, 1.5, 1.6, -1.4, -1.5, -1.6 };
for (double num : nums) {
test(num);
}
}
private static void test(double num) {
System.out.println("Math.floor(" + num + ")=" + Math.floor(num));
System.out.println("Math.round(" + num + ")=" + Math.round(num));
System.out.println("Math.ceil(" + num + ")=" + Math.ceil(num));
}
}
当上面的代码被编译时,它会产生下列结果:
Math.floor(1.4)=1.0
Math.round(1.4)=1
Math.ceil(1.4)=2.0
Math.floor(1.5)=1.0
Math.round(1.5)=2
Math.ceil(1.5)=2.0
Math.floor(1.6)=1.0
Math.round(1.6)=2
Math.ceil(1.6)=2.0
Math.floor(-1.4)=-2.0
Math.round(-1.4)=-1
Math.ceil(-1.4)=-1.0
Math.floor(-1.5)=-2.0
Math.round(-1.5)=-1
Math.ceil(-1.5)=-1.0
Math.floor(-1.6)=-2.0
Math.round(-1.6)=-2
Math.ceil(-1.6)=-1.0
14.Character 类
Character 类用于对单个字符进行操作,Character 类在对象中包装一个基本类型 char 的值:
char ch = 'a';
// Unicode 字符表示形式
char uniChar = '\u039A';
// 字符数组
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };
然而,在实际开发过程中,我们经常会遇到需要使用对象,而不是内置数据类型的情况。为了解决这个问题,Java语言为内置数据类型char提供了包装类Character类。
Character类提供了一系列方法来操纵字符。你可以使用Character的构造方法创建一个Character类对象,例如:
Character ch = new Character('a');
在某些情况下,Java编译器会自动创建一个Character对象,例如,将一个char类型的参数传递给需要一个Character类型参数的方法时,那么编译器会自动地将char类型参数转换为Character对象。 这种特征称为装箱,反过来称为拆箱:
// 原始字符 'a' 装箱到 Character 对象 ch 中
Character ch = 'a';
// 原始字符 'x' 用 test 方法装箱
// 返回拆箱的值到 'c'
char c = test('x');
- 转义序列
前面有反斜杠(\)的字符代表转义字符,它对编译器来说是有特殊含义的,下面列表展示了Java的转义序列:
转义序列 | 描述 |
---|---|
\t | 在文中该处插入一个tab键 |
\b | 在文中该处插入一个后退键 |
\n | 在文中该处换行 |
\r | 在文中该处插入回车 |
\f | 在文中该处插入换页符 |
\' | 在文中该处插入单引号 |
\" | 在文中该处插入双引号 |
\\ | 在文中该处插入反斜杠 |
当打印语句遇到一个转义序列时,编译器可以正确地对其进行解释,以下实例转义双引号并输出:
public class Test {
public static void main(String args[]) {
System.out.println("访问\"紫薇星!\"");
}
}
当上面的代码被编译时,它会产生下列结果:
访问"紫薇星!"
- Character 方法
下面是Character类的方法:
序号 | 方法与描述 |
---|---|
1 | isLetter() 是否是一个字母 |
2 | isDigit() 是否是一个数字字符 |
3 | isWhitespace() 是否是一个空白字符 |
4 | isUpperCase() 是否是大写字母 |
5 | isLowerCase() 是否是小写字母 |
6 | toUpperCase() 指定字母的大写形式 |
7 | toLowerCase() 指定字母的小写形式 |
8 | toString() 返回字符的字符串形式,字符串的长度仅为1 |
接下来将一一进行说明,主要是对上表内容进行解释和说明:
- Java isLetter() 方法
isLetter() 方法用于判断指定字符是否为字母。语法格式为:
boolean isLetter(char ch)
参数:ch -- 要测试的字符。
返回值:如果字符为字母,则返回 true;否则返回 false。
public class Test {
public static void main(String args[]) {
System.out.println(Character.isLetter('c'));
System.out.println(Character.isLetter('5'));
}
}
当上面的代码被编译时,它会产生下列结果:
true
false
- Java isDigit() 方法
isDigit() 方法用于判断指定字符是否为数字,格式如下:
public static boolean isDigit(char ch)
参数:ch -- 要测试的字符。
返回值:如果字符为数字,则返回 true;否则返回 false。
public class Test {
public static void main(String args[]) {
System.out.println(Character.isDigit('c'));
System.out.println(Character.isDigit('5'));
}
}
当上面的代码被编译时,它会产生下列结果:
false
true
- Java isWhitespace() 方法
isWhitespace() 方法用于判断指定字符是否为空白字符,空白符包含:空格、tab 键、换行符。格式如下:
boolean isWhitespace(char ch)
参数:ch -- 要测试的字符。
返回值:如果字符为空白字符,则返回 true;否则返回 false。
public class Test {
public static void main(String args[]) {
System.out.println(Character.isWhitespace('c'));
System.out.println(Character.isWhitespace(' '));
System.out.println(Character.isWhitespace('\n'));
System.out.println(Character.isWhitespace('\t'));
}
}
当上面的代码被编译时,它会产生下列结果:
false
true
true
true
- Java isUpperCase() 方法
isUpperCase() 方法用于判断指定字符是否为大写字母。格式如下:
boolean isUpperCase(char ch)
参数:ch -- 要测试的字符。
返回值:如果字符为大写,则返回 true;否则返回 false。
public class Test {
public static void main(String args[]) {
System.out.println( Character.isUpperCase('c'));
System.out.println( Character.isUpperCase('C'));
}
}
当上面的代码被编译时,它会产生下列结果:
false
true
- Java isLowerCase() 方法
isLowerCase() 方法用于判断指定字符是否为小写字母。格式如下:
boolean isLowerCase(char ch)
参数:ch -- 要测试的字符。
返回值:如果字符为小写,则返回 true;否则返回 false。
public class Test {
public static void main(String args[]) {
System.out.println( Character.isLowerCase('c'));
System.out.println( Character.isLowerCase('C'));
}
}
当上面的代码被编译时,它会产生下列结果:
true
false
- Java toUpperCase() 方法
toUpperCase() 方法用于将小写字符转换为大写。格式如下:
char toUpperCase(char ch)
参数:ch -- 要转换的字符。
返回值:返回转换后字符的大写形式,如果有的话;否则返回字符本身。
public class Test {
public static void main(String args[]) {
System.out.println(Character.toUpperCase('a'));
System.out.println(Character.toUpperCase('A'));
}
}
当上面的代码被编译时,它会产生下列结果:
A
A
- Java toLowerCase() 方法
toLowerCase() 方法用于将大写字符转换为小写。格式如下:
char toLowerCase(char ch)
参数:ch -- 要转换的字符。
返回值:返回转换后字符的小写形式,如果有的话;否则返回字符本身。
public class Test {
public static void main(String args[]) {
System.out.println(Character.toLowerCase('a'));
System.out.println(Character.toLowerCase('A'));
}
}
当上面的代码被编译时,它会产生下列结果:
a
a
- Java toString() 方法
toString() 方法用于返回一个表示指定 char 值的 String 对象。结果是长度为 1 的字符串,仅由指定的 char 组成。格式如下:
String toString(char ch)
参数:ch -- 要转换的字符。
返回值:返回指定 char 值的字符串表示形式。
public class Test {
public static void main(String args[]) {
System.out.println(Character.toString('a'));
System.out.println(Character.toString('A'));
}
}
当上面的代码被编译时,它会产生下列结果:
a
A
这部分整理了一些比较实用的方法和类,不过为了大家的阅读体验,主要整理了Number&Math类和Character 类,还有一些类和方法如String类、StringBuffer类等将会在下午发出来,下午见!