java中级工程师面试

1、list如何转换为map。

1、创建一个POJO

package test;public class User {private int id; private String name;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public User(int id, String name) {super();this.id = id;this.name = name;}@Overridepublic String toString() {return "User [id=" + id + ", name=" + name + "]";}}

2、创建添加进list集合

        HashMap<Integer,User> map = new HashMap<>();List<User> list = new ArrayList<User>();list.add(new User(1, "张三"));list.add(new User(2, "李四"));list.add(new User(3, "王五"));Iterator<User> iterator = list.iterator();迭代listwhile (iterator.hasNext()) {User u = iterator.next();map.put(u.getId(), u);}
//遍历map的方式//1、根据map.keySet();Set<Integer> keySet = map.keySet();for (Integer integer : keySet) {User u = map.get(integer);System.out.println(u);}//2、根据map.values().Collection<User> values = map.values();for (User user : values) {System.out.println(user);}//3、推荐 使用for(Entry<Integer, User> entry:  map.entrySet()) {System.out.println(entry.getKey()+" -"+entry.getValue());}//4、map.entrySet().iterator()Iterator<Entry<Integer, User>> it = map.entrySet().iterator();while(it.hasNext()) {Entry<Integer, User> entry = it.next();System.out.println(entry.getValue());}

2、Java中会存在内存泄漏吗，请简单描述？

==存在。==虽然Java有垃圾回收器，但是依然存在内存泄漏。

首先，什么是内存泄漏？

内存泄漏的定义：对象不再被应用程序使用，但是垃圾回收器却不能移除它们，因为它们正在被引用。

为什么会发生内存泄漏？

对象A引用了对象B。A的生命周期（t1—t4）要比B的生命周期（t2—t3）长很多。当B不再用于应用中时，A仍然持有对它的引用。在这种方式下，垃圾回收器就不能将B从内存中移除。这将可能导致出现内存不足的问题，因为如果A对更多的对象做同样的事情，那么内存中将会有很多无法被回收的对象，这将极度耗费内存空间。

如何阻止内存泄漏？

（1）注意集合类，例如HashMap，ArrayList，等等。因为它们是内存泄漏经常发生的地方。当它们被声明为静态时，它们的生命周期就同应用程序的生命周期一般长。

（2）注意事件监听器和回调，如果一个监听器已经注册，但是当这个类不再被使用时却未被注销，就会发生内存泄漏。

（3）“如果一个类管理它自己的内存，程序员应该对内存泄漏保持警惕。”[1] 很多时候当一个对象的成员变量指向其他对象时，不再使用时需要被置空。

3、什么是ORM？

==对象-关系映射（Object/Relation Mapping，简称ORM）==

是一种为了解决==面向对象==与==关系数据库==存在的互不匹配的现象的技术。

4、hibernate如何实现分页查询？

Query query = session.createQuery(hql);
query.setFirstResult(offset);
query.setMaxResults(length);

5、锁机制有什么用？简述悲观锁乐观锁

在数据库的锁机制中介绍过，数据库管理系统（DBMS）中的并发控制的任务是确保在多个事务同时存取数据库中同一数据时不破坏事务的隔离性和统一性以及数据库的统一性。

乐观并发控制(乐观锁)和悲观并发控制（悲观锁）是并发控制主要采用的技术手段。

无论是悲观锁还是乐观锁，都是人们定义出来的概念，可以认为是一种思想。其实不仅仅是数据库系统中有乐观锁和悲观锁的概念，像memcache、hibernate、tair等都有类似的概念。

针对于不同的业务场景，应该选用不同的并发控制方式。所以，不要把乐观并发控制和悲观并发控制狭义的理解为DBMS中的概念，更不要把他们和数据中提供的锁机制（行锁、表锁、排他锁、共享锁）混为一谈。其实，在DBMS中，悲观锁正是利用数据库本身提供的锁机制来实现的。

下面来分别学习一下悲观锁和乐观锁。

悲观锁

在关系数据库管理系统里，悲观并发控制（又名“悲观锁”，Pessimistic Concurrency Control，缩写“PCC”）是一种并发控制的方法。它可以阻止一个事务以影响其他用户的方式来修改数据。如果一个事务执行的操作都某行数据应用了锁，那只有当这个事务把锁释放，其他事务才能够执行与该锁冲突的操作。悲观并发控制主要用于数据争用激烈的环境，以及发生并发冲突时使用锁保护数据的成本要低于回滚事务的成本的环境中。

悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度(悲观)，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）

在数据库中，悲观锁的流程如下：

在对任意记录进行修改前，先尝试为该记录加上排他锁（exclusive locking）。

如果加锁失败，说明该记录正在被修改，那么当前查询可能要等待或者抛出异常。具体响应方式由开发者根据实际需要决定。

如果成功加锁，那么就可以对记录做修改，事务完成后就会解锁了。

其间如果有其他对该记录做修改或加排他锁的操作，都会等待我们解锁或直接抛出异常。

MySQL InnoDB中使用悲观锁

要使用悲观锁，我们必须关闭mysql数据库的自动提交属性，因为MySQL默认使用autocommit模式，也就是说，当你执行一个更新操作后，MySQL会立刻将结果进行提交。 set autocommit=0;

//0.开始事务
begin;/begin work;/start transaction; (三者选一就可以)
//1.查询出商品信息
select status from t_goods where id=1 for update;
//2.根据商品信息生成订单
insert into t_orders (id,goods_id) values (null,1);
//3.修改商品status为2
update t_goods set status=2;
//4.提交事务
commit;/commit work;

上面的查询语句中，我们使用了 select…for update 的方式，这样就通过开启排他锁的方式实现了悲观锁。此时在t_goods表中，id为1的那条数据就被我们锁定了，其它的事务必须等本次事务提交之后才能执行。这样我们可以保证当前的数据不会被其它事务修改。

上面我们提到，使用 select…for update 会把数据给锁住，不过我们需要注意一些锁的级别，MySQL InnoDB默认行级锁。行级锁都是基于索引的，如果一条SQL语句用不到索引是不会使用行级锁的，会使用表级锁把整张表锁住，这点需要注意。

优点与不足

悲观并发控制实际上是“先取锁再访问”的保守策略，为数据处理的安全提供了保证。但是在效率方面，处理加锁的机制会让数据库产生额外的开销，还有增加产生死锁的机会；另外，在只读型事务处理中由于不会产生冲突，也没必要使用锁，这样做只能增加系统负载；还有会降低了并行性，一个事务如果锁定了某行数据，其他事务就必须等待该事务处理完才可以处理那行数

乐观锁

在关系数据库管理系统里，乐观并发控制（又名“乐观锁”，Optimistic Concurrency Control，缩写“OCC”）是一种并发控制的方法。它假设多用户并发的事务在处理时不会彼此互相影响，各事务能够在不产生锁的情况下处理各自影响的那部分数据。在提交数据更新之前，每个事务会先检查在该事务读取数据后，有没有其他事务又修改了该数据。如果其他事务有更新的话，正在提交的事务会进行回滚。乐观事务控制最早是由孔祥重（H.T.Kung）教授提出。

乐观锁（ Optimistic Locking ）相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。

相对于悲观锁，在对数据库进行处理的时候，乐观锁并不会使用数据库提供的锁机制。一般的实现乐观锁的方式就是记录数据版本。

数据版本,为数据增加的一个版本标识。当读取数据时，将版本标识的值一同读出，数据每更新一次，同时对版本标识进行更新。当我们提交更新的时候，判断数据库表对应记录的当前版本信息与第一次取出来的版本标识进行比对，如果数据库表当前版本号与第一次取出来的版本标识值相等，则予以更新，否则认为是过期数据。

实现数据版本有两种方式，第一种是使用版本号，第二种是使用时间戳。

使用版本号实现乐观锁

使用版本号时，可以在数据初始化时指定一个版本号，每次对数据的更新操作都对版本号执行+1操作。并判断当前版本号是不是该数据的最新的版本号。

1.查询出商品信息
select (status,status,version) from t_goods where id=#{id}
2.根据商品信息生成订单
3.修改商品status为2
update t_goods
set status=2,version=version+1
where id=#{id} and version=#{version};

优点与不足

乐观并发控制相信事务之间的数据竞争(data race)的概率是比较小的，因此尽可能直接做下去，直到提交的时候才去锁定，所以不会产生任何锁和死锁。但如果直接简单这么做，还是有可能会遇到不可预期的结果，例如两个事务都读取了数据库的某一行，经过修改以后写回数据库，这时就遇到了问题。

6、String中的Bean的作用域有哪些？

singleton prototype request session global,

7、Spring的注入方法

1、Setter注入

2、构造器注入

3、注解注入（多种名称）

8、java线程中run和start方法的区别（转载）

创建一个线程 Thread t1 = new Thread()

t1.run(); 只是调用了一个普通方法，并没有启动另一个线程，程序还是会按照顺序执行相应的代码。

t1.start(); 则表示，重新开启一个线程，不必等待其他线程运行完，只要得到cup就可以运行该线程。

比如下边的一个例子：

<pre name="code" class="java">public class demo1 {public static void main(String args[]) {  Thread t = new Thread() {  public void run() {  pong(); }  };  t.start();  //        t.run();System.out.print("ping");  }  static void pong() {  System.out.print("pong");  }
}

结果是：

pingpong

public class demo2 {public static void main(String args[]) {  Thread t = new Thread() {  public void run() {  pong();  }  };  //       t.start();  t.run();System.out.print("ping");  }  static void pong() {  System.out.print("pong");  }}

结果是：

pongping

9、什么是基于java的Spring注解配置？给一些注解的例子

10、我们如何对一组对象进行排序

11、你可以把list传递给一个接受LIst参数的方法吗？

12、SpringMvc用什么对象从后台向前台传值？

13、如何把20170101125959转换为日期格式如：2017-01-01 12:59:59

14、查询同时学过课程1和课程2的同学的学号、姓名。

表结构

student(sno,sname,sage,ssex) 学生表
course(cno,cname,tno)课程表