阅读 1756

Java基础知识常见面试题汇总 第一篇

1. 前言

参加过社招的同学都了解,进入一家公司面试开发岗位时,填写完个人信息后,一般都会让先做一份笔试题,然后公司会根据笔试题的回答结果,确定要不要继续此次面试,如果答的不好,有些公司可能会直接说“技术经理或者总监在忙,你先回去等通知吧”,有些公司可能会继续面试,了解下你的项目经验等情况。

至少在工作的前5年甚至更久,面试一般不会跳过笔试题这个环节(大牛,个别公司除外),我自己也记不清自己面试过多少家公司,做过多少份面试题了,导致现在有时逛街,总感觉很多地方似曾相识,感觉自己多年前曾经来面过试,一度自嘲,一度也怀疑,自己当年是靠什么在上海坚持下来的,所以说面试题对于求职来说,还是非常重要的。

网上搜索“Java面试题”几个关键字也是有很多很多的文章讲解,为什么我还要自己总结呢?主要有以下几个原因:

  • 文章太多,反倒不知道该看哪个(就如一本书中所说太多的资讯等于没有资讯)
  • 文章的准确性不高(曾多次发现描述不正确或代码跑不起来的情况)
  • 可以加深自己的理解和记忆
  • 一劳永逸,下次不用再从网上慢慢筛选,看自己整理的就好了

本篇主要整理下Java基础知识的面试题,主要包含以下几点:

  1. Integer和int的区别
  2. ==和equals的区别
  3. String,StringBuilder,StringBuffer的区别
  4. 装箱和拆箱
  5. Java中的值传递和引用传递

接下来一一讲解。

2. Integer和int的区别

2.1 基本概念区分

  1. Integer是int的包装类(引用类型),int是Java的一种基本数据类型(值类型)。
  2. Integer变量必须实例化后才能使用,而int变量不需要。
  3. Integer实际是对象的引用,当new一个Integer时,实际上是生成一个指针指向此对象,而int则是直接存储数据值。
  4. Integer的默认值是null,int的默认值是0。

2.2 Integer与int常见的几种比较场景

1)两个new Integer()变量相比较,永远返回false

Integer i = new Integer(100);
Integer j = new Integer(100);
System.out.println(i == j); // false
复制代码

两个通过new生成的Integer变量生成的是两个对象,其内存地址不同

2)非new生成的Integer变量和new Integer()生成的变量相比较,永远返回false

Integer i = new Integer(100);
Integer j = 100;
System.out.println(i == j); // false
复制代码

非new生成的Integer变量指向的是Java常量池中的对象,而new Integer()生成的变量指向堆中新建的对象,两者在内存中的地址不同

3)两个非new生成的Integer变量比较,如果两个变量的值在区间-128到127 之间,则比较结果为true,如果两个变量的值不在此区间,则比较结果为 false。

Integer i = 100;
Integer j = 100;
System.out.println(i == j); //true

Integer i1 = 128;
Integer j1 = 128;
System.out.println(i1 == j1); //false
复制代码

为什么会这样呢,我们来分析下原因:

Integer i = 100; 在编译时,会翻译成 Integer i = Integer.valueOf(100); ,而Java中Integer类的valueOf方法的源码如下:

public static Integer valueOf(int i) {
     if (i >= IntegerCache.low && i <= IntegerCache.high)
         return IntegerCache.cache[i + (-IntegerCache.low)];
     return new Integer(i);
}

private static class IntegerCache {
     static final int low = -128;
     static final int high;
     static final Integer cache[];

     static {
          // high value may be configured by property
          int h = 127;
          String integerCacheHighPropValue =
              sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
          if (integerCacheHighPropValue != null) {
              try {
                  int i = parseInt(integerCacheHighPropValue);
                  i = Math.max(i, 127);
                  // Maximum array size is Integer.MAX_VALUE
                  h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
              } catch( NumberFormatException nfe) {
                  // If the property cannot be parsed into an int, ignore it.
              }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}
复制代码

从源码可以看出:

Java中的Integer对于-128到127之间的数,会进行缓存。 所以 Integer i = 100 时,会将100进行缓存,下次再写Integer j = 100时,就会直接从缓存中取,而不会new了。

4)Integer变量和int变量比较时,只要两个变量的值是向等的,则结果为true

Integer i = new Integer(100);
int j = 100;
System.out.print(i == j); //true
复制代码

因为包装类Integer和基本数据类型int比较时,Java会自动拆箱为int,然后进行比较,实际上就变为两个int变量的比较

3. ==和equals的区别

3.1 基本概念区分

1)对于==,比较的是值是否相等

如果作用于基本数据类型的变量,则直接比较其存储的 值是否相等,

如果作用于引用类型的变量,则比较的是所指向的对象的地址是否相等。

其实==比较的不管是基本数据类型,还是引用数据类型的变量,比较的都是值,只是引用类型变量存的值是对象的地址

2)对于equals方法,比较的是是否是同一个对象

首先,equals()方法不能作用于基本数据类型的变量,

另外,equals()方法存在于Object类中,而Object类是所有类的直接或间接父类,所以说所有类中的equals()方法都继承自Object类,在没有重写equals()方法的类中,调用equals()方法其实和使用==的效果一样,也是比较的是引用类型的变量所指向的对象的地址,不过,Java提供的类中,有些类都重写了equals()方法,重写后的equals()方法一般都是比较两个对象的值,比如String类。

Object类equals()方法源码:

public boolean equals(Object obj) {
     return (this == obj);
}
复制代码

String类equals()方法源码:

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}
复制代码

3.2 示例

示例1:

int x = 10;
int y = 10;
String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(x == y); // true
System.out.println(str1 == str2); // false
System.out.println(str1.equals(str2)); // true
复制代码

示例2:

String str3 = "abc";
String str4 = "abc";
System.out.println(str3 == str4); // true
复制代码

str3与str4相等的原因是用到了内存中的常量池,当运行到str3创建对象时,如果常量池中没有,就在常量池中创建一个对象"abc",第二次创建的时候,就直接使用,所以两次创建的对象其实是同一个对象,它们的地址值相等。

示例3:

先定义学生Student类

package com.zwwhnly.springbootaction;

public class Student {
    private int age;

    public Student(int age) {
        this.age = age;
    }
}
复制代码

然后创建两个Student实例来比较

Student student1 = new Student(23);
Student student2 = new Student(23);

System.out.println(student1.equals(student2)); // false
复制代码

此时equals方法调用的是基类Object类的equals()方法,也就是==比较,所以返回false。

然后我们重写下equals()方法,只要两个学生的年龄相同,就认为是同一个学生。

package com.zwwhnly.springbootaction;

public class Student {
    private int age;

    public Student(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        Student student = (Student) obj;
        return this.age == student.age;
    }
}
复制代码

此时再比较刚刚的两个实例,返回true。

Student student1 = new Student(23);
Student student2 = new Student(23);

System.out.println(student1.equals(student2)); // true
复制代码

4. String,StringBuilder,StringBuffer的区别

4.1 区别讲解

1)运行速度

运行速度快慢顺序为:StringBuilder > StringBuffer > String

String最慢的原因:

String为字符串常量,而StringBuilder和StringBuffer均为字符串变量,即String对象一旦创建之后该对象是不可以更改的,但后两者的对象是变量,是可以更改的。

2)线程安全

在线程安全上,StringBuilder是线程不安全的,而StringBuffer是线程安全的(很多方法带有synchronized关键字)。

3)使用场景

String:适用于少量的字符串操作的情况。

StringBuilder:适用于单线程下在字符缓冲区进行大量操作的情况。

StringBuffer:适用于多线程下在字符缓冲区进行大量操作的情况。

4.2 示例

以拼接10000次字符串为例,我们看下三者各自需要的时间:

String str = "";
long startTime = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
    str = str + i;
}
long endTime = System.currentTimeMillis();
long time = endTime - startTime;
System.out.println("String消耗时间:" + time);

StringBuilder builder = new StringBuilder("");
startTime = System.currentTimeMillis();
for (int j = 0; j < 10000; j++) {
    builder.append(j);
}
endTime = System.currentTimeMillis();
time = endTime - startTime;
System.out.println("StringBuilder消耗时间:" + time);

StringBuffer buffer = new StringBuffer("");
startTime = System.currentTimeMillis();
for (int k = 0; k < 10000; k++) {
    buffer.append(k);
}
endTime = System.currentTimeMillis();
time = endTime - startTime;
System.out.println("StringBuffer消耗时间:" + time);
复制代码

运行结果:

String消耗时间:258

StringBuilder消耗时间:0

StringBuffer消耗时间:1

也验证了上面所说的StringBuilder > StringBuffer > String。

5. 装箱和拆箱

5.1 什么是装箱?什么是拆箱?

装箱:自动将基本数据类型转换为包装器类型。

拆箱:自动将包装器类型转换为基本数据类型。

Integer i = 10; // 装箱
int j = i; // 拆箱
复制代码

5.2 装箱和拆箱是如何实现的?

装箱过程是通过调用包装器的valueOf方法实现的,

而拆箱过程是通过调用包装器实例的xxxValue方法实现的(xxx代表对应的基本数据类型)。

怎么证明这个结论呢,我们新建个Main类,在主方法中添加如下代码:

package com.zwwhnly.springbootaction;

public class Main {
    public static void main(String[] args) {
        Integer i = 100;        
        int j = i;
    }
}
复制代码

然后打开cmd窗口,切换到Main类所在路径,执行命令:javac Main.java,会发现该目录会生成一个Main.class文件,用IDEA打开,会发现编译后的代码如下:

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.zwwhnly.springbootaction;

public class Main {
    public Main() {
    }

    public static void main(String[] var0) {
        Integer var1 = Integer.valueOf(100);
        int var2 = var1.intValue();
    }
}
复制代码

注意事项:以上所讲使用的是IDEA 2017.2

而在较新版本的IDEA(2018.3.3或者2019.1.3),看到的Main.class是下面这样的:

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.zwwhnly.springbootaction;

public class Main {
    public Main() {
    }

    public static void main(String[] var0) {
        Integer var1 = 100;
        int var2 = var1;
    }
}
复制代码

5.3 示例

示例1:

Double i1 = 100.0;
Double i2 = 100.0;
Double i3 = 200.0;
Double i4 = 200.0;

System.out.println(i1==i2);
System.out.println(i3==i4);
复制代码

输出结果:

false

false

为什么都返回false呢,我们看下Double.valueOf()方法,就知晓了:

private final double value;

public Double(double value) {
   this.value = value;
}

public static Double valueOf(double d) {
   return new Double(d);
}
复制代码

示例2:

Boolean i1 = false;
Boolean i2 = false;
Boolean i3 = true;
Boolean i4 = true;

System.out.println(i1==i2);
System.out.println(i3==i4);
复制代码

输出结果:

true

true

为什么都返回true呢,我们看下Boolean.valueOf()方法,就知晓了:

public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);

public static Boolean valueOf(boolean b) {
   return (b ? TRUE : FALSE);
}
复制代码

6. Java中的值传递和引用传递

6.1 基本概念

值传递:传递对象的一个副本,即使副本被改变,也不会影响源对象,因为值传递的时候,实际上是将实参的值复制一份给形参。

引用传递:传递的并不是实际的对象,而是对象的引用,外部对引用对象的改变也会反映到源对象上,因为引用传递的时候,实际上是将实参的地址值复制一份给形参。

说明:对象传递(数组、类、接口)是引用传递,原始类型数据(整形、浮点型、字符型、布尔型)传递是值传递。

6.2 示例

示例1(值传递):

package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;

        swap(num1, num2);

        System.out.println("num1 = " + num1);
        System.out.println("num2 = " + num2);
    }

    public static void swap(int a, int b) {
        int temp = a;
        a = b;
        b = temp;

        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}
复制代码

运行结果:

a = 20

b = 10

num1 = 10

num2 = 20

可以看出,虽然在swap()方法中a,b的值做了交换,但是主方法中num1,num2的值并未改变。

示例2(引用类型传递):

package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};

        change(arr);

        System.out.println(arr[0]);
    }

    public static void change(int[] array) {
        System.out.println(array[0]);
        array[0] = 0;
    }
}
复制代码

运行结果:

1

0

可以看出,在change()方法中将数组的第一个元素改为0,主方法中数组的第一个元素也跟着变为0。

示例3(StringBuffer类型):

package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer("博客园:申城异乡人");
        System.out.println(stringBuffer);

        changeStringBuffer(stringBuffer);
        System.out.println(stringBuffer);
    }

    public static void changeStringBuffer(StringBuffer stringBuffer) {
        stringBuffer = new StringBuffer("掘金:申城异乡人");

        stringBuffer.append(",欢迎大家关注");
    }
}
复制代码

运行结果:

博客园:申城异乡人

博客园:申城异乡人

也许你会认为第2次应该输出“掘金:申城异乡人,欢迎大家关注”,怎么输出的还是原来的值呢,那是因为在changeStringBuffer中,又new了一个StringBuffer对象,此时stringBuffer变量指向的内存地址已经改变,所以主方法中的stringBuffer变量未受到影响。

如果修改changeStringBuffer()方法的代码为:

public static void changeStringBuffer(StringBuffer stringBuffer) {

    stringBuffer.append(",欢迎大家关注");
}
复制代码

则运行结果会变为:

博客园:申城异乡人

博客园:申城异乡人,欢迎大家关注

示例4(String类型):

package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        String str = new String("博客园:申城异乡人");
        System.out.println(str);

        changeString(str);
        System.out.println(str);
    }

    public static void changeString(String string) {
        //string = "掘金:申城异乡人";
        string = new String("掘金:申城异乡人");
    }
}
复制代码

运行结果:

博客园:申城异乡人

博客园:申城异乡人

在changeString()方法中不管用string = "掘金:申城异乡人";还是string = new String("掘金:申城异乡人");,主方法中的str变量都不会受影响,也验证了String创建之后是不可变更的。

示例5(自定义类型):

package com.zwwhnly.springbootaction;

public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Person(String name) {
        this.name = name;
    }
}
复制代码
package com.zwwhnly.springbootaction;

public class ArrayListDemo {

    public static void main(String[] args) {
        Person person = new Person("zhangsan");
        System.out.println(person.getName());

        changePerson(person);
        System.out.println(person.getName());
    }

    public static void changePerson(Person p) {
        Person person = new Person("lisi");
        p = person;
    }
}
复制代码

运行结果:

zhangsan

zhangsan

修改changePerson()方法代码为:

public static void changePerson(Person p) {
    p.setName("lisi");
}
复制代码

则运行结果为:

zhangsan

lisi

7. 参考

关于==和equals的区别和联系,面试这么回答就可以

Java中==号与equals()方法的区别

Java中的String,StringBuilder,StringBuffer三者的区别

深入剖析Java中的装箱和拆箱

Integer、new Integer() 和 int 比较的面试题

java面试题之int和Integer的区别

最最最常见的Java面试题总结-第一周

8. 最后

打个小广告,欢迎扫码关注微信公众号:「申城异乡人」,定期分享Java技术干货,让我们一起进步。

关注下面的标签,发现更多相似文章
评论