Java面试题(基础方面).doc

《Java面试题(基础方面).doc》由会员分享，可在线阅读，更多相关《Java面试题(基础方面).doc（74页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、Java基础方面: 1、 作用域public,private,protected,以及不写时的区别(来表示是否有权限)答：区别如下：作用域 当前类 同一package 子孙类 其他packagepublic protected friendly private 不写时默认为friendly2、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)答： 3、Static Nested Class 和 Inner Class的不同答4、&和&的区别答：2（0010） & 3（0011） 5、S

2、tring s = new String(xyz);创建了几个String Object答：6、Math.round(11.5)等於多少? Math.round(-11.5)等於多少答: 7、在Java中使用Hibernate来对数据进行批量处理的话。 向数据库插入100 000条数据，用Hibernate可能像这样：答： 8、数组有没有length()这个方法? String有没有length()这个方法答：9、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型答： 10、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用=还是equ

3、als()? 它们有何区别答： 11、xml有哪些解析技术?区别是什么?答：12、用jdom解析xml文件时如何解决中文问题?如何解析?答： 13、abstract class和interface有什么区别答：14、Hibernate中关于get()和load()方法检索的区别答： 15、Hibernate中的update()和saveOrUpdate()的区别答：16、一个hibernate对象有几种状态答：17、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递答： 18、ArrayList和Vector的区别,Hash

4、Map和Hashtable的区别答：19、GC是什么?为什么要有GC答：20、STRING与STRINGBUFFER的区别。 答：21、谈谈final, finally, finalize的区别答：21、heap和stack有什么区别答：22、你所知道的集合类都有哪些？主要方法？答：23、描述一下JVM加载class文件的原理机制?答：24、java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？答：25、当执行Session的load()方法时，Hibernate并不会访问数据库，而是仅仅返回代理类实例答：26、java中实现多态的机制是什么？答：27

5、、垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收答：28、List、Map、Set三个接口，存取元素时，各有什么特点？答：29、说出一些常用的类，包，接口，请各举5个答：30、Ibatis和Hibernate有什么区别？31、Session和cookie的区别在Hibernate应用中如何处理批量更新和批量删除批量更新是指在一个事务中更新大批量数据，批量删除是指在一个事务中删除大批量数据。以下程序直接通过Hibernate API批量更新CUSTOMERS表中年龄大于零的所有记录的AGE字段：tx = session.beginTransacti

6、on();Iterator customers=session.find(from Customer c where c.age0).iterator();while(customers.hasNext()Customer customer=(Customer)customers.next();customer.setAge(customer.getAge()+1); mit();session.close();如果CUSTOMERS表中有1万条年龄大于零的记录，那么Session的find()方法会一下子加载1万个Customer对象到内存。当执行mit()方法时，会清理缓存，Hiberna

7、te执行1万条更新CUSTOMERS表的update语句：update CUSTOMERS set AGE=? . where ID=i;update CUSTOMERS set AGE=? . where ID=j;update CUSTOMERS set AGE=? . where ID=k;以上批量更新方式有两个缺点：(1) 占用大量内存，必须把1万个Customer对象先加载到内存，然后一一更新它们。(2) 执行的update语句的数目太多，每个update语句只能更新一个Customer对象，必须通过1万条update语句才能更新一万个Customer对象，频繁的访问数据库，会大大降

8、低应用的性能。为了迅速释放1万个Customer对象占用的内存，可以在更新每个Customer对象后，就调用Session的evict()方法立即释放它的内存：tx = session.beginTransaction();Iterator customers=session.find(from Customer c where c.age0).iterator();while(customers.hasNext()Customer customer=(Customer)customers.next();customer.setAge(customer.getAge()+1);session.

9、flush();session.evict(customer); mit();session.close();在以上程序中，修改了一个Customer对象的age属性后，就立即调用Session的flush()方法和evict()方法，flush()方法使Hibernate立刻根据这个Customer对象的状态变化同步更新数据库，从而立即执行相关的update语句；evict()方法用于把这个Customer对象从缓存中清除出去，从而及时释放它占用的内存。但evict()方法只能稍微提高批量操作的性能，因为不管有没有使用evict()方法，Hibernate都必须执行1万条update语句，才

10、能更新1万个Customer对象，这是影响批量操作性能的重要因素。假如Hibernate能直接执行如下SQL语句：update CUSTOMERS set AGE=AGE+1 where AGE0;那么以上一条update语句就能更新CUSTOMERS表中的1万条记录。但是Hibernate并没有直接提供执行这种update语句的接口。应用程序必须绕过Hibernate API，直接通过JDBC API来执行该SQL语句：tx = session.beginTransaction();Connection con=session.connection();PreparedStatement s

11、tmt=con.prepareStatement(update CUSTOMERS set AGE=AGE+1 +where AGE0 );stmt.executeUpdate();mit();以上程序演示了绕过Hibernate API，直接通过JDBC API访问数据库的过程。应用程序通过Session的connection()方法获得该Session使用的数据库连接，然后通过它创建PreparedStatement对象并执行SQL语句。值得注意的是，应用程序仍然通过Hibernate的Transaction接口来声明事务边界。如果底层数据库（如Oracle）支持存储过程，也可以通过存储过

12、程来执行批量更新。存储过程直接在数据库中运行，速度更加快。在Oracle数据库中可以定义一个名为batchUpdateCustomer()的存储过程，代码如下：create or replace procedure batchUpdateCustomer(p_age in number) asbeginupdate CUSTOMERS set AGE=AGE+1 where AGEp_age;end;以上存储过程有一个参数p_age，代表客户的年龄，应用程序可按照以下方式调用存储过程：tx = session.beginTransaction();Connection con=session.

13、connection();String procedure = call batchUpdateCustomer(?) ;CallableStatement cstmt = con.prepareCall(procedure);cstmt.setInt(1,0); /把年龄参数设为0cstmt.executeUpdate();mit();从上面程序看出，应用程序也必须绕过Hibernate API，直接通过JDBC API来调用存储过程。Session的各种重载形式的update()方法都一次只能更新一个对象，而delete()方法的有些重载形式允许以HQL语句作为参数，例如：session.

14、delete(from Customer c where c.age0);如果CUSTOMERS表中有1万条年龄大于零的记录，那么以上代码能删除一万条记录。但是Session的delete()方法并没有执行以下delete语句delete from CUSTOMERS where AGE0;Session的delete()方法先通过以下select语句把1万个Customer对象加载到内存中：select * from CUSTOMERS where AGE0;接下来执行一万条delete语句，逐个删除Customer对象：delete from CUSTOMERS where ID=i;de

15、lete from CUSTOMERS where ID=j;delete from CUSTOMERS where ID=k;由此可见，直接通过Hibernate API进行批量更新和批量删除都不值得推荐。而直接通过JDBC API执行相关的SQL语句或调用相关的存储过程，是批量更新和批量删除的最佳方式，这两种方式都有以下优点：(1) 无需把数据库中的大批量数据先加载到内存中，然后逐个更新或修改它们，因此不会消耗大量内存。/数据检索策略关键字: 检索 检索策略：1. 立即检索 2. 延迟检索 3. 预先抓取 4. 批量立即加载 5. 批量延迟加载 立即检索 lazy=false 延迟检索 l

16、azy=true 预先抓取 1. 如果 对象之间全部是立即加载，会导致加载一个对象附带着加载更多的关联对象-无效开销太大 2. 如果对象之间全部是预先抓取，通过一条sql语句完成所有的关联操作。设置hibernate_max_fetch_depth=?外连接的表的个数。一对多 多对多使用延迟加载；一对一，多对一使用预先抓取 批量加载 一对多 多对多的时候 在多的一端，配置文件在一的一端设置set inverse = true batch-size=3.1. 批量立即加载：少发送sql :in(?,?) 注意适当配置batch-size的大小 2. 批量延迟加载： 1：ORM主要解决的问题是对象

17、-关系的映射。一班情况下，一个持久化类和一个表对应，类的每个实例对应表中的一条记录。2：常用的5个核心接口介绍 (1)Configuration接口，用于配置并根启动Hibernate。 (2)SessionFactory接口，一个SessionFactory实例对应一个数据库存储源，它是线程安全的，重量级的，之所以称 它为重量级，是因为启动它要一个很大的缓存，当然，用户可以为它配置二级缓存 (3)Session接口，不是线程安全的，Session实例是轻量级的，它有一个第一级缓存 (4)Transaction接口，是Hibernate的数据库事务接口， (5)Query和Criteria接口

18、，它们是Hibernate的查询接口，Query实例包装了一个HQL查询词句，HQL是面象对象的， 它引用类名和类的属性，而不是表名和表的字段3：持久化类的默认规则 (1)对属性的操作，一这要用setXXX()和getXXX()这样的命名，如果是boolean类型，则可以用isXXX()命名(2)最好实现java.io.Serialiizable接口， (3)必须提供一个不带参数的，最好是public或protected的默认构造方法4：数据类型的映射过程是，先参照表字段类型，再比较java类型，最后由上两种来决定hibernate数据类型5：元素的常用属性 (1)name，指定的是java类

19、中的属性名 (2)column，与java类对应的数据库表名 (3)not null，java类的某个属性是否可为空，在应用应用层检查，即持久化前 (4)type，Hibernate中间件的过度型数据类型， (5)access，设定对于java类属性，是用getXXX()和setXXX()方法(property)，还是直接访问(field) (6)dynamic，设定hibernate生成sql语句的方式，在update，insert时，只对有修改过的字段进行CRUD操作6：我们可以自己对getXXX()和setXXX()方法加入逻辑，这是很灵活的7：只要在xxx.hbm.xml中映射了数据库

20、表中的字断，就可以用HQL语句检索8：Session.close()-清空缓存Session.flush()-清理缓存，对比数据库中表的记录，并执行SQL语句，但不会提交事务Smit()-清理，执行SQL，并提交事务9：Session.load()-当数据库表中没有该记录时，会抛出异常，并受到类级别加载设置的影响，如延迟加载Session.get()-当库中无记录时，返回nullSession.find()-将被淘汰，也是不推荐使用的方法，用query代替10：的inverse属性比如在一(user)对多(book)的关联中，会有配置，当设置inverse=true时，当hibernate检查

21、到user和book的状态都发生变化时，如执行了Book.set(User)，则仅按照book对象状态的变化来同步更新数据库，只生成一条SQL语句来执行，如果不设置inverse=true，则会多执行一次11：和默认的table和column是与name相同的，区分大小写-下面开始介绍各种映射策略1：映射自然主键表，代理主键表，复合主键表，这种映射比较简单，也比较常用2：映射单向一对多，和多对一关联3：映射双向一对多关联(也叫做双向多对一关联)4：怎样提高Hibernate的综合性能 (1)关联级别延迟加载首选设置为lazy=false (2)最好用多对一单向关联，可以选择lazy=false

22、或lazy=true (3)在一对多关联中，首选设置为lazy=true (4)关联类属性首选设置为cascade=save-update，或cascade=all(将删除一切关联的数据) (5)可以设置类级别和关联级别的批量延迟检索和立即检索,batch-size，可以减少和简化Hibernate生成的SQL语句条 数，以提高查询性能 (6)outer-join属性在中默认为true，一般不用设置，多表outer join会严重影响数据库性能hibernate3里面多了 fetch的选项，文档里面说得很简单，我知道lazy参数才是决定是否在查询主表的时候去查询子表，但是这个 fetch又起什

23、么作用呢？我测试了一下，发现无论是 fetch=join 还是 fetch=select,hibernate向数据库发送的 SQL都是一样的。 以一个简单的一对多做例子： Many 一端 Java代码 1. 2. 3. 4. 5. 6. 7. 9. 10. 11. 12. 13. 14. One 一端： Java代码 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. Hibernate的检索策略包括类级别检索策略和关联级别检索策略。 类级别检索策略有立即检索和延迟检索，默认的检索策略是立即检索。在Hibernate映射文件中，通过在上

24、配置 lazy属性来确定检索策略。对于Session的检索方式，类级别检索策略仅适用于load方法；也就说，对于get、qurey检索，持久化对象都会被立即加载而不管lazy是false还是true.一般来说，我们检索对象就是要访问它，因此立即检索是通常的选择。由于load方法在检索不到对象时会抛出异常（立即检索的情况下），因此我个人并不建议使用load检索；而由于中的lazy属性还影响到多对一及一对一的检索策略，因此使用load方法就更没必要了。 关联级别检索策略有立即检索、延迟检索和迫切左外连接检索。对于关联级别检索，又可分为一对多和多对多、多对一和一对一两种情况讨论。 一对多和多对多关联

25、关系一般使用配置。有lazy和outer-join属性，它们的不同取值绝对了检索策略。 1）立即检索：这是一对多默认的检索策略，此时lazy=false，outer-join=false.尽管这是默认的检索策略，但如果关联的集合是无用的，那么就不要使用这种检索方式。 2）延迟检索：此时lazy=true，outer-join=false（outer-join=true是无意义的），这是优先考虑的检索方式。 3）迫切左外连接检索：此时 lazy=false，outer-join=true，这种检索策略只适用于依靠id检索方式（load、get），而不适用于query的集合检索（它会采用立即检索策

26、略）。相比于立即检索，这种检索策略减少了一条sql语句，但在Hibernate中，只能有一个配置成 outer-join=true. 多对一和一对一检索策略一般使用、配置。中需要配置的属性是 outer-join，同时还需要配置one端关联的的lazy属性（配置的可不是中的lazy哦），它们的组合后的检索策略如下： 1） outer-join=auto：这是默认值，如果lazy=true为延迟检索，如果lazy=false为迫切左外连接检索。 2） outer-join=true，无关于lazy，都为迫切左外连接检索。 3） outer-join=false，如果lazy=true为延迟检索，

27、否则为立即检索。 可以看到，在默认的情况下（outer-join=auto，lazy=false），对关联的one端对象Hibernate采用的迫切左外连接检索。依我看，很多情况下，我们并不需要加载one端关联的对象（很可能我们需要的仅仅是关联对象的id）；另外，如果关联对象也采用了迫切左外连接检索，就会出现select语句中有多个外连接表，如果个数多的话会影响检索性能，这也是为什么Hibernate通过 hibernate.max_fetch_depth属性来控制外连接的深度。对于迫切左外连接检索，query的集合检索并不适用，它会采用立即检索策略。 对于检索策略，需要根据实际情况进行选择。

28、对于立即检索和延迟检索，它们的优点在于select语句简单（每张表一条语句）、查询速度快，缺点在于关联表时需要多条select语句，增加了访问数据库的频率。因此在选择即检索和延迟检索时，可以考虑使用批量检索策略来减少select语句的数量（配置batch-size属性）。对于切左外连接检索，优点在于select较少，但缺点是select语句的复杂度提高，多表之间的关联会是很耗时的操作。另外，配置文件是死的，但程序是活的，可以根据需要在程序里显示的指定检索策略（可能经常需要在程序中显示指定迫切左外连接检索）。为了清楚检索策略的配置效果如何，可以配置show_sql属性查看程序运行时Hiberna

29、te执行的sql语句。答案7、在Java中使用Hibernate来对数据进行批量处理的话。 向数据库插入100 000条数据，用Hibernate可能像这样：在Java中使用Hibernate来对数据进行批量处理的话。 向数据库插入100 000条数据，用Hibernate可能像这样：Session session = sessionFactory.openSession(); Transaction tx = session.beginTransaction(); for ( int i=0; i; i+ ) Customer customer = new Customer(.); sess

30、ion.save(customer); mit();session.close();11、xml有哪些解析技术?区别是什么?有DOM,SAX,STAX等 DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，屎隙诃ML的顺序访问 STAX:Stre

31、aming API for XML (StAX)12、用jdom解析xml文件时如何解决中文问题?如何解析?看如下代码,用编码方式加以解决 package test; import java.io.*; public class DOMTest private String inFile = c:people.xml; private String outFile = c:people.xml; public static void main(String args) new DOMTest(); public DOMTest() try javax.xml.parsers.DocumentB

32、uilder builder = javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder(); org.w3c.dom.Document doc = builder.newDocument(); org.w3c.dom.Element root = doc.createElement(老师); org.w3c.dom.Element wang = doc.createElement(王); org.w3c.dom.Element liu = doc.createElement(刘); wang.appe

33、ndChild(doc.createTextNode(我是王老师); root.appendChild(wang); doc.appendChild(root); javax.xml.transform.Transformer transformer = javax.xml.transform.TransformerFactory.newInstance().newTransformer(); transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, gb2312); transformer.setOutput

34、Property(javax.xml.transform.OutputKeys.INDENT, yes); transformer.transform(new javax.xml.transform.dom.DOMSource(doc), new javax.xml.transform.stream.StreamResult(outFile); catch (Exception e) System.out.println (e.getMessage(); 14、Hibernate中关于get()和load()方法检索的区别hibernate中session.get/load方法都能通过指定实体

35、类名和id从数据库中读取指定的记录，并且返回与之对映的实体对象。但是它们也有很大的区别,get()和load()方法在执行检索时的区别：1.get()在类检索级别时总是执行立即检索而且如果检索不到相关的对象的话会返回null,load()方法则会抛出一个ObjectNotException2.load()方法可返回一个实体代理类类型，而get()方法直接返回的是实体类对象。3.load()方法可以充分利用内部缓存和二级缓存，而get()方法会忽略二级缓存，若内部缓存没有查询到会到数据库中去查询。15、Hibernate中的update()和saveOrUpdate()的区别saveOrUpda

36、te()方法可以实现update()的功能，但会多些步骤，具体如下：如果对象在该session中已经被持久化，不进行操作；对象的标识符属性(identifier property)在数据库中不存在或者是个暂时的值，调用save()方法保存它；如果session中的另一个对象有相同的标识符抛出一个异常；以上皆不符合则调用update()更新之。16、一个hibernate对象有几种状态：有三种状态：未被持久化的VO ，此时就是一个内存对象VO，由JVM管理生命周期；已被持久化的PO，并且在Session生命周期内，此时映射数据库数据，由数据库管理生命周期；曾被持久化过，但现在和Session已经

37、detached了，以VO的身份在运行 这种和Session已经detached的PO还能够进入另一个Session。30、Ibatis和Hibernate有什么区别？我一直用ibatis，其实开始项目经理准备用hibernate的，但是hibernate是全封装型orm，做一些需要灵活操作数据库的东东效果很不理想，而且配置了诸如一对多，多对多等映射后，经常会查询一些不必要的数据，即便写了一些可优化性能的配置语句，也会至少查个id出来。而ibatis不会有这种问题，ibatis也是orm一种实现，不同的是sql要自己写，现在只有白痴程序员才不会sql。自己写的sql肯定要灵活，肯定会提高系统性能。但是缺点是开发时间长。 31、1、session保存在服务器，客户端不知道其中的信息；cookie保存在客户端，服务器能够知道其中的信息。2、session中保存的是对象，cookie中保存的是字符串。3、session不能区分路径，同一个用户在访问一个网站期间，所有的session在任何一个地方都可以访问到。而cookie中如果设置了路径参数，那么同一个网站中不同路径下的cookie互相是访问不到的。4、session默认需要借助cookie才能正常工作。如果客户端完全禁止cookie，session，这种方法将失效。但是如果服务器端启用了url编码，也