Math.round(11.5) 等于多少？Math.round(-11.5)等于多少？
Math.round(11.5)的返回值是 12，Math.round(-11.5)的返回值是-11。
Math.round 方法返回的是一个最接近参数的 long 值（例如：Math.round(11.6) = 12；Math.round(-11.6) = -12；Math.round(-0.1) = 0；Math.round(0.1) = 0） 。
如果出现向上向下距离一样的数值，比如题目中的11.5 ，取较大的值。比如：
- Math.round(11.5) ，首先与 11.5最接近的有两个整数 11 和 12，取较大的那结果就是12；
- Math.round(-11.5)，首先与 -11.5最接近的有两个整数 -11 和 -12，取较大的那结果就是-11；
- Math.round(0.5)，首先与 0.5最接近的有两个整数 0 和 1，取较大的那结果就是1；
- Math.round(-0.5)，首先与 -0.5最接近的有两个整数 -1 和 0，取较大的那结果就是0；
1.如果参数为 NaN（无穷与非数值），那么结果为 0。
2.如果参数为负无穷大或任何小于等于 Long.MIN_VALUE 的值，那么结果等于Long.MIN_VALUE 的值。
3.如果参数为正无穷大或任何大于等于 Long.MAX_VALUE 的值，那么结果等于Long.MAX_VALUE 的值。
Math.ceil和Math.floor的使用
Math.ceil(-0.5)等于 -0.0，Math.floor(-0.5)等于-1.0。
ceil：天花板数，向上取整；floor：地板数，向下取整。取整结果符号不变，类型不变。
String str="i"与 String str=new String("i")一样吗？
不一样，运行时涉及到的对象数目不同，前者涉及到一个对象，即字面量“i”在堆中创建的对象，并将其引用驻留在字符串常量池中；后者涉及到两个对象，多了一个通过 new String("i")在堆中创建并初始化的、内容与"i"相同的对象。
关于 String 类的相关知识，推荐阅读Java 基础：String 类源码分析 和 Java 基础：String——常量池与 intern
Java中的String有没有长度限制？
在 String 源码分析中，关于其构造方法的实现比较多，其中有几个是支持用户传入 length 来执行长度的：
public String(byte bytes[], int offset, int length)
可以看到，这里面的参数 length 是使用 int 类型定义的，那么也就是说，String 定义的时候，最大支持的长度就是 int 的最大范围值。
根据 Integer 类的定义，java.lang.Integer#MAX_VALUE的最大值是2^31 – 1;
那么，我们是不是就可以认为 String 能支持的最大长度就是这个值了呢？
其实并不是，这个值只是在运行期，我们构造 String 的时候可以支持的一个最大长度，而实际上，在运行期，定义字符串的时候也是有长度限制的。
如以下代码：
String s = "11111...1111";//其中有10万个字符"1"
当我们使用如上形式定义一个字符串的时候，当我们执行 javac 编译时，是会抛出异常的，提示如下：
错误: 常量字符串过长
那么，明明 String 的构造函数指定的长度是可以支持2147483647(2^31 – 1)的，为什么像以上形式定义的时候无法编译呢？
常量池限制
原因在于： 形如String s = "xxx";定义String的时候，xxx被我们称之为字面量，这种字面量在编译之后会以常量的形式进入到 Class 文件常量池。 要进入常量池，就要遵守常量池的约束条件。
Class 文件常量池的格式规定：其字符串常量的长度不能超过65535( 2^16 – 1 )， 当参数类型为 String，并且长度大于等于 65535 的时候，就会导致编译失败。
运行期限制
首先我们查看以下代码：
String s = "";
for (int i = 0; i <100000 ; i++) {
s+="i";
}
在运行期，长度不能超过 Int 的范围，否则会抛异常。
推荐阅读：String长度限制
用最有效率的方法计算2乘以8？
2 << 3（左移3位相当于乘以2的3次方，右移3位相当于除以2的3次方）。
数组有没有length()方法？String有没有length()方法？
数组没有 length()方法，有 length 的属性。
String 有 length()方法。在 JavaScript 中，获得字符串的长度是通过 length 属性得到的，这一点容易和 Java 混淆。
在Java中，如何跳出当前的多重嵌套循环？
在最外层循环前加一个标记如 A，然后用 break A；可以跳出多重循环。（Java 中支持带标签的 break 和 continue 语句，作用有点类似于 C 和 C++中的 goto 语句，但是就像要避免使用 goto 一样，应该避免使用带标签的 break 和 continue，因为它不会让你的程序变得更优雅，很多时候甚至有相反的作用）
两个对象值相同(x.equals(y) = = true)，但却可有不同的 hash code，这句话对不对？
不对，如果两个对象x和y满足 x.equals(y) = = true，它们的哈希码（hash code）应当相同。
(1)如果两个对象相同（equals方法返回true），那么它们的 hashCode 值一定要相同；
(2) 如果两个对象的 hashCode 相同，它们并不一定相同。
两个对象的 hashCode()相同，则 equals()也一定为 true，对吗？
不对，两个对象的 hashCode()相同，equals()不一定 true。
String str1 = "通话";
String str2 = "重地";
System.out.println(String.format("str1：%d | str2：%d",
str1.hashCode(),str2.hashCode()));
System.out.println(str1.equals(str2));
//结果
str1：1179395 | str2：1179395
false
代码解读：很显然“通话”和“重地”的 hashCode() 相同，然而 equals() 则为 false，因为在散列表中，hashCode()相等即两个键值对的哈希值相等，然而哈希值相等，并不一定能得出键值对相等。
float f=3.4;是否正确？
不正确。3.4 是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换 float f =(float)3.4; 或者写成 float f =3.4F;。
short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？
对于 short s1 = 1; s1 = s1 + 1;由于 1 是 int 类型，因此 s1+1 运算结果也是 int 型，需要强制转换类型才能赋值给 short 型。而 short s1 = 1; s1 += 1;可以正确编译，因为 s1+= 1;相当于 s1 = (short)(s1 + 1);其中有隐含的强制类型转换。
byte b1 = 1, b2 = 2, b3, b4;
final byte b5 = 5, b6 = 6;
b4=b5+b6; //常量在编译阶段直接赋值，注意byte的取值范围，不要大于127
b3=b1+b2; //编译报错
判断语句的案例
boolean f1 = false;
if(f1 = true){
System.out.println("true"); //输出true
}else {
System.out.println("false");
}
int a = -1;
if(a = 1){ //编译报错，注意与js代码的区别，数字
System.out.println(a);
}else{
System.out.println(a);
}
switch是否能作用在byte上，是否能作用在long上，是否能作用在String上？
在 Java 5以前，switch(expr)中，expr 只能是 byte、short、char、int；从 Java 5 开始，Java 中引入了枚举类型，expr 也可以是 enum 类型；从 Java 7 开始，expr 还可以是字符串（String），但是长整型（long）在目前所有的版本中都是不可以的。
switch语句中未使用break会出现什么情况？
public class SwitchTest {
public static void main(String[] args) {
// 案例一
//当default在中间时,且看输出是什么？
int a = 1;
switch (a) {
case 2:
System.out.println("print 2");
case 1:
System.out.println("print 1");
default:
System.out.println("first default print");
case 3:
System.out.println("print 3");
}
// 案例二
//当switch括号内的变量为String类型的外部参数时,且看输出是什么？
String param = null;
switch (param) {
case "param":
System.out.println("print param");
break;
case "String":
System.out.println("print String");
break;
case "null":
System.out.println("print null");
break;
default:
System.out.println("second default print");
}
}
}
执行结果为：
首先我们分析解答案例一代码的输出：
根据官方文档可以得出有如下三种情况：
- 如果表达式的值和其中一个 case 语句中的常量相等了，那么我们就说 case 语句匹配上了。switch 代码块中匹配的 case 语句之后的所有语句 （如果有）就按照顺序执行。如果所有语句都正常完成，或者在匹配的 case 语句之后没有语句，那么整个 switch 代码块就将正常完成。
- 如果没有和表达式匹配的 case 语句，但是有一个 default 语句，那么 switch 代码块中 default 语句后面的所有语句（如果有）将按顺序执行。如果所有语句都正常完成，或者如果 default 标签之后没有语句了，则整个 switch 代码块就将正常完成。
- 如果既没有 case 语句和表达式的值匹配上，也没有 default 语句，那就没有什么搞的了，switch 语句执行了个寂寞，也算是正常完成。
情况一和案例代码一表述的正是一件事，如果我们对案例一进行修改，把 a 的值改为0，输出结果如下图所示：
first default print
print 3
该结果正好对应情况二。
在 a=0 的基础上去除 default 语句，执行案例一代码，输出结果为空，对应情况三。
在上述案例中，我们没有使用到 break 或者 return 字段，在阿里 Java 开发手册中是这样定义的：
关于案例二代码报错，原因如下：switch 后面的括号叫做表达式，如果这个表达式的计算结果是 null，那么就抛出空指针异常。这个 switch 语句也就算完事了。
另外，如果这个表达式的结果是一个引用类型（比如说是一个方法），那么还需要进行一个拆箱的处理。
推荐阅读：https://www.cnblogs.com/thisiswhy/p/13662049.html
枚举类型的使用
枚举类有多少个实例，就会调用多少次构造方法，枚举类构造方法只能加 private 修饰符（或不加），因为枚举类本身已经是构造好的，不允许再被外部构造。
查看如下一个案例：
public class Test2{
public static void main(String[] args) {
System.out.println(User.one);
}
}
enum User{
one,two,three;
private User(){
System.out.println("执行构造方法");
}
}
执行结果为：
执行构造方法
执行构造方法
执行构造方法
one
关于枚举的更多内容推荐阅读：Java 枚举(enum) 详解7种常见的用法
正确使用 equals 方法
Object 的 equals 方法容易抛空指针异常，应使用常量或确定有值的对象来调用 equals。
举个例子：
// 不能使用一个值为null的引用类型变量来调用非静态方法，否则会抛出异常
String str = null;
if (str.equals("hresh")) {
...
} else {
..
}
运行上面的程序会抛出空指针异常，但是我们把第二行的条件判断语句改为下面这样的话，就不会抛出空指针异常，else 语句块得到执行。：
"hresh".equals(str);// false
推荐使用 java.util.Objects#equals(JDK7 引入的工具类)。
Objects.equals(null,"hresh");// false
该方法源码如下：
public static boolean equals(Object a, Object b) {
// 可以避免空指针异常。如果a==null的话此时a.equals(b)就不会得到执行，避免出现空指针异常。
return (a == b) || (a != null && a.equals(b));
}
注意：
- 每种原始类型都有默认值一样，如 int 默认值为 0，boolean 的默认值为 false，null 是任何引用类型的默认值，不严格的说是所有 Object 类型的默认值。
- 可以使用 = = 或者 != 操作来比较 null 值，但是不能使用其他算法或者逻辑操作。在 Java 中 null = = null 将返回 true。
- 不能使用一个值为 null 的引用类型变量来调用非静态方法，否则会抛出异常
推荐阅读：Java中equals方法造成空指针异常的原因及解决方案
关于浮点数运算丢失精度问题(BigDecimal)
问题案例：
float a = 1.0f - 0.9f;
float b = 0.9f - 0.8f;
System.out.println(a);// 0.100000024
System.out.println(b);// 0.099999964
System.out.println(a == b);// false
public static void main(String args[]){
System.out.println(0.05+0.01);
System.out.println(1.0-0.42);
System.out.println(4.015*100);
System.out.println("BigDecimal:"+new BigDecimal(Double.toString(4.015)).multiply(new BigDecimal(Double.toString(100))));
System.out.println(123.3/100);
}
//输出结果
0.060000000000000005
0.5800000000000001
401.49999999999994
BigDecimal:401.5000
1.2329999999999999
使用 BigDecimal 来定义浮点数的值，再进行浮点数的运算操作。在 BigDecimal 类中有很多个构造方法，关于浮点型数据作为参数的构造方法只有两个：
public BigDecimal(double var1)//默认舍入模式为MathContext.UNLIMITED具有无限精度算法
public BigDecimal(double var1, MathContext var3)//自定义舍入模式
在实际应用中会发现，public BigDecimal(double val) 损失了double 参数的精度，如下例所示：
double d = 301353.05;
BigDecimal decimal = new BigDecimal(d);
System.out.println(decimal);
//输出结果为：301353.0499999999883584678173065185546875
为避免该情况的出现，最简单有效的方法是使用 BigDecimal 的以 String 为参数的构造函数：public BigDecimal(String val) 来替代。
还有关于四舍五入的情况，也会出现问题。
double a1 = 4.015;
double a2 = Math.round(a1*100)/100.0;
System.out.println(a2);//4.01
DecimalFormat df = new DecimalFormat("0.00");
System.out.println(Double.valueOf(df.format(a1)));//4.01
在商业计算中，对数据要求特别严格的情况下，比如有关金钱数据，最好使用 BigDecimal。下方是针对浮点型数据构建的加减乘除和四舍五入的工具类。
/**
* @author hresh
* @description https://juejin.im/user/2664871918047063
*/
public class Arith{
//默认除法运算精度
private static final int DEF_DIV_SCALE = 10;
//这个类不能实例化
private Arith(){
}
/**
* 提供精确的加法运算。
* @param v1 被加数
* @param v2 加数
* @return 两个参数的和
*/
public static double add(double v1,double v2){
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue();
}
/**
* 提供精确的减法运算。
* @param v1 被减数
* @param v2 减数
* @return 两个参数的差
*/
public static double sub(double v1,double v2){
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
}
/**
* 提供精确的乘法运算。
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/
public static double mul(double v1,double v2){
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
* 小数点以后10位，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @return 两个参数的商
*/
public static double div(double v1,double v2){
return div(v1,v2,DEF_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @param scale 表示表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static double div(double v1,double v2,int scale){
if(scale<0){
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
/**
* 提供精确的小数位四舍五入处理。
* @param v 需要四舍五入的数字
* @param scale 小数点后保留几位
* @return 四舍五入后的结果
*/
public static double round(double v,int scale){
if(scale<0){
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(Double.toString(v));
BigDecimal one = new BigDecimal("1");
return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
}
}
通过将 double 型数据转换为 BigDecimal 再进行计算，可以保证数据的准确性。
总结：
BigDecimal 主要用来操作（大）浮点数，BigInteger 主要用来操作大整数（超过 long 类型）。
BigDecimal 的实现利用到了 BigInteger, 所不同的是 BigDecimal 加入了小数位的概念
推荐阅读：
is-a 和 has-a 的区别
is a 代表的是类之间的继承关系
has a 代表的是对象和它的成员的从属关系。同一种类的对象，通过它们的属性的不同值来区别。
本文作者为hresh，转载请注明。