华为面试题库

一、华为题库tcpip应用层之上的几个协议具体说明内容：OSI是一个开放性的通信系统互连参考模型，他是一个定义得非常好的协议规范。OSI模型有7层结构，每层都可以有几个子层。OSI的7层从上到下分别是7应用层6表示层5会话层4传输层3网络层2数据链路层1物理层；其中高层（即7、6、5、4层）定义了应用程序的功能，下面3层（即3、2、1层）主要面向通过网络的端到端的数据流。其中传输层包含tcpudpspx等协议Tcpip模型是一系列网络协议的总称。Tcpip模型的四层结构： 这些协议分成四个层次，上一层的协议都以下一层的协议为基础。从下到上的四层，连接层（LindLayer）、网络层（InternetLayer）、传输层（TransportLayer）、应用层（ApplicationLayer）。连接层负责建立电路连接，是整个网络的物理基础，典型的协议包括以太网、ADSL等。数据链路层。这个层次为待传送的数据加入一个以太网协议头，并进行CRC编码，为最后的数据传输做准备。再往下则是硬件层次了，负责网络的传输，这个层次的定义包括网线的制式，网卡的定义等等（这些我们就不用关心了，我们也不做网卡），所以有些书并不把这个层次放在tcp/ip协议族里面，因为它几乎和tcp/ip协议的编写者没有任何的关系。发送协议的主机从上自下将数据按照协议封装，而接收数据的主机则按照协议从得到的数据包解开，最后拿到需要的数据。这种结构非常有栈的味道，所以某些文章也把tcp/ip协议族称为tcp/ip协议栈。网络层负责分配地址和传送二进制数据，主要协议是IP协议。传输层负责传送文本数据，主要协议是TCP协议、UDP协议应用层负责传送各种最终形态的数据，是直接与用户打交道的层，典型协议是HTTP、FTP等。TCP/IP详解学习笔记(1)-基本概念互联网IP地址：现在，通常使用的IP地址是一个32bit的数字，也就是我们常说的IPv4标准，这32bit的数字分成四组，也就是常见的55的样式。IPv4标准上，地址被分为五类，我们常用的是B类地址。具体的分类请参考其他文档。需要注意的是IP地址是网络号+主机号的组合，这非常重要。32Bit分成四组，一组8bit2^8=16*16=256域名系统域名系统是一个分布的数据库，它提供将主机名（就是网址啦）转换成IP地址的服务。RFCRFC是什么？RFC就是tcp/ip协议的标准文档，在这里我们可以看到RFC那长长的定义列表，现在它一共有4000多个协议的定义，当然，我们所要学习的，也就是那么十几个协议而已。端口号(port)注意，这个号码是用在TCP，UDP上的一个逻辑号码，并不是一个硬件端口，我们平时说把某某端口封掉了，也只是在IP层次把带有这个号码的IP包给过滤掉了而已。

应用编程接口现在常用的编程接口有socket和TLI。而前面的有时候也叫做“Berkeleysocket”，可见Berkeley对于网络的发展有多大的贡献。TCP/IP详解学习笔记(2)-数据链路层数据链路层有三个目的：

为IP模块发送和

接收IP数据报。

为ARP模块发送ARP请求和接收ARP应答。

为RARP发送RARP请

求和接收RARP应答ip大家都听说过。至于ARP和RARP，ARP叫做地址解析协议，是用IP地址换MAC地址的一种协议，而RARP则叫做逆地址解析协议，在tcp/ip协议的后面章节会介绍它们（在局域网里面用ARP协议可以很容易的搞瘫痪网络哦）数据链路层的协议还是很多的，有我们最常用的以太网（就是平时我们用的网卡）协议，也有不太常见的令牌环，还有FDDI，当然，还有国内现在相当普及的PPP协议（就是adsl宽带），以及一个loopback协议。联系linux里面的ifconfig-a命令，这个命令通常会得到如下的结果其中，eth0就是以太网接口，而lo则是loopback接口。这也说明这个主机在网络链路层上至少支持loopback协议和以太网协议。以太网（Ether-net）的定是指数字设备公司（

DigitalEquipmentCorp.）、英特尔公司（IntelCorp.）和Xerox公司在1982年联合公布的一个标准，这个标准里面使用了一种称作CSMA/CD的接入方法。而IEEE802提供的标准集802.3(还有一部分定义到了802.2中)也提供了一个CSMA/CD的标准。这两个标准稍有不同，TCP/IP协议对这种情况的处理方式如下:·

以太网的IP数据报封装在RFC894中定义，而IEEE802网络的IP数据报封装在RFC1042中定义。·

一台主机一定要能发送和接收RFC894定义的数据报。·

一台主机可以接收RFC894和RFC1042的封装格式的混合数据报。Stringuser="test";Stringpassword="test";Connectioncon=DriverManager.getConnection(url,user,password);5)连接PostgreSQL数据库Class.forName("org.postgresql.Driver");Stringurl="JDBC:postgresql://localhost/testDb";Stringuser="test";Stringpassword="test";Connectioncon=DriverManager.getConnection(url,user,password);6)连接Access数据库Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");Stringurl="JDBC:odbc:Driver={MicrosoftAccessDriver(*.mdb)};DBQ="+application.getRealPath("/Data/testDb/mdb");Connectionconn=DriverManager.getConnection(url,"","");7连接Sybase数据库Class.forName("com.sybase.JDBC.SybDriver");Stringurl="JDBC:sybase:Tds:localhost:5007/testDb";Propertiespro=System.getProperties();pro.put("user","userId");pro.put("password","user_password");Connectioncon=DriverManager.getConnection(url,pro);8连接informix数据库Class.forName("rmix.JDBC.ifxDriver");Stringurl="JDBC:informix-sqli:localhost:1533/testDb:INFORMIXSERVER=myserver"user=testUser;password=testpassword";Connectioncon=DriverManager.getConnection(url);就是那个保存数组面试题目问题dataset和list的使用区别/envelope/archive/2010/04/20/1716343.html/topics/350207425java框架问题spring3.0/lib/view/open1338338587698.htmlspringstrutshibernate内存溢出为何会出现内存溢出如何处理内存溢出/miyunhong/article/details/5373910/jxzxm1_2/article/details/2499751dataset的几个实现/fttbfttb/articles/1509662.html标准html写界面的code/html/html_forms.asp前台界面的一些封装类可以直接使用的有哪些JavaScript内置对象/developerworks/cn/web/wa-objectsinjs-v1b/JavaScriptDOM对象http://www.caogen8.co/w3school/js/js_obj_htmldom.asp.htm什么是线程安全什么是不安全？/zwq194/archive/2012/06/26/2563567.htmlshh架构struts关于action的使用/lsh6688/article/details/7525963还有就是java的一些细节问题我记不住了你网上搜搜华为java面试会有好多看看就好了./link?url=0M6kj9LRAV76YazYQFOZhKuxTM0rPVnpfyiG3wXzNluksR4DbC-wOXqkuBO38dd4kNeC2DYwDjrcZKqK5I2pxtr1mIAoE7Np7mLI-B-BdZq二、面试十大算法题目字符串如果IDE没有代码自动补全功能，所以你应该记住下面的这些方法。链表在Java中，链表的实现非常简单，每个节点Node都有一个值val和指向下个节点的链接next。classNode{ intval; Nodenext; Node(intx){ val=x; next=null; }}/article/1017将这些全部实现，并且记忆。常用排序算法：/morewindows/article/details/6684558说明各个排序算法的具体实现。/11745/关于直观展示各个排序算法的gif图片。Verygood程序员必知的8种算法/pzhtpf/article/details/7559896集中排序算法的比较/articles/Izi6nm快速排序：基本思想：先从队列中取出一个数据作为基准。分区过程，将比这个数大的都放它右边，比它小的都放左边。在针对左右区间，分别执行上述操作，直到左右区间都只剩下一个数。采用的核心思路是递归的思路：挖坑填数加分治法（1）基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。（2）实例：实现：privatevoidquickSort(int[]array,intfrom,intto){

if(from<to){

inttemp=array[to];

inti=from-1;

for(intj=from;j<to;j++){

if(array[j]<=temp){

i++;

inttempValue=array[j];

array[j]=array[i];

array[i]=tempValue;

}

}

array[to]=array[i+1];

array[i+1]=temp;

quickSort(array,from,i);

quickSort(array,i+1,to);

}

}归并排序介绍：归并排序（Mergesort，台湾译作：合并排序）是建立在归并操作上的一种有效的\o"排序"排序\o"算法"算法。该算法是采用\o"分治法"分治法（DivideandConquer）的一个非常典型的应用步骤：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列设定两个指针，最初位置分别为两个已经排序序列的起始位置比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置重复步骤3直到某一指针达到序列尾将另一序列剩下的所有元素直接复制到合并序列尾（1）基本排序：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。（2）实例：实现-1publicvoidmergeSort(int[]data,intleft,intright){

//TODOAuto-generatedmethodstub

if(left<right){

//找出中间索引

intcenter=(left+right)/2;

//对左边数组进行递归

mergeSort(data,left,center);

//对右边数组进行递归

mergeSort(data,center+1,right);

//合并

merge(data,left,center,right);

}

}

publicvoidmerge(int[]data,intleft,intcenter,intright){

//TODOAuto-generatedmethodstub

int[]tmpArr=newint[data.length];

intmid=center+1;

//third记录中间数组的索引

intthird=left;

inttmp=left;

while(left<=center&&mid<=right){

//从两个数组中取出最小的放入中间数组

if(data[left]<=data[mid]){

tmpArr[third++]=data[left++];

}else{

tmpArr[third++]=data[mid++];

}

}

//剩余部分依次放入中间数组

while(mid<=right){

tmpArr[third++]=data[mid++];

}

while(left<=center){

tmpArr[third++]=data[left++];

}

//将中间数组中的内容复制回原数组

while(tmp<=right){

data[tmp]=tmpArr[tmp++];

}

System.out.println(Arrays.toString(data));

}堆排序介绍：堆积排序（Heapsort）是指利用\o"堆(数据结构)"堆这种数据结构所设计的一种排序算法。堆是一个近似\o"完全二叉树"完全二叉树的结构，并同时满足堆性质：即子结点的键值或索引总是小于（或者大于）它的父节点。步骤：（1）基本思想：堆排序是一种树形选择排序，是对直接选择排序的有效改进。堆的定义如下：具有n个元素的序列（h1,h2,...,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。（2）实例：初始序列：46,79,56,38,40,84建堆：交换，从堆中踢出最大数剩余结点再建堆，再交换踢出最大数依次类推：最后堆中剩余的最后两个结点交换，踢出一个，排序完成。publicvoidheapSort(int[]a){

System.out.println("开始排序");

intarrayLength=a.length;

//循环建堆

for(inti=0;i<arrayLength;i++){

//建堆

buildMaxHeap(a,arrayLength-1-i);

//交换堆顶和最后一个元素

swap(a,0,arrayLength-1-i);

System.out.println(Arrays.toString(a));

}

}

privatevoidswap(int[]data,inti,intj){

inttemp=data[i];

data[i]=data[j];

data[j]=temp;

}

privatevoidbuildMaxHeap(int[]data,intlastIndex){

//从lastIndex处节点（最后一个节点）的父节点开始

for(inti=(lastIndex-1)/2;i>=0;i--){

//k保存正在判断的节点

intk=i;

//如果当前k节点的子节点存在

while(k*2+1<=lastIndex){

//k节点的左子节点的索引

intbiggerIndex=2*k+1;

//如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在

if(biggerIndex<lastIndex){

//若果右子节点的值较大

if(data[biggerIndex]<data[biggerIndex+1]){

//biggerIndex总是记录较大子节点的索引

biggerIndex++;

}

}

//如果k节点的值小于其较大的子节点的值

if(data[k]<data[biggerIndex]){

//交换他们

swap(data,k,biggerIndex);

//将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值

k=biggerIndex;

}else{

break;

}

}

}

}选择排序选择排序(Selectionsort)是一种简单直观的\o"排序算法"排序算法。它的工作原理如下。首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。以此类推，直到所有元素均排序完毕。简单选择排序：（1）基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。（2）实例：实现-1publicvoidselectSort(int[]a){

intposition=0;

for(inti=0;i<a.length;i++){

intj=i+1;

position=i;

inttemp=a[i];

for(;j<a.length;j++){

if(a[j]<temp){

temp=a[j];

position=j;

}

}

a[position]=a[i];

a[i]=temp;

}

}冒泡排序与交换排序有点类似冒泡排序（BubbleSort，台湾译为：泡沫排序或气泡排序）是一种简单的\o"排序算法"排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。步骤：比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。（1）基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。（2）实例：实现1-第一种实现方式bymyselfpublicvoidBubbleSort(int[]a){

for(inti=0;i<a.length;i++){

for(intj=i+1;j<a.length;j++){

if(a[i]>a[j]){

swap(a,i,j);

//inttemp;

//temp=a[j];

//a[j]=a[i];

//a[i]=temp;

}

}

}

}

publicvoidswap(int[]args,inta,intb){

inttemp;

temp=args[b];

args[b]=args[a];

args[a]=temp;

}此实现类似于交换排序实现-2正宗的冒泡排序publicstaticvoidbubbleSort(int[]array){

//下两种选择一种即可

///方式1

for(inti=array.length-1;i>0;i--){

for(intj=0;j<i;j++){

if(array[j]>array[j+1]){

Sort.swap(array,j,j+1);//交换j和j+1

}

}

}

///方式2

for(inti=0;i<array.length;i++){

for(intj=0;j<array.length-1-i;j++){

if(array[j]>array[j+1]){

Sort.swap(array,j,j+1);//交换j和j+1

}

}

}

}插入排序介绍：插入排序（InsertionSort）的算法描述是一种简单直观的\o"排序算法"排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。步骤：从第一个元素开始，该元素可以认为已经被排序取出下一个元素，在已经排序的元素序列中从后向前扫描如果该元素（已排序）大于新元素，将该元素移到下一位置重复步骤3，直到找到已排序的元素小于或者等于新元素的位置将新元素插入到该位置中重复步骤2（1）基本思想：在要排序的一组数中，假设前面(n-1)[n>=2]个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。（2）实例实现-1publicvoidinsertSort(int[]args){

for(inti=0;i<args.length;i++){

intj=i-1;

intkey=args[i];

while(j>=0&&args[j]>key){

args[j+1]=args[j];

args[j]=key;

j--;

}

}

}实现-2publicvoidinsertSort(int[]args){

for(inti=0;i<args.length;i++){

intj=i-1;

intkey=args[i];

for(;j>=0&&args[j]>key;j--){

args[j+1]=args[j];

//args[j]=key;

}

args[j+1]=key;

}

}希尔排序是针对插入排序的一个直接优化。介绍：希尔排序，也称递减增量排序算法，是\o"插入排序"插入排序的一种高速而稳定的改进版本。希尔排序是基于插入排序的以下两点性质而提出改进方法的：1、插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到\o"线性排序"线性排序的效率2、但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位>希尔排序（最小增量排序）1）基本思想：算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。（2）实例：实现：publicvoidshellSort(int[]a){

doubled1=a.length;

inttemp=0;

while(true){

d1=Math.ceil(d1/2);//math.ceil(x)返回大于参数x的最小整数,即对浮点数向上取整

intd=(int)d1;

for(intx=0;x<d;x++){

for(inti=x+d;i<a.length;i+=d){

intj=i-d;

temp=a[i];

for(;j>=0&&a[j]>temp;j-=d){

a[j+d]=a[j];

//a[j]=temp;

}

a[j+d]=temp;

}

}

if(d==1){

break;

}

}

}基数排序（1）基本思想：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。（2）实例：实现publicvoidsort(int[]array){

//首先确定排序的趟数;

intmax=array[0];

for(inti=1;i<array.length;i++){

if(array[i]>max){

max=array[i];

}

}

inttime=0;

//判断位数;

while(max>0){

max/=10;

time++;

}

//建立10个队列;

List<ArrayList>queue=newArrayList<ArrayList>();

for(inti=0;i<10;i++){

ArrayList<Integer>queue1=newArrayList<Integer>();

queue.add(queue1);

}

//进行time次分配和收集;

for(inti=0;i<time;i++){

//分配数组元素;

for(intj=0;j<array.length;j++){

//得到数字的第time+1位数;

intx=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10,i);

ArrayList<Integer>queue2=queue.get(x);

queue2.add(array[j]);

queue.set(x,queue2);

}

intcount=0;//元素计数器;

//收集队列元素;

for(intk=0;k<10;k++){

while(queue.get(k).size()>0){

ArrayList<Integer>queue3=queue.get(k);

array[count]=queue3.get(0);

queue3.remove(0);

count++;

}

}

}//endfor

}递归vs迭代三、面经1-2-3面经-1博主毕业快满三年了，由于种种原因想换一份工作。学了7年计算机技术，在目前的行业用到的技术不多，还是想去寻找一份互联网行业的工作，这样更能学以致用发挥自己的特长。从上次更新博客到现在已经三周左右了，这三周博客基本断更了，现在找工作也基本收尾了，来聊一聊我所遇到的一些面试经历，希望给各位寻求新机会的小伙伴一个参考。总共面完8家收了7个offer，应该算是比较成功的吧。博文中主要还是聊一下技术相关的，博文中所涉及的公司均以代号标志，不便透露细节。第一家面试的公司是一家互联网创业公司，这里简称D，博主对这家公司的印象还是不错的，共面试了5轮，笔试一轮，技术面3轮，最后一轮是HR面。虽然公司总共员工只有小几百人，但是做事比较专业，很多大型的成熟公司也未必做得更好。首先说说笔试，很多一些小的公司，就是从网上题库中拉点选择题让你做做，之后的面试和笔试题无关，这里我遇到的笔试题是和第一轮技术面相关的，有点小套路。笔试题据博主的回忆，共有这么些题（都是简答题）：1.写出java中synchronized的使用方式。可以参考：Java多线程知识小抄集(一)2.Java中设置最大堆和最小堆内存的参数是什么？-Xmx-Xms3.volatile的作用？两点：内存可见性；防止指令重排序；4.写一个二分查找算法5.写一个你熟悉的设计模式，画出UML图，说出此模式的作用以及写出此模式的主要方法。6.一道设计题。（略）7.BeanFactory和ApplicationContext的区别。（Sping的容器可以分为两种类型：1.BeanFactory：（org.springframework.beans.factory.BeanFactory接口定义）是最简答的容器，提供了基本的DI支持。最常用的BeanFactory实现就是XmlBeanFactory类，它根据XML文件中的定义加载beans，该容器从XML文件读取配置元数据并用它去创建一个完全配置的系统或应用。2.ApplicationContext应用上下文：org.springframework.context.ApplicationContext）基于BeanFactory之上构建，并提供面向应用的服务。）（第4，5题在下面会解释）第一轮技术面主要根据简历以及笔试题进行论述。先将笔试题，首先是写出一个熟悉的设计模式，那当然写个单例咯，这个最简单嘛，主要是UML图也特别好画。详细可以参考设计模式：单例模式（Singleton）。博主写的是内部类的写法：这种写法是懒汉式线程安全的写法。面试官问到一个问题：为什么这种写法是线程安全的？那么这里就设计到一个JVM加载的知识：JVM内部机制可以保证在执行类构造器()方法的时候是线程安全的，详细可以参考博文：Java虚拟机类加载机制。。这里博主还特意说了虚拟机规范严格规定了有且只有5种情况（JDK7）必须对类进行初始化(执行类构造器()方法):遇到new,getstatic,putstatic,invokestatic这失调字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。生成这4条指令的最常见的Java代码场景是：使用new关键字实例化对象的时候、读取或设置一个类的静态字段（被final修饰、已在编译器把结果放入常量池的静态字段除外）的时候，以及调用一个类的静态方法的时候。使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。当使用jdk1.7动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getstatic,REF_putstatic,REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行初始化，则需要先出触发其初始化。尤其是第5点，是个特别偏冷的知识点，当你记住这个的时候，可以给面试官留下一个很好的印象。在后面的博文中会经常涉及这种冷知识，可以让你的面试过程添加几处亮点。下面就是要说明一下的二分查找法（首先确保被排序的数组有序），这里有两种写法：递归和非递归的写法。博主憋了一个递归的算法，不过最好还是用非递归的写法。二分查找法还是很容易的，关键这里引申出了变种算法，譬如：给你一个key，找出这个数组中最左边的key，或者最右边的key。当然还有其他变种算法，有兴趣的朋友可以自行查找相关资料。接下去就根据简历聊一聊项目和Java基础了。下面稍微列举一些问题：1.Memcached和Redis的区别?参考：Redis和Memcached的区别2.ActiveMQ的集群配置方式有哪些？（基于共享文件，基于数据库，基于Zookeeper等）3.Mybatis的一些知识点。（略）4.虚拟机的类加载机制。（加载-验证-准备-解析-初始化，详细可以参考

Java虚拟机类加载机制））5.内部类相关知识点。6.面向对象的设计原则？参考：面向对象的设计原则7.SpringAop的原理？动态代理。8.Spring常用的注解？9.NIO的相关。参考：攻破JAVANIO技术壁垒10.数据库优化相关。（博主基本不直接接触数据库，so遇到此类问题直接say:Idon’tknow.有兴趣的小伙伴可以自行查阅一些资料，譬如数据访问优化漏斗法则。）11.linux下查看文件有哪些方式？cattacheadtailmorelessnlvimvigvim技术面二面约好的10:00电面，11:30也没来，后来咨询了HR才说面试官出差去了。。。好吧，毕竟公司还在创业初期，管理上有疏忽可以理解。第二次约的2面同样是10:00，这次是10:27来的电话。额。。。这此的面试官好像是CTO，面的也比较深一些：1.谈谈你对HashMap的理解，怎么样去保证线程安全？博主对HashMap巴拉巴拉的一阵，可以参考：Java集合框架：HashMap.

.然后有三种方法可以保证hashMap的线程安全：换成HashTable；用synchronizedMap包装一下HashMap;换成ConcurrentHashMap。然后补了一句ConcurrentHashMap是比较推崇的，然后就被问了另一个问题：说一下ConcurrentHashMap的实现原理。然后解释了一下，最后问了个问题：用HashMap怎么去实现ConcurrentHashMap？当时想了一个，觉得不okay，想说第二个方案就被制止了。现在想想：把HashMap用Collections.synchronizedMap()包装一下替换屌Segment即可。（如果不知所云，请阅读一下ConcurrentHashMap的源码先~~）补充：这里还问了平常用了那些线程安全的队列，包括：ConcurrentLinkedQueue,ConcurrentLinkedDeque以及BlockingQueue系列。2.Java集合中有哪些常用的类？ArrayList的上级（父类或者接口）是什么，HashMap的上级又是什么？常用的类：Map系（HashMap,LinkedHashMap,TreeMap,WeakHashMap,EnumMap等）；List系（ArrayList,LinkedList,Vector,Stack等）；Set系（HashSet,LinkedHashSet,TreeSet）;工具类（Collections,Arrays）。这里如果说出来了，就必须对其十分了解，比如博主在另一家互联网公司W的面试过程中就被问到：你对java集合了解有多少？博主说：我看过所有集合的源码。然后就被问到：Collections.sort()里面的实现是什么排序算法？这个问题确实够冷门的！幸亏看过，不然就被打脸了。。（TimSort,加强型归并排序）ArrayListextendsAbstractListimplementsList,RandomAccess,Cloneable,Serializable.然后AbstractList又继承了AbstractCollection.然后List和AbstractCollection又都implements了Collection.HashMapextendsAbstractMapimplementsMap,Cloneable,Serializable.3.css导入方式？这个只要2周不没看过就会忘记。。博主当时就忘记了。。超简单的题，但是又是最不起眼的题，细节做的不够好。4.js中的ajax操作的方式？这个写的太多了，所以答起来很easy5.一句话概括NIO。博主说了一通，包括Reactor模式神马的。但是面试官说：你说的也很对，但是不是我想要的结果。斯巴达。。。6.设计数据库的一道题，比较简单，不赘述。7.常用的linux命令？（这个被用了好多次了）8.SpringIOC的原理？答案：基于反射9.数据库事务隔离级别？UncommitRead;CommitRead;RepeatedRead;Serializable.10.memcached与Redis的区别？技术三面之前说过博主对数据库相关的知识，除了会写SQL之外，其他的基本白痴。这次面试将近40mins，差不多被问了30mins的数据库的知识。比如：数据库优化；访问多少条数据，数据库的反应延迟是多少；表和视图的区别。当然还有一些其他的，譬如Spring中的注解在xml文件中怎么配置？面试过程中有两种问题比较难答：第一种，冷门知识，比如Colletions.sort()用到什么排序算法？第二种就是上面的这种特别简单，用过的都知道，但是像这种在Spring配置文件中配置完之后就基本不动了，所以特别容易遗忘。还有类似的比如：Spring中的自动装配怎么配置？HR面最后是HR面，这个最简单，只要言语不过激都是okay的，主要谈谈在原来公司主要做什么，为什么要换份新工作，期望薪资神马的。（ps:谈薪资是门艺术，同样两个人，面试打分也是一样的，但是薪资会谈和不会谈之间可能相差很多，这门艺术博主还在研究中，虽然有所收获，但是还是不敢出来卖弄，等博主把人事六大块之一的薪酬领悟之后再来探讨探讨。）总结博主总结几个心得，仅供参考：面试第一要素：不要紧张，如果你真是技术族，而且对技术有所痴迷，一聊起技术来根本不会紧张。面试第二要素：要对简历上的内容了如指掌，包括原理源码，如果略懂或者根本就是用了几天就再也没用过的技术就从简历上删掉吧，否则被面试官抓住不放就糟糕了。面试第三要素：学会引导面试，掌握主动权。这门技艺需要多去混点面筋，然后自我优化之后，一般都可以掌握。面试第四要素：做人要低调。面试你这个职位的人的技术肯定比这个职位高好几个level,不要觉得你回答了你非常熟悉的问题就高调起来，面试官随时可以挖出一堆坑来让你往里面跳。面试第五要素：要自信。有些面试官会对某些你回答完问题之后会补一句：你确定？这时候就要看你自己了，有可能面试官再提醒你，也有可能再诈你。归根结底还是要技术掌握的够硬，底气就足一些。面经-2H:\01--B.——个人文档\gxy\简历\2面经-3H:\01--B.——个人文档\gxy\简历\3面经-4H:\01--B.——个人文档\gxy\简历\4四、常用工具类、集合等的操作。面向对象和面向过程的区别面向过程：优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

缺点：没有面向对象易维护、易复用、易扩展面向对象

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护

缺点：性能比面向过程低Java的四个基本特性（抽象、封装、继承，多态）抽象：就是把现实生活中的某一类东西提取出来，用程序代码表示，我们通常叫做类或者接口。抽象包括两个方面：一个是数据抽象，一个是过程抽象。数据抽象也就是对象的属性。过程抽象是对象的行为特征。封装：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行封装隐藏。封装分为属性的封装和方法的封装。

继承：是对有着共同特性的多类事物，进行再抽象成一个类。这个类就是多类事物的父类。父类的意义在于抽取多类事物的共性。多态：允许不同类的对象对同一消息做出响应。方法的重载、类的覆盖正体现了多态。重载和重写的区别 重载：发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。

重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父类，访问修饰符大于等于父类；如果父类方法访问修饰符为private则子类中就不是重写。构造器Constructor是否可被override构造器不能被重写，不能用static修饰构造器，只能用publicprivateprotected这三个权限修饰符，且不能有返回语句。访问控制符public,protected,private,以及默认的区别private只有在本类中才能访问；public在任何地方都能访问；protected在同包内的类及包外的子类能访问；默认不写在同包内能访问。是否可以继承String类String类是final类故不可以继承，一切由final修饰过的都不能继承String和StringBuffer、StringBuilder的区别可变性：String类中使用字符数组保存字符串，privatefinalcharvalue[]，所以string对象是不可变的。StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，char[]value，这两种对象都是可变的。线程安全性：String中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。性能：每次对String类型进行改变的时候，都会生成一个新的String对象，然后将指针指向新的String对象。StringBuffer每次都会对StringBuffer对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用StirngBuilder相比使用StringBuffer仅能获得10%~15%左右的性能提升，但却要冒多线程不安全的风险。hashCode和equals方法的关系equals相等，hashcode必相等；hashcode相等，equals可能不相等。抽象类和接口的区别语法层次：抽象类和接口分别给出了不同的语法定义设计层次：抽象层次不同，抽象类是对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。跨域不同，抽象类所体现的是一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在”is-a”关系，即父类和派生类在概念本质上应该是相同的。对于接口则不然，并不要求接口的实现者和接口定义在概念本质上是一致的，仅仅是实现了接口定义的契约而已，”like-a”的关系。。设计层次不同，抽象类是自底向上抽象而来的，接口是自顶向下设计出来的。自动装箱与拆箱装箱：将基本类型用它们对应的引用类型包装起来；拆箱：将包装类型转换为基本数据类型；Java使用自动装箱和拆箱机制，节省了常用数值的内存开销和创建对象的开销，提高了效率，由编译器来完成，编译器会在编译期根据语法决定是否进行装箱和拆箱动作。什么是泛型、为什么要使用以及泛型擦除泛型，即“参数化类型”。创建集合时就指定集合元素的类型，该集合只能保存其指定类型的元素，避免使用强制类型转换。Java编译器生成的字节码是不包涵泛型信息的，泛型类型信息将在编译处理是被擦除，这个过程即类型擦除。泛型擦除可以简单的理解为将泛型java代码转换为普通java代码，只不过编译器更直接点，将泛型java代码直接转换成普通java字节码。类型擦除的主要过程如下：一.将所有的泛型参数用其最左边界（最顶级的父类型）类型替换。二.移除所有的类型参数。12.Java中的集合类及关系图List和Set继承自Collection接口。Set无序不允许元素重复。HashSet和TreeSet是两个主要的实现类。List有序且允许元素重复。ArrayList、LinkedList和Vector是三个主要的实现类。Map也属于集合系统，但和Collection接口没关系。Map是key对