今天面试题总结

一、final，finally，finalize的区别

1、性质不一样

（1）final为关键字；

（2）finalize()为方法；

（3）finally为为区块标志，用于try语句中；

2、做用

（1）final为用于标识常量的关键字，final标识的关键字存储在常量池中（在这里final常量的具体用法将在下面进行介绍）；

（2）finalize()方法在Object中进行了定义，用于在对象“消失”时，由JVM进行调用用于对对象进行垃圾回收，相似于C++中的析构函数；用户自定义时，用于释放对象占用的资源（好比进行I/0操做）；

（3）finally{}用于标识代码块，与try{}进行配合，不论try中的代码执行完或没有执行完（这里指有异常），该代码块之中的程序一定会进行；

3、final详解

1定义变量

1.1  final定义基本类型变量时，要求变量初始化必须在声明时或者构造函数中，不能用于其它地方。该关键字定义的常量，除了初始化阶段，不能更改常量的值。

1.2  final定义对象的引用，该引用的初始化与定义常量时的要求一致；该关键字定义的对象内容能够改变，可是引用指向的地址不能改变；

2定义参数

若是传入该参数定义的变量时，方法不能对该参数内容进行修改（错误），与定义变量的修改规则相同；java方法中传递基本类型时是传值的，java方法对于对象的传递是传参的；<归根结底，java中方法的传递是依靠传递“副本”：对于基本类型，首先创建一个Copy，并将传入的值赋值给Copy，而后对Copy进行操做；对于对象类型，首先创建一个引用Copy，并将传入的对象引用赋值给Copy>

好比：method（final int test）；

有些书上说，这里final定义参数，尤为是对象的参数颇有做用，不能在方法内对于对象的内容进行改变，这样的说法是错误的！原来我也认为这样有些函数式编程的特色，不能对于对象的内容进行修改该，这里依旧能够对对象的内容进行修改。

？？定义该参数有什么用？？

String天生就是final类型的！

3定义方法

（1）使用final关键字定义的方法，不能被子类继承；

（2）容许编译器将全部对此方法的调用转化为inline（行内）行为，便可以将此方法直接复制在调用处，而不是进行例行的方法调用（保存断点、压栈），这样会使程序的效率升高。可是---------若是过多的话，这样会形成代码膨胀，反而会影响效率，因此该方法要慎用。。

4定义类

一个任何final类没法被任何人继承，这也就意味着此类在一个继承树中是一个叶子类，而且此类被认为是很完美的，不须要进行任何修改（总之是不推荐使用）

二、 有return的状况下try catch finally的执行顺序

结论：

一、无论有木有出现异常，finally块中代码都会执行；
二、当try和catch中有return时，finally仍然会执行；
三、finally是在return后面的表达式运算后执行的（此时并无返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是以前保存的值），因此函数返回值是在finally执行前肯定的；
四、finally中最好不要包含return，不然程序会提早退出，返回值不是try或catch中保存的返回值。
举例：
状况1：try{} catch(){}finally{} return;
            显然程序按顺序执行。
状况2:try{ return; }catch(){} finally{} return;
          程序执行try块中return以前（包括return语句中的表达式运算）代码；
         再执行finally块，最后执行try中return;
         finally块以后的语句return，由于程序在try中已经return因此再也不执行。
状况3:try{ } catch(){return;} finally{} return;
         程序先执行try，若是遇到异常执行catch块，
         有异常：则执行catch中return以前（包括return语句中的表达式运算）代码，再执行finally语句中所有代码，
                     最后执行catch块中return. finally以后也就是4处的代码再也不执行。
         无异常：执行完try再finally再return.
状况4:try{ return; }catch(){} finally{return;}
          程序执行try块中return以前（包括return语句中的表达式运算）代码；
          再执行finally块，由于finally块中有return因此提早退出。
状况5:try{} catch(){return;}finally{return;}
          程序执行catch块中return以前（包括return语句中的表达式运算）代码；
          再执行finally块，由于finally块中有return因此提早退出。
状况6:try{ return;}catch(){return;} finally{return;}
          程序执行try块中return以前（包括return语句中的表达式运算）代码；
          有异常：执行catch块中return以前（包括return语句中的表达式运算）代码；
                       则再执行finally块，由于finally块中有return因此提早退出。
          无异常：则再执行finally块，由于finally块中有return因此提早退出。

最终结论：任何执行try 或者catch中的return语句以前，都会先执行finally语句，若是finally存在的话。
                  若是finally中有return语句，那么程序就return了，因此finally中的return是必定会被return的，
                  编译器把finally中的return实现为一个warning。

下面是个测试程序 public class FinallyTest { public static void main(String[] args) { System.out.println(new FinallyTest().test());; } static int test() { int x = 1; try { x++; return x; } finally { ++x; } } } 结果是2。

分析：

在try语句中，在执行return语句时，要返回的结果已经准备好了，就在此时，程序转到finally执行了。 在转去以前，try中先把要返回的结果存放到不一样于x的局部变量中去，执行完finally以后，在从中取出返回结果， 所以，即便finally中对变量x进行了改变，可是不会影响返回结果。 它应该使用栈保存返回值。

三、单链表查找倒数第k个节点

题目：输入一个单向链表，输出该链表中倒数第k个结点。链表的倒数第0个结点为链表的尾指针。

分析：为了获得倒数第k个结点，很天然的想法是先走到链表的尾端，再从尾端回溯k步。但是输入的是单向链表，只有从前日后的指针而没有从后往前的指针。所以咱们须要打开咱们的思路。既然不能从尾结点开始遍历这个链表，咱们仍是把思路回到头结点上来。假设整个链表有n个结点，那么倒数第k个结点是从头结点开始的第n-k-1个结点（从0开始计数）。若是咱们可以获得链表中结点的个数n，那咱们只要从头结点开始日后走n-k-1步就能够了。如何获得结点数n？这个不难，只须要从头开始遍历链表，每通过一个结点，计数器加一就好了。这种思路的时间复杂度是O(n)，但须要遍历链表两次。第一次获得链表中结点个数n，第二次获得从头结点开始的第n­-k-1个结点即倒数第k个结点。如 果链表的结点数很少，这是一种很好的方法。但若是输入的链表的结点个数不少，有可能不能一次性把整个链表都从硬盘读入物理内存，那么遍历两遍意味着一个结 点须要两次从硬盘读入到物理内存。咱们知道把数据从硬盘读入到内存是很是耗时间的操做。咱们能不能把链表遍历的次数减小到1？若是能够，将能有效地提升代码执行的时间效率。若是咱们在遍历时维持两个指针，第一个指针从链表的头指针开始遍历，在第k-1步以前，第二个指针保持不动；在第k-1步开始，第二个指针也开始从链表的头指针开始遍历。因为两个指针的距离保持在k-1，当第一个（走在前面的）指针到达链表的尾结点时，第二个指针（走在后面的）指针正好是倒数第k个结点。这种思路只须要遍历链表一次。对于很长的链表，只须要把每一个结点从硬盘导入到内存一次。所以这一方法的时间效率前面的方法要高。

 

#include <iostream> #include <map> using  namespace  std; typedef  struct  ListNode{      int  m_nkey;      ListNode *m_pnext; } ListNode,*Node; int  main() {      int  n,k;      cout<< "The length of the list: " <<endl;      cin>>n;      cout<< "Which one to select(from tail): " <<endl;      cin>>k;      Node head,tmp,last;      for ( int  i=n;i>=1;i--)      {          tmp= new  ListNode();          tmp->m_nkey=i;          if (i==n)          head=tmp;          else          last->m_pnext=tmp;      tmp->m_pnext=NULL;      last=tmp;      }      Node p=head;      Node q=head;      int  i=1;      while (p!=NULL)      {          if (i<=k)          {              i++;              p=p->m_pnext;          }          else          {              p=p->m_pnext;              q=q->m_pnext;          }      }      cout<< "The data is: " <<q->m_nkey<<endl; }

四、如何实现大型系统的高并发性

高并发高负载的大型网站系统架构:http://developer.51cto.com/art/200906/129475.htm

高性能高并发服务器架构:http://www.doc88.com/p-5820457828.html