电面整理

2019-04-13 16:23发布

站内文章 / 模拟电子
10451 0 1654
 今天中午接到阿里巴巴的电话面试，电面了将近一个小时左右。感觉自己发挥得并不好，好多基础的只是还是一知半解的， 虽然看过一些东西的源代码,但是，很多东西，也只是限看过而且，但是一到用的时候，或者被问到的时候， 却突然失忆……, 这里记录一下今天问到的问题。给自己长长记性。     ================================================     PS 凭着记忆来把他问的问题整理一下，并列出来，准备一一理解清楚     最开始的几个问题我现在已经记不清楚了， 估计当时紧张了。   ===================================================    你对Java的集合框架了解吗？ 能否说说常用的类？     说说Hashtable与HashMap的区别： 源代码级别的区别呢？    平时用过的List有哪些？ （除了ArrayList和LinkedList），ArrayList和LinkedList的区别？    ArrayList的特点，内部容器是如何扩充的？    Properties类的特点？ 线程安全?    ===============================================  平时使用过的框架有哪些？ (我提到了Struts2)    请说一下Struts2的初始化？和类的创建？(从源代码角度出发)    据你了解，除了反射还有什么方式可以动态的创建对象？（我提到了CGLIB…… 我以为他会接着问CGLIB,揪心中……，结果他没问）    请说一下Struts2 是如何把Action交给Spring托管的？它是单例的还是多例？ 你们页面的表单对象是多例还是单例？    请说一下你们业务层对象是单例还是多例的？    请说一下Struts2源代码中有哪些设计模式？   ======================================================    请说一下，你觉得你最熟悉的技术特点？ （我提到了并发编程）    请说一下线程安全出现的原因？     请说一下线程池的中断策略(4个)？ 各有什么特点？    请说一下Tomcat配置不同应用的不同端口如何配置？ 如何配置数据源？ 如何实现动态部署？    请说一下Java常用的优化？     你了解最新的Servlet规范吗？ 简单说一下？（我提到了推）    那请你说一下“推”是如何实现的？    线程安全下，StringBuffer与StringBuilder的区别？ 它们是如何扩充内部数组容量的？ （源代码）    请说一下Tomcat中的设计模式？（我提到观察者模式）    是否可以说说Java反射的相关优化机制？ （我说我不太清楚…… 他说没关系 - -！）    请说一些Mysql的常用优化策略？    因为我之前有提到过“推”，他可能对我的知识面比较感兴趣，要我说说平时都看些什么书，还了解一些什么其他的技术范畴。  （他首先提到SOA，我说有了解，并且是未来的趋势，还有提到云计算，我说有过一定了解，但是并未深究）    =====================================================  之后是几个职业方面的问题？    你觉得你的潜力？ 你在团队中的位置？ 你觉得跟团队中最好的还有哪些差距？你要花多少时间赶上他们？    你对阿里巴巴还有什么疑问吗？ （我很囧的问了，“阿里巴巴的牛人平时都跟你们有互动吗？-----本意是指培训，但是话没说清楚……”，囧了……）
PS，下面是时候对问题的整理，里面纯粹仅限于个人浅见，如果有错误，还希望各位能指点一二。 ==================================================================
  • 你对Java的集合框架了解吗？ 能否说说常用的类？ 
Java集合框架类图：


 
  我常用的类： HashMap,Hashtable,HashSet,ArrayList,Vector,LinkedList,Collections,Arrays;

  • 说说Hashtable与HashMap的区别(源代码级别)


       1.最明显的区别在于Hashtable 是同步的(每个方法都是synchronized)，而HashMap则不是.        2.HashMap继承至AbstractMap,Hashtable继承至Dictionary ,前者为Map的骨干， 其内部已经实现了Map所需           要做的大部分工作， 它的子类只需要实现它的少量方法即可具有Map的多项特性。而后者内部都为抽象方法，需要           它的实现类一一作自己的实现，且该类已过时         3.两者检测是否含有key时，hash算法不一致，HashMap内部需要将key的hash码重新计算一边再检测，而                    Hashtable则直接利用key本身的hash码来做验证。 HashMap:   Java代码 复制代码
  1. int hash = (key == null) ? 0 : hash(key.hashCode());   
  2. -----   
  3. static int hash(int h) {   
  4.         h ^= (h >>> 20) ^ (h >>> 12);   
  5.         return h ^ (h >>> 7) ^ (h >>> 4);   
  6.     }  
int hash = (key == null) ? 0 : hash(key.hashCode()); ----- static int hash(int h) { h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); }     Hashtable：   Java代码 复制代码
  1. int hash = key.hashCode();  
int hash = key.hashCode();     4.两者初始化容量大小不一致，HashMap内部为 16*0.75 , Hashtable 为 11*0.75 HashMap:   Java代码 复制代码
  1. static final int DEFAULT_INITIAL_CAPACITY = 16;   
  2. static final float DEFAULT_LOAD_FACTOR = 0.75f;   
  3. public HashMap() {   
  4.      this.loadFactor = DEFAULT_LOAD_FACTOR;   
  5.      threshold=(int)(DEFAULT_INITIAL_CAPACITY*DEFAULT_LOAD_FACTOR);   
  6.      table = new Entry[DEFAULT_INITIAL_CAPACITY];   
  7.      init();   
  8. }      
  9. ………………………………  
static final int DEFAULT_INITIAL_CAPACITY = 16; static final float DEFAULT_LOAD_FACTOR = 0.75f; public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; threshold=(int)(DEFAULT_INITIAL_CAPACITY*DEFAULT_LOAD_FACTOR); table = new Entry[DEFAULT_INITIAL_CAPACITY]; init(); } ………………………………    Hashtable:   Java代码 复制代码
  1. public Hashtable() {   
  2.     this(11, 0.75f);   
  3. }   
  4. -----   
  5.  public Hashtable(int initialCapacity, float loadFactor) {   
  6.         ..........   
  7.     this.loadFactor = loadFactor;   
  8.     table = new Entry[initialCapacity];   
  9.     threshold = (int)(initialCapacity * loadFactor);   
  10.     }     
public Hashtable() { this(11, 0.75f); } ----- public Hashtable(int initialCapacity, float loadFactor) { .......... this.loadFactor = loadFactor; table = new Entry[initialCapacity]; threshold = (int)(initialCapacity * loadFactor); }      其实后续的区别应该还有很多， 这里先列出4点。  

  • 平时除了ArrayList和LinkedList外，还用过的List有哪些？
    ArrayList和LinkedList的区别？
  事实上，我用过的List主要就是这2个， 另外用过Vector. ArrayList和LinkedList的区别：  
  1. 毫无疑问，第一点就是两者的内部数据结构不同， ArrayList内部元素容器是一个Object的数组，
    而LinkedList内部实际上一个链表的数据结构，其有一个内部类来表示链表.
    Java代码 复制代码
    1. (ArrayList)   
    2. private transient Object[] elementData;    
    3.   
    4. ………………………………………………………………………………   
    5.   
    6. (LinkedList)   
    7. private transient Entry header = new Entry(null, null, null);/链表头    
    8.   
    9. //内部链表类.   
    10. private static class Entry {   
    11.     E element; //数据元素   
    12.     Entry next; // 前驱   
    13.     Entry previous;//后驱   
    14.     Entry(E element, Entry next, Entry previous) {   
    15.         this.element = element;   
    16.         this.next = next;   
    17.         this.previous = previous;   
    18.     }   
    19. }     
    (ArrayList) private transient Object[] elementData; ……………………………………………………………………………… (LinkedList) private transient Entry header = new Entry(null, null, null);/链表头 //内部链表类. private static class Entry { E element; //数据元素 Entry next; // 前驱 Entry previous;//后驱 Entry(E element, Entry next, Entry previous) { this.element = element; this.next = next; this.previous = previous; } }  
  2. 两者的父类不同，也就决定了两者的存储形式不同。 ArrayList继承于 AbstractList,而LinkedList继承于AbstractSequentialList. 两者都实现了List的骨干结构，只是前者的访问形式趋向于 “随机访问”数据存储（如数组），后者趋向于 “连续访问”数据存储（如链接列表）

    Java代码 复制代码
    1. public class ArrayList extends AbstractList      
    2. ---------------------------------------------------------------------------------------   
    3. public class LinkedList extends AbstractSequentialList      
    public class ArrayList extends AbstractList --------------------------------------------------------------------------------------- public class LinkedList extends AbstractSequentialList  
  3. 再有就是两者的效率问题， ArrayList基于数组实现，所以毫无疑问可以直接用下标来索引，其索引数据快，插入元素设计到数组元素移动，或者数组扩充，所以插入元素要慢。LinkedList基于链表结构，插入元素只需要改变插入元素的前后项的指向即可，故插入数据要快，而索引元素需要向前向后遍历，所以索引元素要慢。

  • ArrayList的特点，内部容器是如何扩充的？
上一点谈到了ArrayList的特点，这里略，重点来看其内部容器的扩充： Java代码 复制代码
  1. public void ensureCapacity(int minCapacity) {   
  2.         modCount++;   
  3.         int oldCapacity = elementData.length;   
  4.         if (minCapacity > oldCapacity) {   
  5.             Object oldData[] = elementData;   
  6.              //这里扩充的大小为原大小的大概 60%   
  7.             int newCapacity = (oldCapacity * 3) / 2 + 1;   
  8.             if (newCapacity < minCapacity)   
  9.                 newCapacity = minCapacity;   
  10.             //创建一个指定大小的新数组来覆盖原数组   
  11.             elementData = Arrays.copyOf(elementData, newCapacity);   
  12.         }   
  13.     }     
public void ensureCapacity(int minCapacity) { modCount++; int oldCapacity = elementData.length; if (minCapacity > oldCapacity) { Object oldData[] = elementData; //这里扩充的大小为原大小的大概 60% int newCapacity = (oldCapacity * 3) / 2 + 1; if (newCapacity < minCapacity) newCapacity = minCapacity; //创建一个指定大小的新数组来覆盖原数组 elementData = Arrays.copyOf(elementData, newCapacity); } }  

  • Properties类的特点？ 线程安全吗? 
Properties 继承于Hashtable,,所以它是线程安全的. 其特点是: 它表示的是一个持久的属性集，它可以保存在流中或者从流中加载，属性列表的每一个键和它所对应的值都是一个“字符串” 其中，常用的方法是load()方法，从流中加载属性： Java代码 复制代码
  1. "FONT-WEIGHT: normal">public synchronized void load(InputStream inStream) throws IOException {   
  2.         // 将输入流转换成LineReader   
  3.         load0(new LineReader(inStream));   
  4.     }   
  5.   
  6.     private void load0(LineReader lr) throws IOException {   
  7.         char[] convtBuf = new char[1024];   
  8.         int limit;   
  9.         int keyLen;   
  10.         int valueStart;   
  11.         char c;   
  12.         boolean hasSep;   
  13.         boolean precedingBackslash;   
  14.         // 一行一行处理   
  15.         while ((limit = lr.readLine()) >= 0) {   
  16.             c = 0;   
  17.             keyLen = 0;   
  18.             valueStart = limit;   
  19.             hasSep = false;   
  20.             precedingBackslash = false;   
  21.             // 下面用2个循环来处理key,value   
  22.             while (keyLen < limit) {   
  23.                 c = lr.lineBuf[keyLen];   
  24.                 // need check if escaped.   
  25.                 if ((c == '=' || c == ':') && !precedingBackslash) {   
  26.                     valueStart = keyLen + 1;   
  27.                     hasSep = true;   
  28.                     break;   
  29.                 } else if ((c == ' ' || c == ' ' || c == 'f')   
  30.                         && !precedingBackslash) {   
  31.                     valueStart = keyLen + 1;   
  32.                     break;   
  33.                 }   
  34.                 if (c == '\') {   
  35.                     precedingBackslash = !precedingBackslash;   
  36.                 } else {   
  37.                     precedingBackslash = false;   
  38.                 }   
  39.                 keyLen++;   
  40.             }   
  41.   
  42.             while (valueStart < limit) {   
  43.                 c = lr.lineBuf[valueStart];   
  44.                 if (c != ' ' && c != ' ' && c != 'f') {   
  45.                     if (!hasSep && (c == '=' || c == ':')) {   
  46.                         hasSep = true;   
  47.                     } else {   
  48.                         break;   
  49.                     }   
  50.                 }   
  51.                 valueStart++;   
  52.             }   
  53.   
  54.             String key = loadConvert(lr.lineBuf, 0, keyLen, convtBuf);   
  55.             String value = loadConvert(lr.lineBuf, valueStart, limit   
  56.                     - valueStart, convtBuf);   
  57.             // 存入内部容器中，这里用的是Hashtable 内部的方法.   
  58.             put(key, value);   
  59.         }   
  60.     }  
public synchronized void load(InputStream inStream) throws IOException { // 将输入流转换成LineReader load0(new LineReader(inStream)); } private void load0(LineReader lr) throws IOException { char[] convtBuf = new char[1024]; int limit; int keyLen; int valueStart; char c; boolean hasSep; boolean precedingBackslash; // 一行一行处理 while ((limit = lr.readLine()) >= 0) { c = 0; keyLen = 0; valueStart = limit; hasSep = false; precedingBackslash = false; // 下面用2个循环来处理key,value while (keyLen < limit) { c = lr.lineBuf[keyLen]; // need check if escaped. if ((c == '=' || c == ':') && !precedingBackslash) { valueStart = keyLen + 1; hasSep = true; break; } else if ((c == ' ' || c == ' ' || c == 'f') && !precedingBackslash) { valueStart = keyLen + 1; break; } if (c == '\') { precedingBackslash = !precedingBackslash; } else { precedingBackslash = false; } keyLen++; } while (valueStart < limit) { c = lr.lineBuf[valueStart]; if (c != ' ' && c != ' ' && c != 'f') { if (!hasSep && (c == '=' || c == ':')) { hasSep = true; } else { break; } } valueStart++; } String key = loadConvert(lr.lineBuf, 0, keyLen, convtBuf); String value = loadConvert(lr.lineBuf, valueStart, limit - valueStart, convtBuf); // 存入内部容器中，这里用的是Hashtable 内部的方法. put(key, value); } }  LineReader类，是Properties内部的类： Java代码 复制代码
  1. "FONT-WEIGHT: normal">class LineReader {   
  2.         public LineReader(InputStream inStream) {   
  3.             this.inStream = inStream;   
  4.             inByteBuf = new byte[8192];   
  5.         }   
  6.   
  7.         public LineReader(Reader reader) {   
  8.             this.reader = reader;   
  9.             inCharBuf = new char[8192];   
  10.         }   
  11.   
  12.         byte[] inByteBuf;   
  13.         char[] inCharBuf;   
  14.         char[] lineBuf = new char[1024];   
  15.         int inLimit = 0;   
  16.         int inOff = 0;   
  17.         InputStream inStream;   
  18.         Reader reader;   
  19.   
  20.         /**  
  21.          * 读取一行  
  22.          *   
  23.          * @return  
  24.          * @throws IOException  
  25.          */  
  26.         int readLine() throws IOException {   
  27.             int len = 0;   
  28.             char c = 0;   
  29.             boolean skipWhiteSpace = true;// 空白   
  30.             boolean isCommentLine = false;// 注释   
  31.             boolean isNewLine = true;// 是否新行.   
  32.             boolean appendedLineBegin = false;// 加 至行开始   
  33.             boolean precedingBackslash = false;// 反斜杠   
  34.             boolean skipLF = false;   
  35.             while (true) {   
  36.                 if (inOff >= inLimit) {   
  37.                     // 从输入流中读取一定数量的字节并将其存储在缓冲区数组inCharBuf/inByteBuf中,这里区分字节流和字符流   
  38.                     inLimit = (inStream == null) ? reader.read(inCharBuf)   
  39.                             : inStream.read(inByteBuf);   
  40.                     inOff = 0;   
  41.                     // 读取到的为空.   
  42.                     if (inLimit <= 0) {   
  43.                         if (len == 0 || isCommentLine) {   
  44.                             return -1;   
  45.                         }   
  46.                         return len;   
  47.                     }   
  48.                 }   
  49.                 if (inStream != null) {   
  50.                     // 由于是字节流，需要使用ISO8859-1来解码   
  51.                     c = (char) (0xff & inByteBuf[inOff++]);   
  52.                 } else {   
  53.                     c = inCharBuf[inOff++];   
  54.                 }   
  55.   
  56.                 if (skipLF) {   
  57.                     skipLF = false;   
  58.                     if (c == ' ') {   
  59.                         continue;   
  60.                     }   
  61.                 }   
  62.                 if (skipWhiteSpace) {   
  63.                     if (c == ' ' || c == ' ' || c == 'f') {   
  64.                         continue;   
  65.                     }   
  66.                     if (!appendedLineBegin && (c == ' ' || c == ' ')) {   
  67.                         continue;   
  68.                     }   
  69.                     skipWhiteSpace = false;   
  70.                     appendedLineBegin = false;   
  71.                 }   
  72.                 if (isNewLine) {   
  73.                     isNewLine = false;   
  74.                     if (c == '#' || c == '!') {   
  75.                         // 注释行，忽略.   
  76.                         isCommentLine = true;   
  77.                         continue;   
  78.                     }   
  79.                 }   
  80.                 // 读取真正的属性内容   
  81.                 if (c != ' ' && c != ' ') {   
  82.                     // 这里类似于ArrayList内部的容量扩充，使用字符数组来保存读取的内容.   
  83.                     lineBuf[len++] = c;   
  84.                     if (len == lineBuf.length) {   
  85.                         int newLength = lineBuf.length * 2;   
  86.                         if (newLength < 0) {   
  87.                             newLength = Integer.MAX_VALUE;   
  88.                         }   
  89.                         char[] buf = new char[newLength];   
  90.                         System.arraycopy(lineBuf, 0, buf, 0, lineBuf.length);   
  91.                         lineBuf = buf;   
  92.                     }   
  93.                     if (c == '\') {   
  94.                         precedingBackslash = !precedingBackslash;   
  95.                     } else {   
  96.                         precedingBackslash = false;   
  97.                     }   
  98.                 } else {   
  99.                     // reached EOL 文件结束   
  100.                     if (isCommentLine || len == 0) {   
  101.                         isCommentLine = false;   
  102.                         isNewLine = true;   
  103.                         skipWhiteSpace = true;   
  104.                         len = 0;   
  105.                         continue;   
  106.                     }   
  107.                     if (inOff >= inLimit) {   
  108.                         inLimit = (inStream == null) ? reader.read(inCharBuf)   
  109.                                 : inStream.read(inByteBuf);   
  110.                         inOff = 0;   
  111.                         if (inLimit <= 0) {   
  112.                             return len;   
  113.                         }   
  114.                     }   
  115.                     if (precedingBackslash) {   
  116.                         len -= 1;   
  117.                         skipWhiteSpace = true;   
  118.                         appendedLineBegin = true;   
  119.                         precedingBackslash = false;   
  120.                         if (c == ' ') {   
  121.                             skipLF = true;   
  122.                         }   
  123.                     } else {   
  124.                         return len;   
  125.                     }   
  126.                 }   
  127.             }   
  128.         }   
  129.     }     
class LineReader { public LineReader(InputStream inStream) { this.inStream = inStream; inByteBuf = new byte[8192]; } public LineReader(Reader reader) { this.reader = reader; inCharBuf = new char[8192]; } byte[] inByteBuf; char[] inCharBuf; char[] lineBuf = new char[1024]; int inLimit = 0; int inOff = 0; InputStream inStream; Reader reader; /** * 读取一行 * * @return * @throws IOException */ int readLine() throws IOException { int len = 0; char c = 0; boolean skipWhiteSpace = true;// 空白 boolean isCommentLine = false;// 注释 boolean isNewLine = true;// 是否新行. boolean appendedLineBegin = false;// 加 至行开始 boolean precedingBackslash = false;// 反斜杠 boolean skipLF = false; while (true) { if (inOff >= inLimit) { // 从输入流中读取一定数量的字节并将其存储在缓冲区数组inCharBuf/inByteBuf中,这里区分字节流和字符流 inLimit = (inStream == null) ? reader.read(inCharBuf) : inStream.read(inByteBuf); inOff = 0; // 读取到的为空. if (inLimit <= 0) { if (len == 0 || isCommentLine) { return -1; } return len; } } if (inStream != null) { // 由于是字节流，需要使用ISO8859-1来解码 c = (char) (0xff & inByteBuf[inOff++]); } else { c = inCharBuf[inOff++]; } if (skipLF) { skipLF = false; if (c == ' ') { continue; } } if (skipWhiteSpace) { if (c == ' ' || c == ' ' || c == 'f') { continue; } if (!appendedLineBegin && (c == ' ' || c == ' ')) { continue; } skipWhiteSpace = false; appendedLineBegin = false; } if (isNewLine) { isNewLine = false; if (c == '#' || c == '!') { // 注释行，忽略. isCommentLine = true; continue; } } // 读取真正的属性内容 if (c != ' ' && c != ' ') { // 这里类似于ArrayList内部的容量扩充，使用字符数组来保存读取的内容. lineBuf[len++] = c; if (len == lineBuf.length) { int newLength = lineBuf.length * 2; if (newLength < 0) { newLength = Integer.MAX_VALUE; } char[] buf = new char[newLength]; System.arraycopy(lineBuf, 0, buf, 0, lineBuf.length); lineBuf = buf; } if (c == '\') { precedingBackslash = !precedingBackslash; } else { precedingBackslash = false; } } else { // reached EOL 文件结束 if (isCommentLine || len == 0) { isCommentLine = false; isNewLine = true; skipWhiteSpace = true; len = 0; continue; } if (inOff >= inLimit) { inLimit = (inStream == null) ? reader.read(inCharBuf) : inStream.read(inByteBuf); inOff = 0; if (inLimit <= 0) { return len; } } if (precedingBackslash) { len -= 1; skipWhiteSpace = true; appendedLineBegin = true; precedingBackslash = false; if (c == ' ') { skipLF = true; } } else { return len; } } } } }  这里特别的是，实际上，Properties从流中加载属性集合，是通过将流中的字符或者字节分成一行行来处理的。
  • 请说一下Struts2的初始化？和类的创建？(从源代码角度出发)
（我当时回答这个问题的思路我想应该对了， 我说是通过反射加配置文件来做的） 由于这个问题研究起来可以另外写一篇专门的模块，这里只列出相对简单的流程，后续会希望有时间整理出具体的细节: 首先，Struts2是基于Xwork框架的，如果你有仔细看过Xwork的文档，你会发现，它的初始化过程基于以下几个类： Configuring XWork2 centers around the following classes:- 1. ConfigurationManager 2. ConfigurationProvider 3. Configuration 而在ConfigurationProvider的实现类XmlConfigurationProvider 的内部，你可以看到下面的代码 Java代码 复制代码
  1. "FONT-WEIGHT: normal"> public XmlConfigurationProvider() {   
  2.         this("xwork.xml", true);   
  3. }  
public XmlConfigurationProvider() { this("xwork.xml", true); }  同样的，Struts2的初始化也是这样的一个类，只不过它继承于Xwork原有的类，并针对Struts2做了一些特别的定制。 Java代码 复制代码
  1. "FONT-WEIGHT: normal">public class StrutsXmlConfigurationProvider    
  2.    extends XmlConfigurationProvider {   
  3.     

热门文章