淘宝武汉，面试感受

题记：赶回长沙，已经是夜里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 * * 基本算法实现思路为：用当前取得的运算符与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内即为需要操作的数，取出数，压栈，并且清空tempNumif (!"".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 '(':// '('优先级最高,显然返回truereturn true;case ')':// ')'优先级最低，return false;case '*': {// '*/'优先级只比'+-'高if (last == '+' || last == '-')return true;elsereturn false;}case '/': {if (last == '+' || last == '-')return true;elsereturn false;}// '+-'为最低，一直返回falsecase '+':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.什么是平衡二叉树?

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

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

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

 

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

 

 

 

 

失败原因分析：

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

 

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

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

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

 

 

 

 

 

 

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

 

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

 

题目分析：

四则运算的那个题，还可以勉强找个理由，因为自己面的是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鄙视不是计算机相关专业的了，我不是计算机院的，不代表哥不是专业的。

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