java基础应用_Java基础(应用篇)

1、Math.round(11.5) 等于多少？Math.round(-11.5)等于多少？2、String str="i"与 String str=new String("i")一样吗？3、用最有效率的方法计算2乘以8？4、数组有没有length()方法？String有没有length()方法？5、在Java中，如何跳出当前的多重嵌套循环？6、两个对象值相同(x.equals(y) == true)，但却可有不同的 hash code，这句话对不对？7、两个对象的 hashCode()相同，则 equals()也一定为 true，对吗？8、float f=3.4;是否正确？9、short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？10、switch是否能作用在byte上，是否能作用在long上，是否能作用在String上？11、正确使用 equals 方法12、关于浮点数运算丢失精度问题(BigDecimal)

1、Math.round(11.5) 等于多少？Math.round(-11.5)等于多少？

Math.round(11.5)的返回值是 12，Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加 0.5 然后进行下取整。

2、String str="i"与 String str=new String("i")一样吗？

不一样，运行时涉及到的对象数目不同，前者涉及到一个对象，即字面量“i”在堆中创建的对象，并将其引用驻留在字符串常量池中；后者涉及到两个对象，多了一个通过 new String("i")在堆中创建并初始化的、内容与"i"相同的对象。

3、用最有效率的方法计算2乘以8？

2 << 3(左移3位相当于乘以2的3次方，右移3位相当于除以2的3次方)。

4、数组有没有length()方法？String有没有length()方法？

数组没有 length()方法，有 length 的属性。

String 有 length()方法。在 JavaScript 中，获得字符串的长度是通过 length 属性得到的，这一点容易和 Java 混淆。

5、在Java中，如何跳出当前的多重嵌套循环？

在最外层循环前加一个标记如 A，然后用 break A;可以跳出多重循环。(Java 中支持带标签的 break 和 continue 语句，作用有点类似于 C 和 C++中的 goto 语句，但是就像要避免使用 goto 一样，应该避免使用带标签的 break 和 continue，因为它不会让你的程序变得更优雅，很多时候甚至有相反的作用)

6、两个对象值相同(x.equals(y) == true)，但却可有不同的 hash code，这句话对不对？

不对，如果两个对象x和y满足x.equals(y) == true，它们的哈希码(hash code)应当相同。

(1)如果两个对象相同(equals方法返回true)，那么它们的hashCode值一定要相同；

(2) 如果两个对象的 hashCode 相同，它们并不一定相同。

7、两个对象的 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()相等即两个键值对的哈希值相等，然而哈希值相等，并不一定能得出键值对相等。

8、float f=3.4;是否正确？

不正确。3.4 是双精度数，将双精度型(double)赋值给浮点型(float)属于下转型(down-casting，也称为窄化)会造成精度损失，因此需要强制类型转换 float f =(float)3.4; 或者写成float f =3.4F;。

9、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);其中有隐含的强制类型转换。

10、switch是否能作用在byte上，是否能作用在long上，是否能作用在String上？

在 Java 5以前，switch(expr)中，expr 只能是 byte、short、char、int；从 Java 5 开始，Java 中引入了枚举类型，expr 也可以是 enum 类型；从 Java 7 开始，expr 还可以是字符串(String)，但是长整型(long)在目前所有的版本中都是不可以的。

11、正确使用 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方法造成空指针异常的原因及解决方案

12、关于浮点数运算丢失精度问题(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。下方是针对浮点型数据构建的加减乘除和四舍五入的工具类。

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();
   }
}

通过将浮点型数据转换为 BigDecimal 再进行计算，可以保证数据的准确性。

总结：

BigDecimal 主要用来操作(大)浮点数，BigInteger 主要用来操作大整数(超过 long 类型)。

BigDecimal 的实现利用到了 BigInteger, 所不同的是 BigDecimal 加入了小数位的概念

推荐阅读：

Java中float/double取值范围与精度

java中浮点数的比较(double, float)(转)