Java面试经验分享-优快云博客

本文转载自：http://java-mzd.iteye.com/blog/1004784

题记：赶回长沙，已经是夜里12点了，这次虽然没有收到面试通知，但是抱着拼一拼的态度，还是赶去了武汉，很庆幸，经过自己的努力争取，HR姐姐给了我们一个机会，只可惜，自己表现的太不给力，没把握住。

面我的是“玄难”，虽然挂了我，还是很感激玄难老师吧。整个面试过程，感觉还是很轻松、愉悦，老师给我的感觉是很淡定、从容，一种很睿智的感觉（呵呵，果然是大师）。面试中聊了些与技术无关的东西，有关价值观、未来等，能感觉到老师真的在用心在跟我交流这些东西，也是很真诚的给了我一些来自他的经验和建议，在此对老师还是很感激的。只是很可惜，由于自己在技术面试上拙劣的表现，没有达到老师的要求吧。

下面给出此次老师问我的题目，以及自己的回答，以及自己的回顾点评。欢迎大家在回复中指出我的错误，也欢迎各种更优秀的答案。面的题目其实也比较简单，只是由于自己的拙劣表现而失去了机会，所以也比较遗憾吧。

试题：

1.一个类A，其中有方法int f(int a,int b),怎么通过反射调用此方法？

1.通过class.forName(“A”).newInstance;加载类,并初始化一个该类对象

2.通过对象的getMethod(“f”)方法得到该Method 方法对象

3.调用method对象的 invoke()方法

其实，最可惜的就是此题。

唉。那么熟悉、信心满满的Reflection知识，还记得当初为了搞明白Reflection实现的原理，跑去看过《深入JVM》。打印了好几十页的PDF，上面记满了笔记。后面又用Reflection写过了这么多东西。

结果面试的时候，居然SB的连通过反射调用对象的方法时，需要先得到该方法对象都给忘了，还是在老师的提醒下想起。

在老师的提醒下，想起了要得到方法对象，却又忘记了重载的可能。因为方法可能会重载，所以同一个方法名，可能有不同的参数、返回值，都是不同的方法对象。唉，真的只能说自己表现的太拙劣了吧。这么低级的问题居然都想不起来。

2.Web开发中，filter的作用？

1. 初级的内容，可以用来在外部和服务器间，进行字符串的过滤

2. filter主要应该是用于安全机制，可以通过Http Request中的信息，对用户进行各种限制，比如可以过滤只能某个地区（IP）的用户可以接入，或者只有登录（具有某种权限）的用户才能访问（某些模块）

自己当时第一反应想到的就是这两个，貌似老师觉得两个少了，不太满意？

3.给一个图，给出最优深度查找？

唉，因为确实自己没看过图的内容，就直接坦诚的告诉老师这个我不会了。

估计答到这一步的时候，我就已经基本没戏了？

4.给一个稀疏矩阵，你怎么存？

思考大约1分钟后，我给出的答案是，用链表。

链表的每个节点的有4个数据项，分别为：行号，列号，数据，下一个节点的指向。

这个问题其实我应该表现的很不好吧，一开始居然没听明白“稀疏矩阵”，老师提点了“线性代数”了，我还是让老师花了个例图。应该给老师留下了“不好好上学”的印象吧。而且答完后老师似乎还是不满意。

P.S. 宾哥说,用“邻接链表”，明天查查看。

5.给一个四则运算的字符串，计算出结果

我当时的考虑：因为是字符串，而且需要解析出来，并且字符串之间有一定的规则：用数字和+-*/连接起来。于是，我想到了用正则表达式解析，然后再进行运算

而老师问这个问题的目的应该是考我数据结构，他想听到的答案是用栈实现

import Java.util.Stack;

[java] view plain copy

/**
* 利用栈，进行四则运算的类
* 用两个栈来实现算符优先，一个栈用来保存需要计算的数据numStack,一个用来保存计算优先符priStack
*
* 基本<a href="http://lib.youkuaiyun.com/base/datastructure" class='replace_word' title="算法与数据结构知识库" target='_blank' style='color:#df3434; font-weight:bold;'>算法</a>实现思路为：用当前取得的运算符与priStack栈顶运算符比较优先级：若高于，则因为会先运算，放入栈顶；
* 若等于，因为出现在后面，所以会后计算，所以栈顶元素出栈，取出操作数运算；
* 若小于，则同理，取出栈顶元素运算，将结果入操作数栈。各个优先级'(' > '*' = '/' > '+' = '-' > ')'
* @author java_mzd
*
*/
public class Operate {
private Stack<Character> priStack = new Stack<Character>();// 操作符栈
private Stack<Integer> numStack = new Stack<Integer>();;// 操作数栈
/**
* 传入需要解析的字符串，返回计算结果(此处因为时间问题，省略合法性验证)
* @param str 需要进行技术的表达式
* @return 计算结果
*/
public int caculate(String str) {
// 1.判断string当中有没有非法字符
String temp;// 用来临时存放读取的字符
// 2.循环开始解析字符串，当字符串解析完，且符号栈为空时，则计算完成
StringBuffer tempNum = new StringBuffer();// 用来临时存放数字字符串(当为多位数时)
StringBuffer string = new StringBuffer().append(str);// 用来保存，提高效率
while (string.length() != 0) {
temp = string.substring(0, 1);
string.delete(0, 1);
// 判断temp，当temp为操作符时
if (!isNum(temp)) {
// 1.此时的tempNum内即为需要操作的数，取出数，压栈，并且清空tempNum
if (!"".equals(tempNum.toString())) {
// 当表达式的第一个符号为括号
int num = Integer.parseInt(tempNum.toString());
numStack.push(num);
tempNum.delete(0, tempNum.length());
}
// 用当前取得的运算符与栈顶运算符比较优先级：若高于，则因为会先运算，放入栈顶；若等于，因为出现在后面，所以会后计算，所以栈顶元素出栈，取出操作数运算；
// 若小于，则同理，取出栈顶元素运算，将结果入操作数栈。
// 判断当前运算符与栈顶元素优先级，取出元素，进行计算(因为优先级可能小于栈顶元素，还小于第二个元素等等，需要用循环判断)
while (!compare(temp.charAt(0)) && (!priStack.empty())) {
int a = (int) numStack.pop();// 第二个运算数
int b = (int) numStack.pop();// 第一个运算数
char ope = priStack.pop();
int result = 0;// 运算结果
switch (ope) {
// 如果是加号或者减号，则
case '+':
result = b + a;
// 将操作结果放入操作数栈
numStack.push(result);
break;
case '-':
result = b - a;
// 将操作结果放入操作数栈
numStack.push(result);
break;
case '*':
result = b * a;
// 将操作结果放入操作数栈
numStack.push(result);
break;
case '/':
result = b / a;// 将操作结果放入操作数栈
numStack.push(result);
break;
}
}
// 判断当前运算符与栈顶元素优先级，如果高，或者低于平，计算完后，将当前操作符号，放入操作符栈
if (temp.charAt(0) != '#') {
priStack.push(new Character(temp.charAt(0)));
if (temp.charAt(0) == ')') {// 当栈顶为'('，而当前元素为')'时，则是括号内以算完，去掉括号
priStack.pop();
priStack.pop();
}
}
} else
// 当为非操作符时（数字）
tempNum = tempNum.append(temp);// 将读到的这一位数接到以读出的数后(当不是个位数的时候)
}
return numStack.pop();
}
/**
* 判断传入的字符是不是0-9的数字
*
* @param str
* 传入的字符串
* @return
*/
private boolean isNum(String temp) {
return temp.matches("//d");
}
/**
* 比较当前操作符与栈顶元素操作符优先级，如果比栈顶元素优先级高，则返回true，否则返回false
*
* @param str 需要进行比较的字符
* @return 比较结果 true代表比栈顶元素优先级高，false代表比栈顶元素优先级低
*/
private boolean compare(char str) {
if (priStack.empty()) {
// 当为空时，显然当前优先级最低，返回高
return true;
}
char last = (char) priStack.lastElement();
// 如果栈顶为'('显然，优先级最低，')'不可能为栈顶。
if (last == '(') {
return true;
}
switch (str) {
case '#':
return false;// 结束符
case '(':
// '('优先级最高,显然返回true
return true;
case ')':
// ')'优先级最低，
return false;
case '*': {
// '*/'优先级只比'+-'高
if (last == '+' || last == '-')
return true;
else
return false;
}
case '/': {
if (last == '+' || last == '-')
return true;
else
return false;
}
// '+-'为最低，一直返回false
case '+':
return false;
case '-':
return false;
}
return true;
}
public static void main(String args[]) {
Operate operate = new Operate();
int t = operate.caculate("(3+4*(4*10-10/2)#");
System.out.println(t);
}
}

使用正则的基本实现思路为：按照优先级分组，来分隔正则表达式。

并且，每一组分出来以后，计算完成，再将结果带入原表达式。

先分括号，即：一个括号内的所有内容（数字和运算符）分为一组，因为分组得到的括号内的内容，还是一个字符串，所以，可以对这个字符串进行递归计算。

再分* / ，即：将一个* 和 / 左右的数字和* /号分为一组

再分……

（对不起各位观众朋友，因为本人昨晚12点多才赶回来，现在已经早上7点半，9点半还要去材料院谈项目，12点还要踢比赛，下午2点还要3.1的面试大赛，怕下午撑不住。。俺先睡2小时，晚上回来继续写。。大家等等，中间自己也可以想想实现。

顺便，晚上附送大礼：本人和众同学所收集的淘宝武汉众多面试题，及我们的浅陋看法）

现附上正则解析解法

说明：为什么当又括号时，选择从最里面一层括号开始提取解析.

1.首先从运算优先级别来看，最内一层括号最优先。

2.从逻辑上说，以最外一层为单位提取，再递归，也可以。但是具体用正则表达式解析时，有如下两个问题：

如果有括号嵌套，那么我们需要使用贪婪模式，来把（和最后面一个）匹配。

贪婪模式面临的问题:当为平行括号（）的时候，会把两个都匹配出来

3+3*(2-1)+10/(4-2)

非贪婪模式面临的问题:匹配不了嵌套括号。

3+3*（2-1*4+2*（4-2））

因此，使用如下解法中，从最内层开发匹配只需要一个简单的正则即可实现

[java] view plain copy

import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 用正则表达式，解析四则运算字符串，进行四则运算
*
*思路：四则运算中，我们都是先算出优先级较高的运算符的结果
* 并且用该结果代替该运算表达式（包括运算符和参与运算的数字），得到新的运算表达式，继续进行运算。直到所有的运算符都运算完毕。
* 四则运算中：优先级最高的为括号，嵌套的括号，其内括号优先级也比外面的括号高。因此，我们只需要找出每个单独的括号，计算出结果，并用结果代替改括号内容即可。
* 此思路自动解决了括号嵌套的问题。同理，对于'*' '/' ’+‘ ’-‘ 运算，我们同样只需要用计算结果代替表达式，再代入继续计算
*/
public class RegexOperate {
/**
* 传入表达式，进行计算
*
* @param str
* 需要计算的表达式
* @return 计算结果
*/
public int caculate(String str) {
// 当没有括号嵌套时，左括号’（‘与右括号’）‘直接是没有其他的左括号’(‘的
// 则，左右括号内为数字0-9或者加减乘除，且可以出现N次
String reg = "//(([0-9//+//-//*///]*)//)";
// 编译正则规范
Pattern pat = Pattern.compile(reg);
// 用该正则规范匹配需要匹配的字符串
Matcher match = pat.matcher(str);
// 如果匹配成功
if (match.find()) {
// 整个结果是需要匹配出来的表达式式，
String res = match.group();
// 第二组是需要计算出结果的表达式
String str2 = match.group(1);
int result = caculate2(str2);
// 将代替后的表达式重新进行计算（递归）
return caculate(str.replace(res, "" + result));
}
// 当匹配不到括号时，直接返回计算值，即为计算结果
return caculate2(str);
}
/**
* 不含括号的计算
*
* @param str
* 计算表达式
* @return 计算结果
*/
private int caculate2(String str) {
// 1.先匹配出乘除
// *或者/左右各有一个数字（位数为一位或者以上）的做为一组
String reg = "(//d+)(//*|///)(//d+)";
// 编译正则规范
Pattern pat = Pattern.compile(reg);
// 用该正则规范匹配需要匹配的字符串
Matcher match = pat.matcher(str);
// 如果匹配成功
if (match.find()) {
// 整个结果是需要匹配出来的表达式式，
String res = match.group();
// 在整个组中，第一组是需要计算的第一个数
int a = Integer.parseInt(match.group(1));
// 第二组是需要计算的符号
char ope = match.group(2).charAt(0);
// 第三组是需要计算的第一个数
int b = Integer.parseInt(match.group(3));
// 根据需要计算的数跟计算符计算
int result = operate(a, ope, b);
// 将代替后的表达式重新进行计算（递归）
return caculate2(str.replace(res, "" + result));
}
// 当匹配不到* / 时，开始匹配+ -
// *或者/左右各有一个数字（位数为一位或者以上）的做为一组
String reg2 = "(//d+)(//+|//-)(//d+)";
// 编译正则规范
Pattern pat2 = Pattern.compile(reg2);
// 用该正则规范匹配需要匹配的字符串
Matcher match2 = pat2.matcher(str);
// 如果匹配成功
if (match2.find()) {
// 整个结果是需要匹配出来的表达式式，
String res = match2.group();
// 在整个组中，第一组是需要计算的第一个数
int a = Integer.parseInt(match2.group(1));
// 第二组是需要计算的符号
char ope = match2.group(2).charAt(0);
// 第三组是需要计算的第一个数
int b = Integer.parseInt(match2.group(3));
// 根据需要计算的数跟计算符计算
int result = operate(a, ope, b);
// 将代替后的表达式重新进行计算（递归）
return caculate2(str.replace(res, "" + result));
}
return Integer.parseInt(str);
}
/**
* 根据计算符，及需要计算的数，进行计算，返回结果
*
* @param a
* @param ope
* 计算操作符
* @param b
* @return 计算结果
*/
private int operate(int a, char ope, int b) {
switch (ope) {
case '*':
return a * b;
case '/':
return a / b;
case '+':
return a + b;
case '-':
return a - b;
}
return 0;
}
public static void main(String args[]) {
RegexOperate r = new RegexOperate();
System.out.println(r.caculate("2*(2+33/(10+1))+2*(1+2)"));
}
}

两种方法性能分析：

首先，我们知道使用自己实现的栈的比使用系统栈（递归），效率是要高的。

其次，两个实现中，性能应该都是不高的，因为都在频繁的操作String，而String又是不可更改的（在栈的实现中，使用StringBuffer等进行了一定程度上的性能优化）。

再次，在正则的实现中，正则解析的效率，肯定是瓶颈之一。

（具体的性能测试，请读者自己去操作下，最近实在是忙的一B）

6.什么是平衡二叉树?

平衡二叉树是动态查找表的一种，二叉排序树也是动态查找表，它在插入元素时，虽然整个查找树还是有序的，但是同样的数据，不同的顺序，可能就会导致书的结构差异较大，从而平均查找长度可能差异很大。

而平衡二叉树中，任何一个子节点的左右子树深度差的绝对值不大于一，这样可以保证对于同一组数据，不管其顺序为什么，我们的平均查找长度都不会有什么差异。

当我们插入数据的时候，如果左右子树的深度差绝对值大于一，那么我们将对改子树进行对应的旋转操作，以达到平衡。

研究了那么久的数据结构，真的在面试中发挥作用的就是这个题了吧。可惜已经无法挽回老师对我“基础不扎实“的印象了。

失败原因分析：

老师给我的回复是：专业技能的基础还不够扎实，没有一个完整的知识体系。

其实冷静下来仔细想想，如果有这样一位面试者在我面前：

笔试没过
自称熟悉Reflection，居然简单问题还答的不堪入目
四则运算是栈的基本应用，居然答的牛头不对马嘴（用正则解析）
图是数据结构的重要分支，居然都不知道

我想，如果我是面试官，我也会觉得这样的应聘者的基础功太差了吧。

失败点一：首先，基础功差。客观上，自己确实是半路出家搞程序而且还是商学院的，相比计算机院的同学，在硬件、算法、编译原理、计算机原理、操作系统等知识方面，自己确实会有一定的弱势。

失败点二：然后，主观上来说，今天自己确实发挥的太差，老师问的问题也算是根据我简历上的技能说明来问的，自己也确实应该是非常熟练的掌握了的，但是为什么都没有答好呢？很值得自己反思。

题目分析：

四则运算的那个题，还可以勉强找个理由，因为自己面的是Java研发，当时思维一直固定在用语言实现，而没考虑到老师考的是数据结构，想要的答案是用栈来实现，而且用Java的正则也确实可以实现功能。

但是Reflection那个题，自己这么熟悉的东西，还考的这么基础，自己却莫名其妙的答成这样，确实是自己的问题。（考前没复习？太久没用忘记API？等等等等）

图的深度优先查找，这个题没什么好抱怨的，答不出来安全是自己的错，而且确实是自己不会，感谢老师让我发现了知识的漏洞。

其实数据结构本来应该是自己比较有把握的一块，以为自己ArrayList、LinkedList、HashMap、TreeMap等常见集合框架都自己实现过了，而且对对内部的一些关系（诸如Set和Map的关系）也研究过了，一直以为自己是高枕无忧了。奈何自己的眼光一直只盯着Java，也就只研究过集合框架中的内容，却把图这样重要的东西也给疏漏了，可以说自己今天人品不好，恰好就只问了这个，但是也确实是自己有缺陷，心服口服。

失败点三：一直跟着老师的这个思路在走，没有主动的向老师展示出自己比较擅长的东西。

自己擅长的多线程，网络通信，数据库等内容很遗憾都没有被问到吧，也可能是老师看到我写的擅长Java Reflection，然后问了个反射的问题，结果我还没答好，所以老师失望了，就没再继续问下去了吧。

唉，也确实怪自己一紧张，居然连需要先通过class的方法得到Method对象数组，再通过Method对象数组匹配参数和返回值都给忘了。呵呵，现在还记得自己当时看Reflection的时候的比较上写着，一切都是对象，每个方法都是一个Method类的对象，其中有参数和异常返回值等熟悉，怎么今天就突然一下短路了呢？

（曾经也一直觉得数据结构自己比较熟悉，应该没什么问题，今天悲剧了，所以就算问其他的，可能也可能同样悲剧吧。）

收获：

1.自己的努力得到了一定的回报，所以没有笔试成绩，但是自己勇敢的去争取到了一次面试机会，中间的各种心态变化，自己的心理素质等都得到了很多的锻炼和验证。

2.发现知识漏洞:

1.自以为掌握的很好的反射，原来太久没用，基本API等用法都有所忘记。

2.自以为比较熟悉的数据结构，对于栈，只是明白结构，缺乏去活用它的能力。对于图，居然遗漏了，没有学。

3.面试体会：在面试中，首先还是要展示自己作为“一个人”的基本素质，特性。然后，应该适当的引导老师，尽量展现一下自己的优点。

面试总结的也差不多了，虽然总结就知道自己失败了，总有点挫败感，但是，另一个角度，反而没有了患得患失的焦虑，可以更冷静更合理的看待自己这次的得失。就算失败了，也得好好分析最大程度的挖掘出这次失败对自己的价值

题外话：一。关于计算机专业的知识结构与体系

我想，这主要应该是指：数据库、操作系统、计算机网络、数据结构算法。

写这个，只是想明白自己的优缺点：

缺点：1.数据结构中Java中涉及的比较少的，自己也几乎没有涉及