【Java面试题系列】:Java基础知识面试题,看这一篇就够了
时间:2019-05-08 17:10 来源:linux.it.net.cn 作者:IT
1.前言
参加过社招的同学都了解,进入一家公司面试开发岗位时,填写完个人信息后,一般都会让先做一份笔试题,然后公司会根据笔试题的回答结果,确定要不要继续此次面试,如果答的不好,有些公司可能会直接说“技术经理或者总监在忙,你先回去等通知吧”,有些公司可能会继续面试,了解下你的项目经验等情况。
至少在工作的前5年甚至更久,面试一般不会跳过笔试题这个环节(大牛,个别公司除外),我自己也记不清自己面试过多少家公司,做过多少份面试题了,导致现在有时逛街,总感觉很多地方似曾相识,感觉自己多年前曾经来面过试,一度自嘲,一度也怀疑,自己当年是靠什么在上海坚持下来的,所以说面试题对于求职来说,还是非常重要的。
网上搜索“Java面试题”几个关键字也是有很多很多的文章讲解,为什么我还要自己总结呢?主要有以下几个原因:
文章太多,反倒不知道该看哪个(就如一本书中所说太多的资讯等于没有资讯)
文章的准确性不高(曾多次发现描述不正确或代码跑不起来的情况)
可以加深自己的理解和记忆
一劳永逸,下次不用再从网上慢慢筛选,看自己整理的就好了
2.提纲
本篇主要整理下Java基础知识的面试题,主要包含以下几点:
2.1 Integer与int的区别
2.2 ==和equals的区别
2.3 String,StringBuilder,StringBuffer的区别
2.4 装箱和拆箱
接下来一一讲解。
3.Integer与int的区别
3.1基本概念区分:
Integer是int的包装类(引用类型),int是java的一种基本数据类型(值类型)。
Integer变量必须实例化后才能使用,而int变量不需要。
Integer实际是对象的引用,当new一个Integer时,实际上是生成一个指针指向此对象;而int则是直接存储数据值。
Integer的默认值是null,int的默认值是0。
3.2Integer与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对于-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变量的比较
4.==和equals的区别
4.1基本概念区分
1)对于==,比较的是值是否相等
如果作用于基本数据类型的变量,则直接比较其存储的 “值”是否相等;
如果作用于引用类型的变量,则比较的是所指向的对象的地址是否相等。
其实==比较的不管是基本数据类型,还是引用数据类型的变量,比较的都是值,只是引用类型变量存的值是对象的地址
2)对于equals方法,比较的是是否是同一个对象
equals方法不能作用于基本数据类型的变量,equals继承Object类;
如果没有对equals方法进行重写,则比较的是引用类型的变量所指向的对象的地址;
诸如String、Date等类对equals方法进行了重写的话,比较的是所指向的对象的内容。
3)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;
}
4.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.springbootdemo;
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.springbootdemo;
public class Student {
private int age;
public Student(int age) {
this.age = age;
}
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
5.String,StringBuilder,StringBuffer的区别
5.1区别讲解
1)运行速度
运行速度快慢顺序为:StringBuilder > StringBuffer > String
String最慢的原因:
String为字符串常量,而StringBuilder和StringBuffer均为字符串变量,即String对象一旦创建之后该对象是不可以更改的,但后两者的对象是变量,是可以更改的。
2)线程安全
在线程安全上,StringBuilder是线程不安全的,而StringBuffer是线程安全的(很多方法带有synchronized关键字)。
3)使用场景
String:适用于少量的字符串操作的情况。
StringBuilder:适用于单线程下在字符缓冲区进行大量操作的情况。
StringBuffer:适用于多线程下在字符缓冲区进行大量操作的情况。
5.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。
#6.装箱和拆箱
6.1什么是装箱?什么是拆箱?
装箱:自动将基本数据类型转换为包装器类型。
拆箱:自动将包装器类型转换为基本数据类型。
Integer i = 10; // 装箱
int j = i; // 拆箱
6.2 装箱和拆箱是如何实现的?
装箱过程是通过调用包装器的valueOf方法实现的,而拆箱过程是通过调用包装器实例的 xxxValue方法实现的。(xxx代表对应的基本数据类型)。
怎么证明这个结论呢,我们新建个类Main,在主方法中添加如下代码:
package com.zwwhnly.springbootdemo;
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.springbootdemo;
public class Main {
public Main() {
}
public static void main(String[] var0) {
Integer var1 = Integer.valueOf(100);
int var2 = var1.intValue();
}
}
6.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);
} (责任编辑:IT)
1.前言 参加过社招的同学都了解,进入一家公司面试开发岗位时,填写完个人信息后,一般都会让先做一份笔试题,然后公司会根据笔试题的回答结果,确定要不要继续此次面试,如果答的不好,有些公司可能会直接说“技术经理或者总监在忙,你先回去等通知吧”,有些公司可能会继续面试,了解下你的项目经验等情况。 至少在工作的前5年甚至更久,面试一般不会跳过笔试题这个环节(大牛,个别公司除外),我自己也记不清自己面试过多少家公司,做过多少份面试题了,导致现在有时逛街,总感觉很多地方似曾相识,感觉自己多年前曾经来面过试,一度自嘲,一度也怀疑,自己当年是靠什么在上海坚持下来的,所以说面试题对于求职来说,还是非常重要的。 网上搜索“Java面试题”几个关键字也是有很多很多的文章讲解,为什么我还要自己总结呢?主要有以下几个原因: 文章太多,反倒不知道该看哪个(就如一本书中所说太多的资讯等于没有资讯) 文章的准确性不高(曾多次发现描述不正确或代码跑不起来的情况) 可以加深自己的理解和记忆 一劳永逸,下次不用再从网上慢慢筛选,看自己整理的就好了 2.提纲 本篇主要整理下Java基础知识的面试题,主要包含以下几点: 2.1 Integer与int的区别 2.2 ==和equals的区别 2.3 String,StringBuilder,StringBuffer的区别 2.4 装箱和拆箱 接下来一一讲解。 3.Integer与int的区别 3.1基本概念区分: Integer是int的包装类(引用类型),int是java的一种基本数据类型(值类型)。 Integer变量必须实例化后才能使用,而int变量不需要。 Integer实际是对象的引用,当new一个Integer时,实际上是生成一个指针指向此对象;而int则是直接存储数据值。 Integer的默认值是null,int的默认值是0。 3.2Integer与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对于-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变量的比较 4.==和equals的区别 4.1基本概念区分 1)对于==,比较的是值是否相等 如果作用于基本数据类型的变量,则直接比较其存储的 “值”是否相等; 如果作用于引用类型的变量,则比较的是所指向的对象的地址是否相等。 其实==比较的不管是基本数据类型,还是引用数据类型的变量,比较的都是值,只是引用类型变量存的值是对象的地址 2)对于equals方法,比较的是是否是同一个对象 equals方法不能作用于基本数据类型的变量,equals继承Object类; 如果没有对equals方法进行重写,则比较的是引用类型的变量所指向的对象的地址; 诸如String、Date等类对equals方法进行了重写的话,比较的是所指向的对象的内容。 3)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; } 4.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.springbootdemo; 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.springbootdemo; public class Student { private int age; public Student(int age) { this.age = age; } 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 5.String,StringBuilder,StringBuffer的区别 5.1区别讲解 1)运行速度 运行速度快慢顺序为:StringBuilder > StringBuffer > String String最慢的原因: String为字符串常量,而StringBuilder和StringBuffer均为字符串变量,即String对象一旦创建之后该对象是不可以更改的,但后两者的对象是变量,是可以更改的。 2)线程安全 在线程安全上,StringBuilder是线程不安全的,而StringBuffer是线程安全的(很多方法带有synchronized关键字)。 3)使用场景 String:适用于少量的字符串操作的情况。 StringBuilder:适用于单线程下在字符缓冲区进行大量操作的情况。 StringBuffer:适用于多线程下在字符缓冲区进行大量操作的情况。 5.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。 #6.装箱和拆箱 6.1什么是装箱?什么是拆箱? 装箱:自动将基本数据类型转换为包装器类型。 拆箱:自动将包装器类型转换为基本数据类型。 Integer i = 10; // 装箱 int j = i; // 拆箱 6.2 装箱和拆箱是如何实现的? 装箱过程是通过调用包装器的valueOf方法实现的,而拆箱过程是通过调用包装器实例的 xxxValue方法实现的。(xxx代表对应的基本数据类型)。 怎么证明这个结论呢,我们新建个类Main,在主方法中添加如下代码: package com.zwwhnly.springbootdemo; 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.springbootdemo; public class Main { public Main() { } public static void main(String[] var0) { Integer var1 = Integer.valueOf(100); int var2 = var1.intValue(); } } 6.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); } (责任编辑:IT) |