2017年5月面试总结

「爱情、让人受尽委屈。」 2022-06-15 01:13 264阅读 0赞

# 1. 渔夫分鱼算法 #

A，B，C，D，E五个渔夫夜间合伙捕鱼，凌晨都疲惫不堪，各自在草丛中熟睡。第二天清晨A先醒来，他把鱼均分五份，把多余的一条扔回湖中，便拿了自己的一份回家了，B醒来后，也把鱼均分五份，把多余的一条扔回湖中，便拿了自己的一份回家了，C,D,E也按同样方法分鱼。问5人至少捕到多少条鱼？  
面试官让五分钟写出来，我是不行了，回来后因减1的问题差了5条，害得我花了近二十分钟。像这种算法，稍有点儿能力的都能写出来，只是时间问题，干嘛非要较那个真儿。

public static void main(String[] args) {
    
            for (int num = 6;; num++) {
                int t = num;
                // 每一个渔夫起来分鱼都必须符合：分成5份多一条
                for (int j = 1; j <= 5; j++) {
                    if (t % 5 == 1) {   
                        // 下一个渔夫起来看到总的条数
                        t = t-1- ((t - 1) / 5);
                    }else{
                        t =0;
                    }
                }
                if(t!=0){
                    System.out.println(num);
                    break;
                }
            }       
        }

# 2.动态代理模式 #

1.  动态代理涉及到反射知识，这方面欠缺的可参考：  
    [http://www.cnblogs.com/ktlshy/p/4716838.html][http_www.cnblogs.com_ktlshy_p_4716838.html]
2.  动态理详解参考：  
    实例：[http://www.cnblogs.com/xiaoluo501395377/p/3383130.html][http_www.cnblogs.com_xiaoluo501395377_p_3383130.html]  
    详解：[https://www.ibm.com/developerworks/cn/java/j-lo-proxy1/index.html][https_www.ibm.com_developerworks_cn_java_j-lo-proxy1_index.html]
3.  动态代理时，我有一个疑问就是，invoke方法什么时候被调用的，参考：  
    [http://blog.csdn.net/zcc\_0015/article/details/22695647][http_blog.csdn.net_zcc_0015_article_details_22695647]  
    由于动态生成的代理类也实现了被代理对象的接口，然后在实现代理接口方法中会调用invoke方法。所以通过动态代理类调用被代理对象的某全方法时，就能调用到invoke方法了

# 3.如何在mysql查找效率慢的SQL语句 #

参考：[http://www.cnblogs.com/kimi9py/p/5735043.html][http_www.cnblogs.com_kimi9py_p_5735043.html]  
1. 首先查看是否开启慢查询：  
SHOW VARIABLES LIKE ‘%quer%’；  
![这里写图片描述][SouthEast]  
1. 开启慢查询：slow\_query\_log  
`set GLOBAL slow_query_log= on;`  
这个参数设置为ON，可以捕获执行时间超过一定数值的SQL语句。  
2. 设置慢查询时间：long\_query\_time  
`set GLOBAL long_query_time= 2;`  
当SQL语句执行时间超过此数值时，就会被记录到日志中，建议设置为1或者更短。  
3. 指定慢查询日志记录位置：slow\_query\_log\_file  
`set GLOBAL slow_query_log_file= 2;`  
4. 捕获所有未使用索引的SQL语句 log\_queries\_not\_using\_indexes  
`set GLOBAL log_queries_not_using_indexes= on;`

# 4. 字符串排序 #

有一个字符串str=”235568523134”;请写程序将字符串str进行升序排序。（请使用一切可以使用的JDK API，但仅限JDK API）

String str = "235568523134";
    char[] arr = str.toCharArray();
    // 升序排序
    Arrays.sort(arr);
    // 处理结果
    StringBuffer sbs = new StringBuffer();
    for(char s :arr){
        sbs.append(s);
    }
    
    System.out.println("排序后结果是："+sbs.toString());

# 5.spring事务 #

请简单介绍Spring支持的常用数据库事务传播属性和事务隔离级别，及对它们的使用场景？

<table> 
 <thead> 
  <tr> 
   <th>事务传播行为类型</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>propagation_required(常用)</td> 
   <td>如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是 最常见的选择。</td> 
  </tr> 
  <tr> 
   <td>propagation_supports</td> 
   <td>支持当前事务，如果当前没有事务，就以非事务方式执行。</td> 
  </tr> 
  <tr> 
   <td>propagation_mandatory</td> 
   <td>使用当前的事务，如果当前没有事务，就抛出异常。</td> 
  </tr> 
  <tr> 
   <td>propagation_requires_new</td> 
   <td>新建事务，如果当前存在事务，把当前事务挂起。</td> 
  </tr> 
  <tr> 
   <td>propagation_not_supported</td> 
   <td>以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。</td> 
  </tr> 
  <tr> 
   <td>propagation_never</td> 
   <td>以非事务方式执行，如果当前存在事务，则抛出异常。</td> 
  </tr> 
  <tr> 
   <td>propagation_nested</td> 
   <td>如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与 propagation_required类似的操作。此时， 底层的数据源必须基于 JDBC 3.0 ，并且实现者需要支持保存点事务机制。</td> 
  </tr> 
 </tbody> 
</table>

参考：  
[http://jaeger.blog.51cto.com/11064196/1761660][http_jaeger.blog.51cto.com_11064196_1761660]  
[http://blog.csdn.net/willfcareer/article/details/5695530][http_blog.csdn.net_willfcareer_article_details_5695530]

**Spring事务的隔离级别**

<table> 
 <thead> 
  <tr> 
   <th>隔离级别</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>DEFAULT</td> 
   <td>这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.</td> 
  </tr> 
  <tr> 
   <td>READ_UNCOMMITTED</td> 
   <td>这是事务最低的隔离级别，它充许令外一个事务可以看到这个事务未提交的数据。 这种隔离级别会产生脏读，不可重复读和幻像读。</td> 
  </tr> 
  <tr> 
   <td>READ_COMMITTED</td> 
   <td>保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据</td> 
  </tr> 
  <tr> 
   <td>REPEATABLE_READ</td> 
   <td>这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。</td> 
  </tr> 
  <tr> 
   <td>SERIALIZABLE</td> 
   <td>这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻像读。</td> 
  </tr> 
 </tbody> 
</table>

什么是脏数据，脏读，不可重复读，幻读？  
**脏读**: 指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据， 那么另外一个事务读到的这个数据是脏数据，依据脏数据所做的操作可能是不正确的。  
**不可重复读**: 指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的数据 可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。

**幻读**: 指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改**涉及到表中的全部数据行**。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。

# 3.springMVC底层实现 #

# 4. mybatis底层实现原理 #

# 5.mybatis里的“\#”与“$”的区别 #

# 6.描述mybatis里的resultMap #

[http_www.cnblogs.com_ktlshy_p_4716838.html]: http://www.cnblogs.com/ktlshy/p/4716838.html
[http_www.cnblogs.com_xiaoluo501395377_p_3383130.html]: http://www.cnblogs.com/xiaoluo501395377/p/3383130.html
[https_www.ibm.com_developerworks_cn_java_j-lo-proxy1_index.html]: https://www.ibm.com/developerworks/cn/java/j-lo-proxy1/index.html
[http_blog.csdn.net_zcc_0015_article_details_22695647]: http://blog.csdn.net/zcc_0015/article/details/22695647
[http_www.cnblogs.com_kimi9py_p_5735043.html]: http://www.cnblogs.com/kimi9py/p/5735043.html
[SouthEast]: /images/20220615/296cae8f327f4297be4b78cfa162846e.png
[http_jaeger.blog.51cto.com_11064196_1761660]: http://jaeger.blog.51cto.com/11064196/1761660
[http_blog.csdn.net_willfcareer_article_details_5695530]: http://blog.csdn.net/willfcareer/article/details/5695530