JAVA面试题解惑系列（八）——聊聊基本类型（内置类型）

最新推荐文章于 2022-07-13 22:19:30 发布
最新推荐文章于 2022-07-13 22:19:30 发布
阅读量481 收藏 4
点赞数
分类专栏： Java面试 文章标签： java 面试 integer float byte string

基本类型，或者叫做内置类型，是JAVA中不同于类的特殊类型。它们是我们编程中使用最频繁的类型，因此面试题中也总少不了它们的身影，在这篇文章中我们将从面试中常考的几个方面来回顾一下与基本类型相关的知识。

基本类型共有九种，它们分别都有相对应的包装类。关于它们的详细信息请看下表：

[img]http://zangweiren.javaeye.com/upload/picture/pic/18450/8071c6c2-7cfb-3783-829a-a6abb3ae55e5.jpg [/img]

对于基本类型void以及它的包装类java.lang.Void，我们都无法直接进行操作。基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。请看下面的例子：

Java代码 复制代码
  1. public class PrimitiveTypeTest {   
  2.     public static void main(String[] args) {   
  3.         // byte   
  4.         System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);   
  5.         System.out.println("包装类：java.lang.Byte");   
  6.         System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);   
  7.         System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);   
  8.         System.out.println();   
  9.   
  10.         // short   
  11.         System.out.println("基本类型：short 二进制位数：" + Short.SIZE);   
  12.         System.out.println("包装类：java.lang.Short");   
  13.         System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);   
  14.         System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);   
  15.         System.out.println();   
  16.   
  17.         // int   
  18.         System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);   
  19.         System.out.println("包装类：java.lang.Integer");   
  20.         System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);   
  21.         System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);   
  22.         System.out.println();   
  23.   
  24.         // long   
  25.         System.out.println("基本类型：long 二进制位数：" + Long.SIZE);   
  26.         System.out.println("包装类：java.lang.Long");   
  27.         System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);   
  28.         System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);   
  29.         System.out.println();   
  30.   
  31.         // float   
  32.         System.out.println("基本类型：float 二进制位数：" + Float.SIZE);   
  33.         System.out.println("包装类：java.lang.Float");   
  34.         System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);   
  35.         System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);   
  36.         System.out.println();   
  37.   
  38.         // double   
  39.         System.out.println("基本类型：double 二进制位数：" + Double.SIZE);   
  40.         System.out.println("包装类：java.lang.Double");   
  41.         System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);   
  42.         System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);   
  43.         System.out.println();   
  44.   
  45.         // char   
  46.         System.out.println("基本类型：char 二进制位数：" + Character.SIZE);   
  47.         System.out.println("包装类：java.lang.Character");   
  48.         // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台   
  49.         System.out.println("最小值：Character.MIN_VALUE="  
  50.                 + (int) Character.MIN_VALUE);   
  51.         // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台   
  52.         System.out.println("最大值：Character.MAX_VALUE="  
  53.                 + (int) Character.MAX_VALUE);   
  54.     }   
  55. }  
public class PrimitiveTypeTest {
	public static void main(String[] args) {
		// byte
		System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
		System.out.println("包装类：java.lang.Byte");
		System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
		System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
		System.out.println();

		// short
		System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
		System.out.println("包装类：java.lang.Short");
		System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
		System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
		System.out.println();

		// int
		System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
		System.out.println("包装类：java.lang.Integer");
		System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
		System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
		System.out.println();

		// long
		System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
		System.out.println("包装类：java.lang.Long");
		System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
		System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
		System.out.println();

		// float
		System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
		System.out.println("包装类：java.lang.Float");
		System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
		System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
		System.out.println();

		// double
		System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
		System.out.println("包装类：java.lang.Double");
		System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
		System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
		System.out.println();

		// char
		System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
		System.out.println("包装类：java.lang.Character");
		// 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
		System.out.println("最小值：Character.MIN_VALUE="
				+ (int) Character.MIN_VALUE);
		// 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
		System.out.println("最大值：Character.MAX_VALUE="
				+ (int) Character.MAX_VALUE);
	}
}


运行结果：

  1. 基本类型：byte 二进制位数：8
  2. 包装类：java.lang.Byte
  3. 最小值：Byte.MIN_VALUE=-128
  4. 最大值：Byte.MAX_VALUE=127
  5. 基本类型：short 二进制位数：16
  6. 包装类：java.lang.Short
  7. 最小值：Short.MIN_VALUE=-32768
  8. 最大值：Short.MAX_VALUE=32767
  9. 基本类型：int 二进制位数：32
  10. 包装类：java.lang.Integer
  11. 最小值：Integer.MIN_VALUE=-2147483648
  12. 最大值：Integer.MAX_VALUE=2147483647
  13. 基本类型：long 二进制位数：64
  14. 包装类：java.lang.Long
  15. 最小值：Long.MIN_VALUE=-9223372036854775808
  16. 最大值：Long.MAX_VALUE=9223372036854775807
  17. 基本类型：float 二进制位数：32
  18. 包装类：java.lang.Float
  19. 最小值：Float.MIN_VALUE=1.4E-45
  20. 最大值：Float.MAX_VALUE=3.4028235E38
  21. 基本类型：double 二进制位数：64
  22. 包装类：java.lang.Double
  23. 最小值：Double.MIN_VALUE=4.9E-324
  24. 最大值：Double.MAX_VALUE=1.7976931348623157E308
  25. 基本类型：char 二进制位数：16
  26. 包装类：java.lang.Character
  27. 最小值：Character.MIN_VALUE=0
  28. 最大值：Character.MAX_VALUE=65535


Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的“E+数字”表示E之前的数字要乘以10的多少倍。比如3.14E3就是3.14×1000=3140，3.14E-3就是3.14/1000=0.00314。

大家将运行结果与上表信息仔细比较就会发现float、double两种类型的最小值与Float.MIN_VALUE、Double.MIN_VALUE的值并不相同，这是为什么呢？实际上Float.MIN_VALUE和Double.MIN_VALUE分别指的是float和double类型所能表示的最小正数。也就是说存在这样一种情况，0到±Float.MIN_VALUE之间的值float类型无法表示，0到±Double.MIN_VALUE之间的值double类型无法表示。这并没有什么好奇怪的，因为这些范围内的数值超出了它们的精度范围。

基本类型存储在栈中，因此它们的存取速度要快于存储在堆中的对应包装类的实例对象。从Java5.0（1.5）开始，JAVA虚拟机（Java Virtual Machine）可以完成基本类型和它们对应包装类之间的自动转换。因此我们在赋值、参数传递以及数学运算的时候像使用基本类型一样使用它们的包装类，但这并不意味着你可以通过基本类型调用它们的包装类才具有的方法。另外，所有基本类型（包括void）的包装类都使用了final修饰，因此我们无法继承它们扩展新的类，也无法重写它们的任何方法。

各种数值类型之间的赋值与转换遵循什么规律呢？我们来看下面这个例子：

Java代码 复制代码
  1. public class PrimitiveTypeTest {   
  2.     public static void main(String[] args) {   
  3.         // 给byte类型变量赋值时，数字后无需后缀标识   
  4.         byte byte_a = 1;   
  5.         // 编译器会做范围检查，如果赋予的值超出了范围就会报错   
  6.         // byte byte_b = 1000;   
  7.         // 把一个long型值赋值给byte型变量，编译时会报错，即使这个值没有超出byte类型的取值范围   
  8.         // byte byte_c = 1L;   
  9.   
  10.         // 给short类型变量赋值时，数字后无需后缀标识   
  11.         short short_a = 1;   
  12.         // 编译器会做范围检查，如果赋予的值超出了范围就会报错   
  13.         // short short_b = 70000;   
  14.         // 把一个long型值赋值给short型变量，编译时会报错，即使这个值没有超出short类型的取值范围   
  15.         // byte short_c = 1L;   
  16.   
  17.         // 给short类型变量赋值时，数字后无需后缀标识   
  18.         int int_a = 1;   
  19.         // 编译器会做范围检查，如果赋予的值超出了范围就会报错   
  20.         // int int_b = 2200000000;   
  21.         // 把一个long型值赋值给int型变量，编译时会报错，即使这个值没有超出int类型的取值范围   
  22.         // int int_c = 1L;   
  23.   
  24.         // 可以把一个int型值直接赋值给long型变量，数字后无需后缀标识   
  25.         long long_a = 1;   
  26.         // 如果给long型变量赋予的值超出了int型值的范围，数字后必须加L（不区分大小写）标识   
  27.         long long_b = 2200000000L;   
  28.         // 编译器会做范围检查，如果赋予的值超出了范围就会报错   
  29.         // long long_c = 9300000000000000000L;   
  30.   
  31.         // 可以把一个int型值直接赋值给float型变量   
  32.         float float_a = 1;   
  33.         // 可以把一个long型值直接赋值给float型变量   
  34.         float float_b = 1L;   
  35.         // 没有F（不区分大小写）后缀标识的浮点数默认为double型的，不能将它直接赋值给float型变量   
  36.         // float float_c = 1.0;   
  37.         // float型数值需要有一个F（不区分大小写）后缀标识   
  38.         float float_d = 1.0F;   
  39.         // 把一个double型值赋值给float型变量，编译时会报错，即使这个值没有超出float类型的取值范围   
  40.         // float float_e = 1.0D;   
  41.         // 编译器会做范围检查，如果赋予的值超出了范围就会报错   
  42.         // float float_f = 3.5000000E38F;   
  43.   
  44.         // 可以把一个int型值直接赋值给double型变量   
  45.         double double_a = 1;   
  46.         // 可以把一个long型值直接赋值给double型变量   
  47.         double double_b = 1L;   
  48.         // 可以把一个float型值直接赋值给double型变量   
  49.         double double_c = 1F;   
  50.         // 不带后缀标识的浮点数默认为double类型的，可以直接赋值   
  51.         double double_d = 1.0;   
  52.         // 也可以给数字增加一个D（不区分大小写）后缀标识，明确标出它是double类型的   
  53.         double double_e = 1.0D;   
  54.         // 编译器会做范围检查，如果赋予的值超出了范围就会报错   
  55.         // double double_f = 1.8000000000000000E308D;   
  56.   
  57.         // 把一个double型值赋值给一个byte类型变量，编译时会报错，即使这个值没有超出byte类型的取值范围   
  58.         // byte byte_d = 1.0D;   
  59.         // 把一个double型值赋值给一个short类型变量，编译时会报错，即使这个值没有超出short类型的取值范围   
  60.         // short short_d = 1.0D;   
  61.         // 把一个double型值赋值给一个int类型变量，编译时会报错，即使这个值没有超出int类型的取值范围   
  62.         // int int_d = 1.0D;   
  63.         // 把一个double型值赋值给一个long类型变量，编译时会报错，即使这个值没有超出long类型的取值范围   
  64.         // long long_d = 1.0D;   
  65.   
  66.         // 可以用字符初始化一个char型变量   
  67.         char char_a = 'a';   
  68.         // 也可以用一个int型数值初始化char型变量   
  69.         char char_b = 1;   
  70.         // 把一个long型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围   
  71.         // char char_c = 1L;   
  72.         // 把一个float型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围   
  73.         // char char_d = 1.0F;   
  74.         // 把一个double型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围   
  75.         // char char_e = 1.0D;   
  76.         // 编译器会做范围检查，如果赋予的值超出了范围就会报错   
  77.         // char char_f = 70000;   
  78.     }   
  79. }  
public class PrimitiveTypeTest {
	public static void main(String[] args) {
		// 给byte类型变量赋值时，数字后无需后缀标识
		byte byte_a = 1;
		// 编译器会做范围检查，如果赋予的值超出了范围就会报错
		// byte byte_b = 1000;
		// 把一个long型值赋值给byte型变量，编译时会报错，即使这个值没有超出byte类型的取值范围
		// byte byte_c = 1L;

		// 给short类型变量赋值时，数字后无需后缀标识
		short short_a = 1;
		// 编译器会做范围检查，如果赋予的值超出了范围就会报错
		// short short_b = 70000;
		// 把一个long型值赋值给short型变量，编译时会报错，即使这个值没有超出short类型的取值范围
		// byte short_c = 1L;

		// 给short类型变量赋值时，数字后无需后缀标识
		int int_a = 1;
		// 编译器会做范围检查，如果赋予的值超出了范围就会报错
		// int int_b = 2200000000;
		// 把一个long型值赋值给int型变量，编译时会报错，即使这个值没有超出int类型的取值范围
		// int int_c = 1L;

		// 可以把一个int型值直接赋值给long型变量，数字后无需后缀标识
		long long_a = 1;
		// 如果给long型变量赋予的值超出了int型值的范围，数字后必须加L（不区分大小写）标识
		long long_b = 2200000000L;
		// 编译器会做范围检查，如果赋予的值超出了范围就会报错
		// long long_c = 9300000000000000000L;

		// 可以把一个int型值直接赋值给float型变量
		float float_a = 1;
		// 可以把一个long型值直接赋值给float型变量
		float float_b = 1L;
		// 没有F（不区分大小写）后缀标识的浮点数默认为double型的，不能将它直接赋值给float型变量
		// float float_c = 1.0;
		// float型数值需要有一个F（不区分大小写）后缀标识
		float float_d = 1.0F;
		// 把一个double型值赋值给float型变量，编译时会报错，即使这个值没有超出float类型的取值范围
		// float float_e = 1.0D;
		// 编译器会做范围检查，如果赋予的值超出了范围就会报错
		// float float_f = 3.5000000E38F;

		// 可以把一个int型值直接赋值给double型变量
		double double_a = 1;
		// 可以把一个long型值直接赋值给double型变量
		double double_b = 1L;
		// 可以把一个float型值直接赋值给double型变量
		double double_c = 1F;
		// 不带后缀标识的浮点数默认为double类型的，可以直接赋值
		double double_d = 1.0;
		// 也可以给数字增加一个D（不区分大小写）后缀标识，明确标出它是double类型的
		double double_e = 1.0D;
		// 编译器会做范围检查，如果赋予的值超出了范围就会报错
		// double double_f = 1.8000000000000000E308D;

		// 把一个double型值赋值给一个byte类型变量，编译时会报错，即使这个值没有超出byte类型的取值范围
		// byte byte_d = 1.0D;
		// 把一个double型值赋值给一个short类型变量，编译时会报错，即使这个值没有超出short类型的取值范围
		// short short_d = 1.0D;
		// 把一个double型值赋值给一个int类型变量，编译时会报错，即使这个值没有超出int类型的取值范围
		// int int_d = 1.0D;
		// 把一个double型值赋值给一个long类型变量，编译时会报错，即使这个值没有超出long类型的取值范围
		// long long_d = 1.0D;

		// 可以用字符初始化一个char型变量
		char char_a = 'a';
		// 也可以用一个int型数值初始化char型变量
		char char_b = 1;
		// 把一个long型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围
		// char char_c = 1L;
		// 把一个float型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围
		// char char_d = 1.0F;
		// 把一个double型值赋值给一个char类型变量，编译时会报错，即使这个值没有超出char类型的取值范围
		// char char_e = 1.0D;
		// 编译器会做范围检查，如果赋予的值超出了范围就会报错
		// char char_f = 70000;
	}
}


从上面的例子中我们可以得出如下几条结论：

  1. 未带有字符后缀标识的整数默认为int类型；未带有字符后缀标识的浮点数默认为double类型。
  2. 如果一个整数的值超出了int类型能够表示的范围，则必须增加后缀“L”（不区分大小写，建议用大写，因为小写的L与阿拉伯数字1很容易混淆），表示为long型。
  3. 带有“F”（不区分大小写）后缀的整数和浮点数都是float类型的；带有“D”（不区分大小写）后缀的整数和浮点数都是double类型的。
  4. 编译器会在编译期对byte、short、int、long、float、double、char型变量的值进行检查，如果超出了它们的取值范围就会报错。
  5. int型值可以赋给所有数值类型的变量；long型值可以赋给long、float、double类型的变量；float型值可以赋给float、double类型的变量；double型值只能赋给double类型变量。


下图显示了几种基本类型之间的默认逻辑转换关系：

图中的实线表示无精度损失的转换，而虚线则表示这样的转换可能会损失一定的精度。如果我们想把一个能表示更大范围或者更高精度的类型，转换为一个范围更小或者精度更低的类型时，就需要使用强制类型转换（Cast）了。不过我们要尽量避免这种用法，因为它常常引发错误。请看下面的例子，如果不运行代码，你能预测它的结果吗？

Java代码 复制代码
  1. public class PrimitiveTypeTest {   
  2.     public static void main(String[] args) {   
  3.         int a = 123456;   
  4.         short b = (short) a;   
  5.         // b的值会是什么呢？   
  6.         System.out.println(b);   
  7.     }   
  8. }  
public class PrimitiveTypeTest {
	public static void main(String[] args) {
		int a = 123456;
		short b = (short) a;
		// b的值会是什么呢？
		System.out.println(b);
	}
}


运行结果：

  1. -7616


运算符对基本类型的影响

当使用+、-、*、/、%运算符对基本类型进行运算时，遵循如下规则：

  1. 只要两个操作数中有一个是double类型的，另一个将会被转换成double类型，并且结果也是double类型；
  2. 否则，只要两个操作数中有一个是float类型的，另一个将会被转换成float类型，并且结果也是float类型；
  3. 否则，只要两个操作数中有一个是long类型的，另一个将会被转换成long类型，并且结果也是long类型；
  4. 否则，两个操作数（包括byte、short、int、char）都将会被转换成int类型，并且结果也是int类型。


当使用+=、-=、*=、/=、%=、运算符对基本类型进行运算时，遵循如下规则：

  • 运算符右边的数值将首先被强制转换成与运算符左边数值相同的类型，然后再执行运算，且运算结果与运算符左边数值类型相同。


了解了这些，我们就能解答下面这个常考的面试题了。请看：

引用
short s1=1;s1=s1+1;有什么错？short s1=1;s1+=1;有什么错？


乍一看，觉得它们都应该没有错误，可以正常运行。我们来写个例子试试：

Java代码 复制代码
  1. public class PrimitiveTypeTest {   
  2.     public static void main(String[] args) {   
  3.         short s1 = 1;   
  4.         // 这一行代码会报编译错误   
  5.         // s1 = s1 + 1;   
  6.         // 这一行代码没有报错   
  7.         s1 = 1 + 1;   
  8.         // 这一行代码也没有报错   
  9.         s1 += 1;   
  10.     }   
  11. }  
public class PrimitiveTypeTest {
	public static void main(String[] args) {
		short s1 = 1;
		// 这一行代码会报编译错误
		// s1 = s1 + 1;
		// 这一行代码没有报错
		s1 = 1 + 1;
		// 这一行代码也没有报错
		s1 += 1;
	}
}


从例子中我们可以看出结果了。利用上面列举的规律，也很容易解释。在s1=s1+1;中，s1+1运算的结果是int型，把它赋值给一个short型变量s1，所以会报错；而在s1+=1;中，由于是s1是short类型的，所以1首先被强制转换为short型，然后再参与运算，并且结果也是short类型的，因此不会报错。那么，s1=1+1;为什么不报错呢？这是因为1+1是个编译时可以确定的常量，“+”运算在编译时就被执行了，而不是在程序执行的时候，这个语句的效果等同于s1=2，所以不会报错。前面讲过了，对基本类型执行强制类型转换可能得出错误的结果，因此在使用+=、-=、*=、/=、%=等运算符时，要多加注意。

当使用“==”运算符在基本类型和其包装类对象之间比较时，遵循如下规则：

  1. 只要两个操作数中有一个是基本类型，就是比较它们的数值是否相等。
  2. 否则，就是判断这两个对象的内存地址是否相等，即是否是同一个对象。


下面的测试例子则验证了以上的规则：

Java代码 复制代码
  1. public class EqualsTest {   
  2.     public static void main(String[] args) {   
  3.         // int类型用int类型初始化   
  4.         int int_int = 0;   
  5.         // int类型用Integer类型初始化   
  6.         int int_Integer = new Integer(0);   
  7.         // Integer类型用Integer类型初始化   
  8.         Integer Integer_Integer = new Integer(0);   
  9.         // Integer类型用int类型初始化   
  10.         Integer Integer_int = 0;   
  11.   
  12.         System.out.println("int_int == int_Integer结果是："  
  13.                 + (int_int == int_Integer));   
  14.         System.out.println("Integer_Integer == Integer_int结果是："  
  15.                 + (Integer_Integer == Integer_int));   
  16.         System.out.println();   
  17.         System.out.println("int_int == Integer_Integer结果是："  
  18.                 + (int_int == Integer_Integer));   
  19.         System.out.println("Integer_Integer == int_int结果是："  
  20.                 + (Integer_Integer == int_int));   
  21.         System.out.println();   
  22.   
  23.         // boolean类型用boolean类型初始化   
  24.         boolean boolean_boolean = true;   
  25.         // boolean类型用Boolean类型初始化   
  26.         boolean boolean_Boolean = new Boolean(true);   
  27.         // Boolean类型用Boolean类型初始化   
  28.         Boolean Boolean_Boolean = new Boolean(true);   
  29.         // Boolean类型用boolean类型初始化   
  30.         Boolean Boolean_boolean = true;   
  31.   
  32.         System.out.println("boolean_boolean == boolean_Boolean结果是："  
  33.                 + (boolean_boolean == boolean_Boolean));   
  34.         System.out.println("Boolean_Boolean == Boolean_boolean结果是："  
  35.                 + (Boolean_Boolean == Boolean_boolean));   
  36.         System.out.println();   
  37.         System.out.println("boolean_boolean == Boolean_Boolean结果是："  
  38.                 + (boolean_boolean == Boolean_Boolean));   
  39.         System.out.println("Boolean_Boolean == boolean_boolean结果是："  
  40.                 + (Boolean_Boolean == boolean_boolean));   
  41.     }   
  42. }  
public class EqualsTest {
	public static void main(String[] args) {
		// int类型用int类型初始化
		int int_int = 0;
		// int类型用Integer类型初始化
		int int_Integer = new Integer(0);
		// Integer类型用Integer类型初始化
		Integer Integer_Integer = new Integer(0);
		// Integer类型用int类型初始化
		Integer Integer_int = 0;

		System.out.println("int_int == int_Integer结果是："
				+ (int_int == int_Integer));
		System.out.println("Integer_Integer == Integer_int结果是："
				+ (Integer_Integer == Integer_int));
		System.out.println();
		System.out.println("int_int == Integer_Integer结果是："
				+ (int_int == Integer_Integer));
		System.out.println("Integer_Integer == int_int结果是："
				+ (Integer_Integer == int_int));
		System.out.println();

		// boolean类型用boolean类型初始化
		boolean boolean_boolean = true;
		// boolean类型用Boolean类型初始化
		boolean boolean_Boolean = new Boolean(true);
		// Boolean类型用Boolean类型初始化
		Boolean Boolean_Boolean = new Boolean(true);
		// Boolean类型用boolean类型初始化
		Boolean Boolean_boolean = true;

		System.out.println("boolean_boolean == boolean_Boolean结果是："
				+ (boolean_boolean == boolean_Boolean));
		System.out.println("Boolean_Boolean == Boolean_boolean结果是："
				+ (Boolean_Boolean == Boolean_boolean));
		System.out.println();
		System.out.println("boolean_boolean == Boolean_Boolean结果是："
				+ (boolean_boolean == Boolean_Boolean));
		System.out.println("Boolean_Boolean == boolean_boolean结果是："
				+ (Boolean_Boolean == boolean_boolean));
	}
}


运行结果：

  1. int_int == int_Integer结果是：true
  2. Integer_Integer == Integer_int结果是：false
  3. int_int == Integer_Integer结果是：true
  4. Integer_Integer == int_int结果是：true
  5. boolean_boolean == boolean_Boolean结果是：true
  6. Boolean_Boolean == Boolean_boolean结果是：false
  7. boolean_boolean == Boolean_Boolean结果是：true
  8. Boolean_Boolean == boolean_boolean结果是：true


为了便于查看，上例中变量命名没有采用规范的方式，而是采用了“变量类型”+“_”+“初始化值类型”的方式。

Math.round()方法

java.lang.Math类里有两个round()方法，它们的定义如下：

Java代码 复制代码
  1. public static int round(float a) {   
  2.     //other code   
  3. }   
  4.   
  5. public static long round(double a) {   
  6.     //other code   
  7. }  
public static int round(float a) {
    //other code
}

public static long round(double a) {
    //other code
}


它们的返回值都是整数，且都采用四舍五入法。运算规则如下：

  1. 如果参数为正数，且小数点后第一位>=5，运算结果为参数的整数部分+1。
  2. 如果参数为负数，且小数点后第一位>5，运算结果为参数的整数部分-1。
  3. 如果参数为正数，且小数点后第一位<5；或者参数为负数，且小数点后第一位<=5，运算结果为参数的整数部分。


我们可以通过下面的例子来验证：

Java代码 复制代码
  1. public class MathTest {   
  2.     public static void main(String[] args) {   
  3.         System.out.println("小数点后第一位=5");   
  4.         System.out.println("正数：Math.round(11.5)=" + Math.round(11.5));   
  5.         System.out.println("负数：Math.round(-11.5)=" + Math.round(-11.5));   
  6.         System.out.println();   
  7.   
  8.         System.out.println("小数点后第一位<5");   
  9.         System.out.println("正数：Math.round(11.46)=" + Math.round(11.46));   
  10.         System.out.println("负数：Math.round(-11.46)=" + Math.round(-11.46));   
  11.         System.out.println();   
  12.   
  13.         System.out.println("小数点后第一位>5");   
  14.         System.out.println("正数：Math.round(11.68)=" + Math.round(11.68));   
  15.         System.out.println("负数：Math.round(-11.68)=" + Math.round(-11.68));   
  16.     }   
  17. }  
public class MathTest {
	public static void main(String[] args) {
		System.out.println("小数点后第一位=5");
		System.out.println("正数：Math.round(11.5)=" + Math.round(11.5));
		System.out.println("负数：Math.round(-11.5)=" + Math.round(-11.5));
		System.out.println();

		System.out.println("小数点后第一位<5");
		System.out.println("正数：Math.round(11.46)=" + Math.round(11.46));
		System.out.println("负数：Math.round(-11.46)=" + Math.round(-11.46));
		System.out.println();

		System.out.println("小数点后第一位>5");
		System.out.println("正数：Math.round(11.68)=" + Math.round(11.68));
		System.out.println("负数：Math.round(-11.68)=" + Math.round(-11.68));
	}
}


运行结果：

  1. 小数点后第一位=5
  2. 正数：Math.round(11.5)=12
  3. 负数：Math.round(-11.5)=-11
  4. 小数点后第一位<5
  5. 正数：Math.round(11.46)=11
  6. 负数：Math.round(-11.46)=-11
  7. 小数点后第一位>5
  8. 正数：Math.round(11.68)=12
  9. 负数：Math.round(-11.68)=-12


根据上面例子的运行结果，我们还可以按照如下方式总结，或许更加容易记忆：

  1. 参数的小数点后第一位<5，运算结果为参数整数部分。
  2. 参数的小数点后第一位>5，运算结果为参数整数部分绝对值+1，符号（即正负）不变。
  3. 参数的小数点后第一位=5，正数运算结果为整数部分+1，负数运算结果为整数部分。


但是上面的结论仍然不是很好记忆。我们来看看round()方法的内部实现会给我们带来什么启发？我们来看这两个方法内部的代码：

Java代码 复制代码
  1. public static int round(float a) {   
  2.     return (int)floor(a + 0.5f);   
  3. }   
  4.   
  5. public static long round(double a) {   
  6.     return (long)floor(a + 0.5d);   
  7. }  
public static int round(float a) {
	return (int)floor(a + 0.5f);
}

public static long round(double a) {
	return (long)floor(a + 0.5d);
}


看来它们都是将参数值+0.5后交与floor()进行运算，然后取返回值。那么floor()方法的作用又是什么呢？它是取一个小于等于参数值的最大整数。比如经过floor()方法运算后，如果参数是10.2则返回10，13返回13，-20.82返回-21，-16返回-16等等。既然是这样，我们就可以用一句话来概括round()方法的运算效果了：

  • Math类的round()方法的运算结果是一个<=(参数值+0.5)的最大整数。


switch语句

哪些类型可以用于switch语句的判断呢？我们做个测试就知道了：

Java代码 复制代码
  1. public class MathTest {   
  2.     // 枚举类型，Java5.0以上版本可用   
  3.     static enum enum_e {   
  4.         A, B   
  5.     }   
  6.   
  7.     public static void main(String[] args) {   
  8.         // byte   
  9.         byte byte_n = 0;   
  10.         switch (byte_n) {   
  11.         case 0:   
  12.             System.out.println("byte可以用于switch语句");   
  13.             break;   
  14.         }   
  15.   
  16.         // Byte类   
  17.         Byte byte_m = 0;   
  18.         // 需要Java5.0（1.5）以上版本支持   
  19.         switch (byte_m) {   
  20.         case 0:   
  21.             System.out.println("Byte类可以用于switch语句");   
  22.             System.out.println();   
  23.             break;   
  24.         }   
  25.   
  26.         // char   
  27.         char char_n = 0;   
  28.         switch (char_n) {   
  29.         case 0:   
  30.             System.out.println("char可以用于switch语句");   
  31.             break;   
  32.         }   
  33.   
  34.         // Character类   
  35.         Character char_m = 0;   
  36.         // 需要Java5.0（1.5）以上版本支持   
  37.         switch (char_m) {   
  38.         case 0:   
  39.             System.out.println("Character类可以用于switch语句");   
  40.             System.out.println();   
  41.             break;   
  42.         }   
  43.   
  44.         // short   
  45.         short short_n = 0;   
  46.         switch (short_n) {   
  47.         case 0:   
  48.             System.out.println("short可以用于switch语句");   
  49.             break;   
  50.         }   
  51.   
  52.         // Short   
  53.         Short short_m = 0;   
  54.         // 需要Java5.0（1.5）以上版本支持   
  55.         switch (short_m) {   
  56.         case 0:   
  57.             System.out.println("Short类可以用于switch语句");   
  58.             System.out.println();   
  59.             break;   
  60.         }   
  61.   
  62.         // int   
  63.         int int_n = 0;   
  64.         switch (int_n) {   
  65.         case 0:   
  66.             System.out.println("int可以用于switch语句");   
  67.             break;   
  68.         }   
  69.   
  70.         // Integer类   
  71.         Integer int_m = 0;   
  72.         // 需要Java5.0（1.5）以上版本支持   
  73.         switch (int_m) {   
  74.         case 0:   
  75.             System.out.println("Integer类可以用于switch语句");   
  76.             System.out.println();   
  77.             break;   
  78.         }   
  79.   
  80.         // long   
  81.         long long_n = 0;   
  82.         // 编译错误，long型不能用于switch语句   
  83.         // switch (long_n) {   
  84.         // case 0:   
  85.         // System.out.println("long可以用于switch语句");   
  86.         // break;   
  87.         // }   
  88.   
  89.         // Long类   
  90.         Long long_m = 0L;   
  91.         // 编译错误，Long类型不能用于switch语句   
  92.         // switch (long_m) {   
  93.         // case 0:   
  94.         // System.out.println("Long类可以用于switch语句");   
  95.         // System.out.println();   
  96.         // break;   
  97.         // }   
  98.   
  99.         // float   
  100.         float float_n = 0.0F;   
  101.         // 编译错误，float型不能用于switch语句   
  102.         // switch (float_n) {   
  103.         // case 0.0F:   
  104.         // System.out.println("float可以用于switch语句");   
  105.         // break;   
  106.         // }   
  107.   
  108.         // Float类   
  109.         Float float_m = 0.0F;   
  110.         // 编译错误，Float类型不能用于switch语句   
  111.         // switch (float_m) {   
  112.         // case 0.0F:   
  113.         // System.out.println("Float类可以用于switch语句");   
  114.         // System.out.println();   
  115.         // break;   
  116.         // }   
  117.   
  118.         // double   
  119.         double double_n = 0.0;   
  120.         // 编译错误，double型不能用于switch语句   
  121.         // switch (double_n) {   
  122.         // case 0.0:   
  123.         // System.out.println("double可以用于switch语句");   
  124.         // break;   
  125.         // }   
  126.   
  127.         // Double类   
  128.         Double double_m = 0.0;   
  129.         // 编译错误，Double类型不能用于switch语句   
  130.         // switch (double_m) {   
  131.         // case 0.0:   
  132.         // System.out.println("Double类可以用于switch语句");   
  133.         // System.out.println();   
  134.         // break;   
  135.         // }   
  136.   
  137.         // boolean   
  138.         boolean bool_b = true;   
  139.         // 编译错误，boolean型不能用于switch语句   
  140.         // switch (bool_b) {   
  141.         // case true:   
  142.         // System.out.println("boolean可以用于switch语句");   
  143.         // break;   
  144.         // }   
  145.   
  146.         // Boolean类   
  147.         Boolean bool_l = true;   
  148.         // 编译错误，Boolean类型不能用于switch语句   
  149.         // switch (bool_l) {   
  150.         // case true:   
  151.         // System.out.println("Boolean类可以用于switch语句");   
  152.         // System.out.println();   
  153.         // break;   
  154.         // }   
  155.   
  156.         // String对象   
  157.         String string_s = "Z";   
  158.         // 编译错误，long型不能用于switch语句   
  159.         // switch (string_s) {   
  160.         // case "Z":   
  161.         // System.out.println("String可以用于switch语句");   
  162.         // System.out.println();   
  163.         // break;   
  164.         // }   
  165.   
  166.         // enum（枚举类型，Java5.0以上版本可用）   
  167.         switch (MathTest.enum_e.A) {   
  168.         case A:   
  169.             System.out.println("enum可以用于switch语句-A");   
  170.             break;   
  171.         case B:   
  172.             System.out.println("enum可以用于switch语句-B");   
  173.             break;   
  174.         }   
  175.     }   
  176. }  
public class MathTest {
	// 枚举类型，Java5.0以上版本可用
	static enum enum_e {
		A, B
	}

	public static void main(String[] args) {
		// byte
		byte byte_n = 0;
		switch (byte_n) {
		case 0:
			System.out.println("byte可以用于switch语句");
			break;
		}

		// Byte类
		Byte byte_m = 0;
		// 需要Java5.0（1.5）以上版本支持
		switch (byte_m) {
		case 0:
			System.out.println("Byte类可以用于switch语句");
			System.out.println();
			break;
		}

		// char
		char char_n = 0;
		switch (char_n) {
		case 0:
			System.out.println("char可以用于switch语句");
			break;
		}

		// Character类
		Character char_m = 0;
		// 需要Java5.0（1.5）以上版本支持
		switch (char_m) {
		case 0:
			System.out.println("Character类可以用于switch语句");
			System.out.println();
			break;
		}

		// short
		short short_n = 0;
		switch (short_n) {
		case 0:
			System.out.println("short可以用于switch语句");
			break;
		}

		// Short
		Short short_m = 0;
		// 需要Java5.0（1.5）以上版本支持
		switch (short_m) {
		case 0:
			System.out.println("Short类可以用于switch语句");
			System.out.println();
			break;
		}

		// int
		int int_n = 0;
		switch (int_n) {
		case 0:
			System.out.println("int可以用于switch语句");
			break;
		}

		// Integer类
		Integer int_m = 0;
		// 需要Java5.0（1.5）以上版本支持
		switch (int_m) {
		case 0:
			System.out.println("Integer类可以用于switch语句");
			System.out.println();
			break;
		}

		// long
		long long_n = 0;
		// 编译错误，long型不能用于switch语句
		// switch (long_n) {
		// case 0:
		// System.out.println("long可以用于switch语句");
		// break;
		// }

		// Long类
		Long long_m = 0L;
		// 编译错误，Long类型不能用于switch语句
		// switch (long_m) {
		// case 0:
		// System.out.println("Long类可以用于switch语句");
		// System.out.println();
		// break;
		// }

		// float
		float float_n = 0.0F;
		// 编译错误，float型不能用于switch语句
		// switch (float_n) {
		// case 0.0F:
		// System.out.println("float可以用于switch语句");
		// break;
		// }

		// Float类
		Float float_m = 0.0F;
		// 编译错误，Float类型不能用于switch语句
		// switch (float_m) {
		// case 0.0F:
		// System.out.println("Float类可以用于switch语句");
		// System.out.println();
		// break;
		// }

		// double
		double double_n = 0.0;
		// 编译错误，double型不能用于switch语句
		// switch (double_n) {
		// case 0.0:
		// System.out.println("double可以用于switch语句");
		// break;
		// }

		// Double类
		Double double_m = 0.0;
		// 编译错误，Double类型不能用于switch语句
		// switch (double_m) {
		// case 0.0:
		// System.out.println("Double类可以用于switch语句");
		// System.out.println();
		// break;
		// }

		// boolean
		boolean bool_b = true;
		// 编译错误，boolean型不能用于switch语句
		// switch (bool_b) {
		// case true:
		// System.out.println("boolean可以用于switch语句");
		// break;
		// }

		// Boolean类
		Boolean bool_l = true;
		// 编译错误，Boolean类型不能用于switch语句
		// switch (bool_l) {
		// case true:
		// System.out.println("Boolean类可以用于switch语句");
		// System.out.println();
		// break;
		// }

		// String对象
		String string_s = "Z";
		// 编译错误，long型不能用于switch语句
		// switch (string_s) {
		// case "Z":
		// System.out.println("String可以用于switch语句");
		// System.out.println();
		// break;
		// }

		// enum（枚举类型，Java5.0以上版本可用）
		switch (MathTest.enum_e.A) {
		case A:
			System.out.println("enum可以用于switch语句-A");
			break;
		case B:
			System.out.println("enum可以用于switch语句-B");
			break;
		}
	}
}


运行结果如下：

  1. byte可以用于switch语句
  2. Byte类可以用于switch语句
  3. char可以用于switch语句
  4. Character类可以用于switch语句
  5. short可以用于switch语句
  6. Short类可以用于switch语句
  7. int可以用于switch语句
  8. Integer类可以用于switch语句
  9. enum可以用于switch语句-A


结果已经出来了，我们来总结一下：

  1. byte、char、short、int四种基本类型以及它们的包装类（需要Java5.0/1.5以上版本支持）都可以用于switch语句。
  2. long、float、double、boolean四种基本类型以及它们的包装类（在Java所有版本中）都不能用于switch语句。
  3. enum类型，即枚举类型可以用于switch语句，但是要在Java5.0（1.5）版本以上才支持。
  4. 所有类型的对象（包括String类，但在Java5.0/1.5以上版本中，该项要排除byte、char、short、int四种基本类型对应的包装类）都不能用于switch语句。
yuson_yan
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA面试题解惑系列.docx
10-27
JAVA面试题解惑系列
C++:内置类型
it_cplusplus
06-23 1388
C++:内置类型简介Void 类型std：： nullptr_t布尔类型字符类型浮点类型整数类型同义词内置类型的大小 简介 内置类型 (也称为 基础类型) 由 c + + 语言标准指定，并内置于编译器。 未在任何标头文件中定义内置类型。 内置类型分为三个主要类别： 整数、 浮点 和 void。 整数类型表示整数。 浮点类型可以指定可能包含小数部分的值。 编译器将大多数内置类型视为不同类型。 但是，某些类型是 同义词，或由编译器视为等效类型。 Void 类型 void类型描述了一组空值。 不能指定类型的变量
八大基本类型
weixin_30826761的博客
02-25 1827
一：基本类型 数值类型：byte（8位）、short（16位）、int（32位）、long（64位）取值范围为-2的n-2次方~2的n-2次方-1（n为位数，去掉一个符号位） 浮点类型：float（32位，单精度）、double（64位，双精度） JAVA中将小数默认为double类型，若要定义float需在数据后面用f声明 字符类型：char（16位，unicode字符） 布尔...
JS之内置类型
qq_35270769的博客
05-15 349
JS之内置类型 内置类型 JS中分为七种内置类型，其中内置类型又分为两大类型：基本数据类型和对象。 基本数据类型有六种：string、number、boolean、undefined、null、symbol。 特殊一点的情况： ①NaN属于number类型，并且NaN不等于自身； console.log(typeof NaN); //输出number类型 document.write(NaN==NaN) //输出false ...
Java基本数据类型有哪些？
敢于挑战我可以的博客
06-26 2304
Java的基本数据类型有八种，具体如下： 1. 四种整数类型：byte、short、int、long 2. 两种浮点数类型：float、double 3. 一种字符类型：char 4. 一种布尔类型：boolean
【JavaScript】基本类型、基本包装类型、引用类型、内置对象
Dorcas_FE的博客
06-26 220
基本类型 字符串（String） 数字(Number) 布尔(Boolean) 对空（Null） 未定义（Undefined） Symbol 引用类型 对象(Object) 数组(Array) 函数(Function) 基本包装类型 var str = "hk" console.log(str.charAt(0)) //"h" 这里的str是基本类型， 那这个str为何会调用方法呢？ 这...
Java面试题解惑系列的练习.zip
01-01
【一线互联网大厂Java核心面试题库】Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等..
JAVA面试题解惑系列114页.pdf
04-25
（一）类的初始化顺序 （二）到底创建了几个String 对象？ （三）变量（属性）的覆盖 ...（八）聊聊基本类型（内置类型） （九）继承、多态、重载和重写 （十）话说多线程 （十一）这些运算符你是否还记得？
JAVA面试题解惑系列合集
01-05
JAVA面试题解惑系列合集 JAVA面试题解惑系列合集 JAVA面试题解惑系列合集
Java面试题系列——Spring 示例代码.zip
01-02
【一线互联网大厂Java核心面试题库】Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等..
JAVA面试题解惑系列
02-23
JAVA面试题解惑系列
JAVA面试题解惑系列.pdf
最新发布
03-19
java 面试题解惑系列，java面试中经常出错的题目总结和解惑
JAVA面试题解惑系列.zip
07-15
JAVA面试题解惑系列之最全面试题
JAVA面试题解惑系列——类的初始化顺序
11-03
JAVA面试题解惑系列(一)——类的初始化顺序-JAVA程序员JAVA工程师面试必看
JAVA面试题解惑系列合集.docx
01-04
java 面试 进阶
js的基本数据类型 引用类型 以及常见的内置对象
冰魂魄的博客
06-05 814
1：数据类型一般分为六种：number，string，boolean，undefined，null，object     number，数值数据类型，例如10或者1或者5.5 string，字符串数据类型，例如”helloworld”    boolean，布尔类型true|falseundefined，未定义的数据，一般var声明了一个变量，但未给变量进行初始化值，那么这个变量的...
前端面试知识点总结JavaScript基础之变量和类型（一）
m0_54630400的博客
07-13 442
前端面试知识点总结JavaScript基础之变量和类型（一）
java的基本数据类型有八种：
weixin_30645617的博客
08-24 1522
1）四种整数类型(byte、short、int、long)： byte：8 位，用于表示最小数据单位，如文件中数据，-128~127 short：16 位，很少用，-32768 ~ 32767 int：32 位、最常用，-2^31-1~2^31 （21 亿） long：64 位、次常用 注意事项： int i=5; // 5 叫直接量（或字面量），即 直接写出...
基本类型的4类8种
怡世的盒子
05-23 1643
四类八种字节数数据表示范围整型byte1-128～127short2-32768～32767int4-2147483648～2147483648long8-263～263-1浮点型float4-3.403E38～3.403E38double8-1.798E308～1.798E308字符型char2表示一个字符，如('a'，'A'，'0'，'家')布尔型boolean1只有两个值true与false...
Java数据类型的面试题
10-20
以下是一些可能被问到的Java数据类型的面试题及其答案： 1. Java中有哪些基本数据类型及其对应的包装类型？ Java中有8种基本数据类型，分别是byte、short、int、long、float、double、char和boolean。每种基本数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值