Java面试准备之Java基础(应用篇)

hresh 554 0

Java面试准备之Java基础(应用篇)

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

执行结果为:

Java面试准备之Java基础(应用篇)

首先我们分析解答案例一代码的输出:

根据官方文档可以得出有如下三种情况:

  • 如果表达式的值和其中一个 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 开发手册中是这样定义的:

Java面试准备之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 代表的是对象和它的成员的从属关系。同一种类的对象,通过它们的属性的不同值来区别。

发表评论 取消回复
表情 图片 链接 代码

分享