春招：我竟然三天就拿到了offer？

时间 2019-11-05

标签竟然三天 3天拿到 offer 栏目职业生涯繁體版

原文原文链接

1 回顾个人时间线

在本文的开头,先分享一下本身的春招经历吧:html

各位掘友你们好,我是练习时长快一年的Android小蔡鸡,喜欢看源码,逛掘金,写技术文章......java

好了好,不开玩笑了OWO,本人大三,今年春招投了许多简历的,都是实习岗,可是被捞的只有阿里,头条和美团,一路下来挺不容易的.node

我的认为在春招中运气＞性格＞三观＞技术.面试

1.1 阿里

3月底 在阿里的学长给了内推机会,可是因为本身以前彻底不知道有实习生招聘这种曲线进大公司的事,因此什么都没准备,致使直接裸奔上阵.
3月27日 跟面试官约了晚上的面试时间以后,面了一个小时,从Java虚拟机聊到HashMap,再到ARouter,再聊到Dagger2,再聊到注解处理器,多进程等等,但因为时间久远,具体到底聊了啥基本忘了,只感受当时啥都不会不懂,回答的时候都是只知其一;不知其二的.
3月29日 原本没报什么但愿的,但两天后,没想到阿里让竟然我这菜鸡给过了(心里OS:受宠若惊).跟面试官约了二面的时间.而后接下来的这几天,心态极差,心理负担极重,就是那种不想输,强烈地想赢的感受,什么熬夜准备啊,旷课复习啊,反正你作的我都作了.
3月31日 果不其然,当天面的时候我本身都以为不对劲,一直都是我本身在说,面试官都没怎么得问,不到30分钟就草草收场,至此个人阿里之行就结束了.以后的一个月基本都在复习和调整心态.

1.2 头条

4月我其实给头条投过两次简历,第一次是头条的一个大佬看到个人文章之后,给了我一个白金码(很是感谢),让我有幸参加了头条4月初的面试.那时阿里刚挂,仍是啥都没准备,因此也是跟阿里同样二面就挂了,没什么参考价值,因此这里说的是我第二次投头条的经历.
4月底 在牛客网上填写了简历,而后给头条投递了简历,具体时间记不清了.
5月8日 一面比较顺利,主要是Java并发可见性,原子性,有序性的问题,还问了同步关键字和Lock的优劣,MVVM等等,基本上都是照着你的简历上来问的,答案早已提早准备好,复读之.
5月10日 二面,一上来就是一道ACM,看到题目就有思路了,奈何实在太紧张,不过在面试官的提示下也写出来了,二面复读完Java并发三大特性后,问了View事件传递,事件拦截,事件序列的处理,自定义View,减小过渡渲染和优化渲染的N种方法,多进程,OOM问题.面试结束后就是数天漫长的等待,期间没有任何消息告诉我到底过了仍是没过,根我第一次投头条面试完立刻就能收到结果比起来,这不像极了头条.
5月15日 美团一面事后打电话给头条的HR问我二面过了没,HR告诉我没过以后直接挂了电话.
5月16日 而后戏剧性的一幕出现了!!!早上10点过了没多久,头条的HR打电话过来叫我准备下一轮面试,时间安排在下星期一,并且语气一股没得商量的感受(心里OS:这是什么意思???)
5月20日 我收到了美团的offer,天然就没继续去面头条了.
5月21日 下午HR打电话问我还考不考虑,我感受头条对我不够感兴趣,就拒绝了,虽然真的很感谢当时该我白金码的那位大佬,但总感受我并非头条要找的人.

1.3 美团

5月初 以前就一直想投美团,但一直以为挺迷的,牛客和实习僧这两个网站都被头条刷屏了,为何TMD中的MD还一点动静都没有?就算有也只有iOS岗,因此就很郁闷,在想可能公司不缺人吧.
5月5日 忽然反应过来还能够去官网投递啊,而后去了美团招聘的官网.当时已经很是佛系了,心想今年美团确定不缺人吧,要否则怎么动静这么小?并且在官网投简历,尚未内推不是等于买彩票吗?但最后仍是抱着试一试的态度投递了简历,并且上面基本啥都没写.
5月13日 简历竟然被捞了???!!!老大打电话给我约了面试时间.
5月15日 面了40分钟,差很少也是照着简从来问,仍是Java并发三大特性,还问了Activity的启动流程,再有就是我简历上写的那些多进程,MVVM之类的了.因此大概就是把以前面试的内容再复读一次,不过感受如今复读得已经比较熟练了,面试完后我问面试官对个人评价如何,面试官貌似很高兴,问我简历上面怎么什么都不写,还告诉我我很OK,进的几率仍是很大的(心里OS:有点受宠若惊?)
5月15日下午 老大又给我来了电话,约了下一轮的面试时间,还顺便作了一个15分钟的小面试,问了一些技术问题,基本上是一些开源项目的源码,期间问到了Glide,我恰好没看过,吓得我当天晚上赶忙去把Glide的源码扫了一遍,最后老大还加了个人微信.
5月16日 没错,效率高到甚至没有隔天,老大面我,面了一个小时.有一道ACM,直接秒了,而后继续复读,让我详细讲了Handler,Looper,MessageQueue,Message的源码,还有调试追踪内存泄漏,还有计网TCP三次握手,还有操做系统的死锁,还有AsyncTask底层和在不一样API等级之间的区别等等,多多少少都答了,不过有一些仍是缺页中断了(忘了或者不会QAQ),可是直到最后都没问Glide(QAQ跳来跳去的,我看了一夜啊),面完之后老大貌似对我挺满意的,当场给我过了,而后帮跟我和大老板约了面试.
5月17日 没错,效率高到甚至没有隔天,大老板面我,聊了大概20到30分钟,大老版问的都是一些比较开放性的问题,好比咱们的美团APP启动白屏了让你列出20种可能,最后我从各方面瞎编乱造了大概10种实在编不下去了,感受是想考察个人发散思惟能力,而后问了我为何想去北京,我就说了个人世界观想去见识更大的世界,感受大老板挺开心的.面试结束后我而后私下去问老大大老板以为我怎么样?而后老大告诉我能够等HR电话了(心里OS:说实话有点小开心)
5月20日 跟HR确认了offer,至此个人春招结束.感受本身性格缺陷挺多的,真的很感谢老大对个人帮助和包容.

1.4 小结

不要轻易放弃和认为春招已经结束了,机会其实还有不少.
说句扎心的话,我的以为其实以为在面试中运气真的很重要,若是你和我同样遇到了超nice的领导,就会一路绿灯,要否则的话真的可能会把你面到自闭.
从我我的主观的这次面试经从来说,感受头条并无外界传闻中的那么效率高和缺人.从我我的的这种要强的性格出发,是没法接受这种你告诉我挂了以后不告诉我缘由,而后又再打电话约下一轮面试的操做的.
PS: 我的猜想应该是本来的候选人把头条给鸽了,而后资格顺位继承到我身上,而后我也鸽了,最后实在没人了,因此才会再打电话给我问我考不考虑.可是人是情感动物啊,而情感每每是创建在反馈的基础上的,若是别人给个人反馈太消极了,那么我给别人的表现也确定不会积极到哪里去.

2 把本身训练成HashMap和复读机

此次春招给我最大的感触就是,当你以为本身像复读机能把面试题给复读出来而且对面试官所提的问题能像HashMap同样在常数时间内找到答案的时候,你就离成功很近了.算法

下面是我在准备面试的时候收集的一些知识点:编程

2.1 Java

2.1.1 `volatile`理解，JMM中主存和工做内存究竟是啥？和JVM各个部分怎么个对应关系？

参考link数组

2.1.2 序列化

Serializable在序列化时使用了反射,从而致使GC的频繁调用,参考link缓存

2.1.3 可见性，原子性，有序性(必考)

可见性volatile,一个线程的修改对另一个线程是立刻可见的,
原子性CAS操做,要么都作要么都不作
有序性synchronized经过进入和退出Monitor(观察器)实现,CPU可能会乱序执行指令,若是在本线程内观察,全部操做都是有序的,若是在一个线程中观察另外一个线程,全部操做都是无序的.参考link

2.1.4 Java锁机制

java锁机制实际上是锁总线,同步关键字和Lock接口的优劣.安全

2.1.5 Java的常量池？不一样String赋值方法，引用是否相等？

字面值是常量,在字节码中使用id索引,equals相等引用不必定相等,Android上String的构造函数会被虚拟机拦截,重定向到StringFactorybash

2.1.6 HashMap的实现?树化阈值?负载因子?

数组加链表加红黑树,默认负载因子0.75,树化阈值8,这部分比较常考,建议专门准备.(打个小广告OWO,你也能够关注个人专栏,里面有一篇文章分析了HashMap和ArrayMap)

2.1.7 Java实现无锁同步

CAS的实现如AtomicInteger等等

2.1.8 单例模式

双重检查

public class Singleton {

    private static volatile Singleton singleton;

    private Singleton() {}

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}
复制代码

反序列化安全,反射安全枚举级单例,类加载时由JVM保证单例,反序列化不会生成新对象,另一种反射安全是在构造函数中对单例进行检查若是存在则抛出异常.

2.1.9 锁的条件变量

信号量要与一个锁结合使用,当前线程要先得到这个锁,而后等待与这个锁相关联的信号量,此时该锁会被解锁,其余线程能够抢到这个锁,若是其余线程抢到了这个锁,那他能够通知这个信号量,而后释放该锁,若是此时第一个线程抢到了该锁,那么它将从等待处继续执行(应用场景,将异步回调操做封装为变为同步操做,避免回调地狱)

信号量与锁相比的应用场景不一样,锁是服务于共享资源的,而信号量是服务于多个线程间的执行的逻辑顺序的,锁的效率更高一些.

2.1.10 ThreadLocal原理

线程上保存着ThreadLocalMap,每一个ThreadLocal使用弱引用包装做为Key存入这个Map里,当线程被回收或者没有其余地方引用ThreadLocal时,ThreadLocal也会被回收进而回收其保存的值

2.1.11 软引用,弱引用,虚引用

软引用内存不够的时候会释放
弱引用GC时释放
虚引用,须要和一个引用队列联系在一块儿使用,引用了跟没引用同样,主要是用来跟GC作一些交互.

2.1.12 `ClassLoader`双亲委派机制

简单来讲就是先把加载请求转发到父加载器,父加载器失败了,再本身试着加载

2.1.13 GC Roots有这些

经过System Class Loader或者Boot Class Loader加载的class对象，经过自定义类加载器加载的class不必定是GC Root:

处于激活状态的线程
栈中的对象
JNI栈中的对象
JNI中的全局对象
正在被用于同步的各类锁对象
JVM自身持有的对象，好比系统类加载器等。

2.1.14 GC算法

名称	描述	优势	缺点
标记-清除算法	暂停除了GC线程之外的全部线程,算法分为“标记”和“清除”两个阶段,首先从GC Root开始标记出全部须要回收的对象，在标记完成以后统一回收掉全部被标记的对象。		标记-清除算法的缺点有两个：首先，效率问题，标记和清除效率都不高。其次，标记清除以后会产生大量的不连续的内存碎片，空间碎片太多会致使当程序须要为较大对象分配内存时没法找到足够的连续内存而不得不提早触发另外一次垃圾收集动做
复制算法	将可用内存按容量分红大小相等的两块，每次只使用其中一块，当这块内存使用完了，就将还存活的对象复制到另外一块内存上去，而后把使用过的内存空间一次清理掉	这样使得每次都是对其中一块内存进行回收，内存分配时不用考虑内存碎片等复杂状况，只须要移动堆顶指针，按顺序分配内存便可，实现简单，运行高效	复制算法的缺点显而易见，可以使用的内存降为原来一半
标记-整理算法	标记-整理算法在标记-清除算法基础上作了改进，标记阶段是相同的,标记出全部须要回收的对象，在标记完成以后不是直接对可回收对象进行清理，而是让全部存活的对象都向一端移动，在移动过程当中清理掉可回收的对象，这个过程叫作整理。	标记-整理算法相比标记-清除算法的优势是内存被整理之后不会产生大量不连续内存碎片问题。复制算法在对象存活率高的状况下就要执行较多的复制操做，效率将会变低，而在对象存活率高的状况下使用标记-整理算法效率会大大提升
分代收集算法	是java的虚拟机的垃圾回收算法.基于编程中的一个事实,越新的对象的生存期越短,根据内存中对象的存活周期不一样，将内存划分为几块，java的虚拟机中通常把内存划分为新生代和年老代，当新建立对象时通常在新生代中分配内存空间，当新生代垃圾收集器回收几回以后仍然存活的对象会被移动到年老代内存中，当大对象在新生代中没法找到足够的连续内存时也直接在年老代中建立

2.2 Android

2.2.1 Handler、MessageQueue等一套东西讲一下，详细说了下源码。为何主线程loop不会ANR？

Android线程模型就是消息循环,Looper关联MessageQueue,不断尝试从MessageQueue取出Message来消费,这个过程可能会被它本身阻塞.
而Handler最终都调用enqueueMessage(Message,when)入队的,延迟的实现时当前是时间加上延迟时间给消息指定一个执行的时间点,而后在MessageQueue找到插入位置,此时会判断是否须要唤醒线程来消费消息以及更新下次须要暂停的时间.
Message知道要发到哪一个Handler是由于Message把Handler保存到了target.
Message内部使用链表进行回收复用

2.2.2 View事件以及View体系相关知识

建议看《Android开发艺术探索》,这玩意三言两语讲不清楚

2.2.3 Android中使用多线程的方法

裸new一个Thread(失控线程,不推荐)
RxJava的调度器(io(优先级比低),密集计算线程(优先级比高,用于执行密集计算任务),安卓主线程, Looper建立(实际上内部也是建立了Handler))
Java Executor框架的Executors#newCachedThreadPool(),不会形成资源浪费,60秒没有被使用的线程会被释放
AsyncTask,内部使用FutureTask实现,经过Handler将结果转发到主线程,默认的Executor是共用的,若是同时执行多个AsyncTask,就可能须要排队,可是能够手动指定Executor解决这个问题,直接new匿名内部类会保存外部类的引用,可能会致使内存泄漏
Android线程模型提供的Handler和HandlerThread
使用IntentService
IntentService和Service的区别——没什么区别,其实就是开了个HandlerThread,让它不要在主线程跑耗时任务

2.2.4 RecyclerView复用缓存

建议看一下,这个可能会被问,不过我运气好没被问到.

2.2.5 Activity启动流程

网上有不少相关的文章,能够本身结合源码去看一下,若是能讲个大概的话也是很加分的.

2.2.6 JNI(除非你本身说你会,不然不是很常考)

可避免的内存拷贝,直接传递对象,到C层是一个jobject的指针,可使用jmethodID和jfiledID访问方法和字段,无需进行内存拷贝,使用直接缓冲区也能够避免内存拷贝.
没法避免的内存拷贝,基本类型数组,没法避免拷贝,由于JVM不信任C层的任何内存操做,特别是字符串操做,由于Java的字符串与C/C++的字符串所使用的数据类型是不同的C/C++使用char一个字节(1字节=8位)或wchar_t是四字节.而jstring和jchar使用的是UTF-16编码使用双字节.(Unicode是兼容ASCII,但不兼容GBK,须要本身转换)
本身建立的局部引用必定要释放,不然一直持有内存泄漏
非局部引用方法返回后就会失效,除非建立全局引用,jclass是一个jobject,方法外围使用时须要建立全局引用,jmethodID和jfiledID不须要.
JNI是经过Java方法映射到C函数实现的,若是使用这种方法,函数必须以C式接口导出(由于C++会对名字作修饰处理),固然也能够在JNI_OnLoad方法中注册.
JNIEnv是线程独立的,JNI中使用pthread建立的线程没有JNIEnv,须要AttachCurrentThread来获取JNIEnv,不用时要DetachCurrentThread

2.3专业课

2.3.1 TCP和UDP的根本区别？

数据报,流模式,TCP可靠,包序不对会要求重传,UDP无论,甚至不能保证送到

2.3.2 TCP三次握手

这个被问的概率很是的大,几乎等于必问,建议专门花时间去看.

2.3.3 Http和Https

CA证书,中间机构,公钥加密对称秘钥传回服务端,一个明文一个加密,SSL层,中间人攻击,参考link

2.4 ACM

对于ACM,比较常考链表的题,不常刷算法的同窗必定不要对其有抵触心理.

你可能会问为何要ACM?网上答案说的什么提升代码质量,可以更好地阅读别人的代码这些理由有必定道理,但对于咱们去面试的人而言最重要的是ACM是面试官考察你编码能力的最直接的手段,因此不用说这么多废话刷题就够了.

刷题的话,建议去刷leetcode,题号在200之内的,简单和中等难度,不建议刷困难,由于面试的时候基本就不会出,没人愿意在那里等你想一个半个小时的.

在面试官面前现场白板编程时,能够先把思路告诉面试官,写不写得出来是另一回事,时间复杂度和空间复杂度是怎么来的必定要搞清楚.在编码时也不必定要写出最佳的时间和空间的算法,但推荐你写出代码量最少,思路最清晰的,这样面试官看得舒服,你讲得也舒服.

下面是我在网上收集或者是在实际中遇到过的ACM题,基本上在leetcode上也都有相似的.

2.4.1 数组、链表

链表逆序(头条几乎是必考的)

public ListNode reverseList(ListNode head)
    {
        if (head == null)
        {
            return null;
        }
        if (head.next == null)
        {
            return head;
        }
        ListNode prev = null;
        ListNode current = head;
        while (current != null)
        {
            ListNode next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        return prev;
    }
复制代码

删除排序数组中的重复项

public int removeDuplicates(int[] nums)
    {
        int length = nums.length;
        if (length == 0 || length == 1)
        {
            return length;
        }
        int size = 1;
        int pre = nums[0];
        for (int i = 1; i < length; )
        {
            if (nums[i] == pre)
            {
                i++;
            } else
            {
                pre = nums[size++] = nums[i++];
            }
        }
        return size;
    }
复制代码

数组中找到重复元素
n个长为n的有序数组，求最大的n个数
用O(1)的时间复杂度删除单链表中的某个节点把后一个元素赋值给待删除节点，这样也就至关因而删除了当前元素,只有删除最后一个元素的时间为o(N)平均时间复杂度仍然为O(1)

public void deleteNode(ListNode node) {
          ListNode next = node.next;
          node.val = next.val;
          node.next = next.next;
      }
复制代码

删除单链表的倒数第N个元素两个指针,第一个先走N步第二个再走,时间复杂度为O(N),参考link

public ListNode removeNthFromEnd(ListNode head, int n) {
          if (head == null)
          {
              return null;
          }
          if (head.next == null)
          {
              return n == 1 ? null : head;
          }
          int size = 0;
          ListNode point = head;
          ListNode node = head;
          do
          {
              if (size >= n + 1)
              {
                  point = point.next;
              }
              node = node.next;
              size++;
          } while (node != null);
          if (size == n)
          {
              return head.next;
          }
          node = point.next;
          point.next = node == null ? null : node.next;
          return head;
      }
复制代码

从长序列中找出前K大的数字
用数组实现双头栈

public static class Stack<T>
      {
          
          public Stack(int cap)
          {
              if (cap <= 0)
              {
                  throw new IllegalArgumentException();
              }
              array = new Object[cap];
              left = 0;
              right = cap - 1;
          }
  
          private Object[] array;
          private int left;
          private int right;
          
          public void push1(T val)
          {
              int index = left + 1;
              if (index < right)
              {
                  array[index] = val;
              }
              left = index;
          }
          
          @SuppressWarnings("unchecked")
          public T pop1()
          {
              if (left > 0)
              {
                  return (T)array[left--];
              }
              return null;
          }
          
          public void push2(T val)
          {
              int index = right - 1;
              if (index > left)
              {
                  array[index] = val;
              }
              right = index;
          }
  
          @SuppressWarnings("unchecked")
          public T pop2()
          {
              if (right < array.length)
              {
                 return (T)array[right++];
              }
              return null;
          }
      }
复制代码

两个链表求和，返回结果也用链表表示 1 -> 2 -> 3 + 2 -> 3 -> 4 = 3 -> 5 -> 7

public ListNode addTwoNumbers(ListNode node1, ListNode node2)
      {
          ListNode head = null;
          ListNode tail = null;
          boolean upAdd = false;
          while (!(node1 == null && node2 == null))
          {
              ListNode midResult = null;
              if (node1 != null)
              {
                  midResult = node1;
                  node1 = node1.next;
              }
              if (node2 != null)
              {
                  if (midResult == null)
                  {
                      midResult = node2;
                  } else
                  {
                      midResult.val += node2.val;
                  }
                  node2 = node2.next;
              }
              if (upAdd)
              {
                  midResult.val += 1;
              }
              if (midResult.val >= 10)
              {
                  upAdd = true;
                  midResult.val %= 10;
              }
              else
              {
                  upAdd = false;
              }
              if (head == null)
              {
                  head = midResult;
                  tail = midResult;
              } else
              {
                  tail.next = midResult;
                  tail = midResult;
              }
          }
          if (upAdd)
          {
              tail.next = new ListNode(1);
          }
          return head;
      }
复制代码

交换链表两两节点

public ListNode swapPairs(ListNode head)
      {
          if (head == null)
          {
              return null;
          }
          if (head.next == null)
          {
              return head;
          }
          ListNode current = head;
          ListNode after = current.next;
          ListNode nextCurrent;
          head = after;
          do
          {
              nextCurrent = after.next;
              after.next = current;
              if (nextCurrent == null)
              {
                  current.next = null;
                  break;
              }
              current.next = nextCurrent.next;
              after = nextCurrent.next;
              if (after == null)
              {
                  current.next = nextCurrent;
                  break;
              }
              current = nextCurrent;
          } while (true);
          return head;
      }
复制代码

找出数组中和为给定值的两个元素，如：[1, 2, 3, 4, 5]中找出和为6的两个元素。

public int[] twoSum(int[]mun,int target)
      {
          Map<Integer, Integer> table = new HashMap<>();
          for (int i = 0; i < mun.length; ++i)
          {
              Integer value = table.get(target - mun[i]);
              if (value != null)
              {
                  return new int[]{i, value};
              }
              table.put(mun[i], i);
          }
          return null;
      }
复制代码

2.4.2 树

二叉树某一层有多少个节点

2.4.3 排序

双向链表排序(这个就比较过度了,遇到了就自求多福吧)

public static void quickSort(Node head, Node tail) {
  		if (head == null || tail == null || head == tail || head.next == tail) {
  			return;
  		}
  		
  		if (head != tail) {
  			Node mid = getMid(head, tail);
  			quickSort(head, mid);
  			quickSort(mid.next, tail);
  		}
  	}
  	
  	public static Node getMid(Node start, Node end) {
  		int base = start.value;
  		while (start != end) {
  			while(start != end && base <= end.value) {
  				end = end.pre;
  			}
  			start.value = end.value;
  			while(start != end && base >= start.value) {
  				start = start.next;
  			}
  			end.value = start.value;
  		}
  		start.value = base;
  		return start;
  	}
  	
  	/**
  	 * 使用如内部实现使用双向链表的LinkedList容器实现的快排 
  	 */
  	public static void quickSort(List<Integer> list) {
  		if (list == null || list.isEmpty()) {
  			return;
  		}
  		quickSort(list, 0, list.size() - 1);
  	}
  	
  	private static void quickSort(List<Integer> list, int i, int j) {
  		if (i < j) {
  			int mid = partition(list, i, j);
  			partition(list, i, mid);
  			partition(list,mid + 1, j);
  		}
  	}
  	
  	private static int partition(List<Integer> list, int i, int j) {
  		int baseVal = list.get(i);
  		while (i < j) {
  			while (i < j && baseVal <= list.get(j)) {
  				j--;
  			}
  			list.set(i, list.get(j));
  			while (i < j && baseVal >= list.get(i)) {
  				i++;
  			}
  			list.set(j, list.get(i));
  		}
  		list.set(i, baseVal);
  		return i;
  	}
复制代码

常见排序,如堆排序,快速,归并,冒泡等,还得记住他们的时间复杂度.

2.5 项目

2.5.1 视频聊天使用什么协议？

不要答TCP,答RTMP实时传输协议,RTMP在Github也有不少开源实现,建议面这方面的同窗能够去了解一下.

2.5.2 你在项目中遇到的一些问题,如何解决,思路是什么?

这一块比较抽象,根据你本身的项目来,着重讲你比较熟悉,有把握的模块,通常面试官都会从中抽取一些问题来向你提问.

2.6 提问

不要问诸如：

面试官是哪一个组的？

这种问题一点价值都没有,由于你即便问了也不能从他那里得到额外的信息,也不可以影响他对你的判断,要问就要问面试官对你的感觉与评价,还要体现出你想要加入的心情以及你问题的深度.

XXX今年是否真的缺人？招聘策略是什么？
面试官认为我存在哪些不足(从性格和技术两方面)？
若是面试没经过能不能告诉我挂掉个人缘由,这样既能够帮助到我也能够帮助到我带的学弟学妹们,并且在我分享个人面经的时候也能帮助XX招到更好的人.
XXX须要我这样的同窗吗?

3 最后说一些我的认为比较重要的事

3.1 积极准备、不断试错

机会都是留给有准备的人的,千万不要想着不许备上战场就能成功.
多看面经,面经就是面试官们的招聘导向,透过阅读大量的面经,你可以感觉获得面试官想要找到什么样的人,而且你能够有针对性地去准备.
由于咱们做为学生,每每没有什么实际的项目经验,因此操做系统,计算机网络,数据结构与算法,计算机组成原理这四大基础就是春招考察的重点.
《Android开发艺术探索》这本书之于Android求职者的重要性,我以为全世界都应该知道了,若是你尚未看过,建议真的好好看一下吧.
不断地去面试,若是你此次面试失败了,那必定要好好总结其中的缘由,必定要千方百计地从面试官口中套出本身的不足,这样你下次面试成功的几率就会增长.

3.2 真正重要而且最容易忽视的一些问题

每每有不少同窗明明以为本身已经准备得很好了已经很复读了,可最后仍是不没拿到offer,那么你可能须要考虑如下的问题了.

就像我一开始说的,春招是运气＞性格＞三观＞技术的,项目与基础当然很重要,可是想在短短的数小时能彻底掌握一我的全部的基本状况实在是太难了,面试官看到的每每只是你的冰山一角,因此在面试的时候,你可能还要在乎如下的问题:

随机应变: 准备一些圆场的话,好比在讲原码时,若是以为本身讲得不彻底对,最后就补充一句——可能我说得不彻底准确,可是我以为看源码不是背书,而是学习他的一种思想并用到本身的代码中去.
知己知彼: 深刻地了解目标公司的企业文化,并准备一些夸他们的话,最好可以让对方会心一笑,这样绝对加分.
坚持到底: 有时候可能会被问道一些形而上学的问题,这种问题每每没有标准答案,求生欲必定要强,不会也要编出来,由于每每面试官问你这些问题,其目的并非看你能不能答对,而是想看看你的发散思惟,看看你能给出多少种的答案,这个过程当中你的尝试,会被面试官当成你的价值
三观要正: 世界观要开阔,敢于迎接挑战,但不是当舔狗,不能没有底线,除非是你本身提出,不然当公司让你旷课去实习的时候我想你应该拒绝,由于若是延毕,可能会影响转正,最后必定是得不偿失,理性大于一切.
端正姿态: 咱们是去求职的,不是去当大爷的,你去实习这三个月打算给公司创造多少价值?因此姿态要放低,当面试官让你作选择的时候,先观察这个问题是不是你可以决定的,若是不是,就说公司怎么安排我就服从安排,我愿意接受新的挑战让本身成长.
儒雅随和: 面试的时候语速可慢但必定不能快,要儒雅随和,不要贪婪地说话,适可而止,即便你知道的东西真的不少.由于你准备了面试,面试官同样也准备了面试你,他也有问题想问你的,若是你一直说,他都没机会问,那他确定不爽.不要抢别人的话头,遇事不要轻易下结论,就算他说得不对也不能直接冲脸,要委婉一点.
别太诚实: 固然这并非叫你去说谎,该说不懂的仍是得说不懂,不要不懂装懂.我想说的是不要主动暴露本身的缺点,由于就像我以前说的,面试官面试你的时间是很是短的,每每他对你的了解十分有限,你要尽量的表现出本身的优势而不是缺点.
手握筹码: 当我去头条面试的时候,我手里握有的筹码就是我可能有很大的机会到某国企实习(校企合做项目),当我去美团面试的时候,个人筹码就是我头条也到了三面,你的筹码间接地证实了你的价值,也能影响面试官对你的判断.

3.3 结语

透露一下,本人是双非二本,自从高考失利之后还觉得本身要一直这么平凡下去QAQ,没想到过了三年终于又给我一个机会让我从新证实了本身,能有机会去到美团这样的大厂工做,真的倍感荣幸.最后的最后仍是惯例啦,若是喜欢个人文章别忘了给我点个赞,拜托了这对我来讲真的很重要.