【Java面试题系列】：Java基础知识面试题，看这一篇就够了（持续更新）
文中面试题从茫茫网海中精心筛选，如有错误，欢迎指正！
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代表对应的基本数据类型）。
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);
}
7.参考链接
java中的string，stringbuilder，stringbuffer三者的区别
上一篇： 关于kafka的一些问题理解
下一篇： 163 AJAX Tab