淘宝武汉，面试感受
题记：赶回长沙，已经是夜里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内即为需要操作的数，取出数，压栈，并且清空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鄙视不是计算机相关专业的了，我不是计算机院的，不代表哥不是专业的。
让自己积极点，明天9点半还要去米塔尔楼谈材料院的项目，中午12点足球赛，下午2点面试比赛。
加油! The most important is not about information,it's the interpretation. Stay hungry,stay foolish.
分享到：
相关推荐
本人在武汉面试安卓遇到的面试题，包含答案和解析
武汉大学面试研究生能力测试题，请用VC、VB或其他高级程序设计语言编写以下程序。
武汉C#面试题目集合准备了好久才集合起来的 希望对朋友们有用途。
武汉-英思--ORACLE面试测试题目.doc 武汉-亿阳信通NET.doc 武汉-世纪畅想笔试.doc 武汉-瑞得软件笔试题.doc 武汉-北大高科页面.doc 只显示部分，希望对正在或正准备找工作的朋友带来帮助，也祝愿大家早日找到心中...
武汉-软通动力武汉-软通动力武汉-软通动力武汉-软通动力武汉-软通动力武汉-软通动力武汉-软通动力
(北京，上海，南京，广州，杭州,武汉)等面试题目.其中，北京14家企业，广州12家企业，杭州11家企业，南京19家企业，上海5家企业，深圳6家企业，武汉6家企业，面试题目。以Word形式。记住是.net面试。希望对找工作的...
武汉市2021事业单位教师招聘笔试、面试内容扫描.pdf
黑马武汉校区Java面试宝典
武汉javaEE模拟面试题-V2.0 武汉javaEE模拟面试题-V2.0
这个包含英语面试和专业综合面试，我考的专硕，英语和学硕面试的是一样，专业综合面试分开的，但是每个面试组各个方向的老师都有，所以应该差不多
武汉招商银行面试经历.doc
武汉瑞盈通网络技术-面试经验2019.7.txt
吉利汽车Java笔试面试题.zip_面试资料下载
黑马程序员面试宝典v2.1。 详细讲述了JAVAEE面试中常见问题与题解
武汉理工大学研究生复试面试题库，包括自动原理控制，模电数电等面试涉及到的专业课面试试题。
武汉招教考试面试宝典5分享.pdf
最新各大公司企业真实面试题-武汉东之林科技有限公司机试
传智播客2018版的面试宝典。
联发科2021武汉嵌入式软件开发_嵌入式-常用知识&面试题库_大厂面试真题.docx