本文转载自：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;
- /**
- * 利用栈，进行四则运算的类
- * 用两个栈来实现算符优先，一个栈用来保存需要计算的数据numStack,一个用来保存计算优先符priStack
- *
- * 基本<a href="http://lib.csdn.net/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））
因此，使用如下解法中，从最内层开发匹配只需要一个简单的正则即可实现 |
- 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中涉及的比较少的，自己也几乎没有涉及
2.操作系统，对于Linux只是简单的了解，并没有很深入的研究过文件系统与内存管理等内容（不过还好，在一直正在学习中）
3.算法，其实，最大的硬伤就在这，一直没有抽空去研究算法，懂的也确实少，这个是大四初期的主要任务。
优点：1.对于数据结构其他部分还是比较清楚。
2.对计算机网络有比较深入的了解（嘿嘿，哥一直在写的小恶意程序就要出来了）
3.对Java语言的掌握还算比较到位
4.数据库掌握比较好
5.毅力强，对技术狂热
关于是否是计算机专业?
很多人都觉得，非计算机专业，就是基础差的代名词。
首先，我必须承认一个基础的事实，普遍意义上来说，计算机专业的同学基础好与非计算机专业。在其他的院，确实不会开数据库、操作系统、编译原理、计算机网络、数据结构算法这些课程，我们是综合学科，虽然开了，但是也确实学的很肤浅。
但是，那只是普通意义上来说。如果对于一个非计算机专业的，技术狂热爱好者呢？我们说的专业，难道只是指的课堂上的专业？
大部分计算机相关专业的同学，或许只是在课堂上上课，大学课堂是什么情况，大家都懂的。可是，对于狂热爱好者呢？他并不是没有学，他只是没在课堂上学。
我不知道有几个计算机相关专业的同学像我一样，每天将近有12个小时在研究技术？
PS. 写这个只是因为最近连续被几个HR鄙视不是计算机相关专业的了，我不是计算机院的，不代表哥不是专业的。