java面试题,各大企业常见的java笔试题之八

IO 流及Socket 部分：（共5 题：基础5 道）

1、什么是java 序列化，如何实现java 序列化？【基础】
答：序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题；序列化的实现：将需要被序列化的类实现Serializable 接口，该接口没有需实现的方法，implements Serializable 只是为了标注该对象是可被序列化的，然后使用一个输出流(如FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream 对象的writeObject(Object obj)方法就可以将参数为obj 的对象写出(即保存其状态)，要恢复的话则用输入流。

2、java 中有几种类型的流？JDK 为每种类型的流提供了一些抽象类以供继承，
请说出他们分别是哪些类？【基础】
答：字节流，字符流。字节流继承于InputStream、OutputStream，字符流继承于Reader、Writer。在java.io 包中还有许多其他的流，主要是为了提高性能和使用方便。

3、文件和目录（IO）操作：
1)如何列出某个目录下的所有文件？
2)如何列出某个目录下的所有子目录？
3)如何判断一个文件或目录是否存在？
4)如何读写文件？【基础】
答：1)示例代码如下:
File file = new File(“e:\\总结”);
File[] files = file.listFiles();
for(int i=0; i if(files[i].isFile()) System.out.println(files[i]);
}
2)示例代码如下:
File file = new File(“e:\\总结”);
File[] files = file.listFiles();
for(int i=0; i if(files[i].isDirectory()) System.out.println(files[i]);
}
3)创建File 对象,调用其exsit()方法即可返回是否存在,如:
第22 页共59 页
System.out.println(new File(“d:\\t.txt”).exists());
4)示例代码如下:
//读文件:
FileInputStream fin = new FileInputStream(“e:\\tt.txt”);
byte[] bs = new byte[100];
while(true){
int len = fin.read(bs);
if(len <= 0) break;
System.out.print(new String(bs,0,len));
}
fin.close();
//写文件:
FileWriter fw = new FileWriter(“e:\\test.txt”);
fw.write(“hello world!” + System.getProperty(“line.separator”));
fw.write(“你好！北京！”);
fw.close();

4、写一个方法,输入一个文件名和一个字符串,统计这个字符串在这个文件中出现的次数。【基础】
答：代码如下：
public int countWords(String file, String find) throws Exception{
int count = 0;
Reader in = new FileReader(file);
int c;
while ((c = in.read()) != -1) {
while (c == find.charAt(0)) {
for (int i = 1; i < find.length(); i++) {
c = in.read();
if (c != find.charAt(i)) break;
if (i == find.length() – 1) count++;
}
}
}
return count;
}

5、Java 的通信编程，编程题(或问答)，用JAVA SOCKET 编程，读服务器几个字符，再写入本地显示？【基础】
答：Server 端程序:
package test;
import java.net.*;
import java.io.*;
public class Server{
private ServerSocket ss;
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public Server(){
try {
ss=new ServerSocket(10000);
while(true){
socket = ss.accept();
String RemoteIP =
socket.getInetAddress().getHostAddress();
String RemotePort = “:”+socket.getLocalPort();
System.out.println(“A client come in!IP:”
+ RemoteIP+RemotePort);
in = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
String line = in.readLine();
System.out.println(“Cleint send is :” + line);
out =
new PrintWriter(socket.getOutputStream(),true);
out.println(“Your Message Received!”);
out.close();
in.close();
socket.close();
}
}catch (IOException e){
out.println(“wrong”);
}
}
public static void main(String[] args){
new Server();
}
}
Client 端程序:
package test;
import java.io.*;
import java.net.*;
public class Client {
Socket socket;
BufferedReader in;
PrintWriter out;
public Client(){
try {
System.out.println(“Try to Connect to
127.0.0.1:10000″);
socket = new Socket(“127.0.0.1″,10000);
System.out.println(“The Server Connected!”);
System.out.println(“Please enter some Character:”);
BufferedReader line = new BufferedReader(new
InputStreamReader(System.in));
out = new PrintWriter(socket.getOutputStream(),true);
out.println(line.readLine());
in = new BufferedReader(
new InputStreamReader(socket.getInputStream()));
System.out.println(in.readLine());
out.close();
in.close();
socket.close();
}catch(IOException e){
out.println(“Wrong”);
}
}
public static void main(String[] args) {
new Client();
}
}

OOA/D 与UML 部分：（共6 题：基础2 道，中等难度4 道）
6、UML 是什么？常用的几种图？【基础】
答：UML 是标准建模语言；常用图包括：用例图,静态图(包括类图、对象图和包图),行为图,交互图(顺序图,合作图),实现图。

7、编程题: 写一个Singleton 出来。【基础】
答：Singleton 模式主要作用是保证在Java 应用程序中，一个类Class 只有一个实例存在。举例：定义一个类，它的构造函数为private 的，它有一个static的private 的该类变量，在类初始化时实例话，通过一个public 的getInstance方法获取对它的引用,继而调用其中的方法。
第一种形式:
public class Singleton {
private Singleton(){}
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
}
第二种形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance(){
if (instance==null)
instance＝new Singleton();
return instance;
}
}
其他形式: 定义一个类，它的构造函数为private 的，所有方法为static 的。
一般认为第一种形式要更加安全些。

8、说说你所熟悉或听说过的j2ee 中的几种常用模式?及对设计模式的一些看法。【中等难度】
答：Session Facade Pattern：使用SessionBean 访问EntityBean；
Message Facade Pattern：实现异步调用；
EJB Command Pattern：使用Command JavaBeans 取代SessionBean，实现轻量级访问；
Data Transfer Object Factory：通过DTO Factory 简化EntityBean 数据提供特性；
Generic Attribute Access：通过AttibuteAccess 接口简化EntityBean数据提供特性；
Business Interface：通过远程（本地）接口和Bean 类实现相同接口规范业务逻辑一致性；
EJB 架构的设计好坏将直接影响系统的性能、可扩展性、可维护性、组件可重用性及开发效率。项目越复杂，项目队伍越庞大则越能体现良好设计的重要性。

9、Java 中常用的设计模式？说明工厂模式？【中等难度】
答：Java 中的23 种设计模式：Factory（ 工厂模式），Builder（ 建造模式）， Factory Method（工厂方法模式），Prototype（原始模型模式），Singleton（单例模式），Facade（门面模式），Adapter（适配器模式）， Bridge（桥梁模式）， Composite（合成模式），Decorator（装饰模式）， Flyweight（享元模式）， Proxy（代理模式），Command（命令模式）， Interpreter（解释器模式）， Visitor（访问者模式），Iterator（迭代子模式）， Mediator（调停者模式）， Memento（备忘录模式），Observer（观察者模式），State（状态模式），Strategy（策略模式），Template Method（模板方法模式）， Chain Of Responsibleity（责任链模式）。
工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

10、开发中都用到了那些设计模式?用在什么场合? 【中等难度】
答：每个模式都描述了一个在我们的环境中不断出现的问题，然后描述了该问题的解决方案的核心。通过这种方式，你可以无数次地使用那些已有的解决方案，无需在重复相同的工作。主要用到了MVC 的设计模式，用来开发JSP/Servlet或者J2EE 的相关应用；及简单工厂模式等。

11、你对软件开发中迭代的含义的理解；【中等难度】
答：软件开发中，各个开发阶段不是顺序执行的，应该是并行执行,也就是迭代的意思。这样对于开发中的需求变化，及人员变动都能得到更好的适应。

XML 部分：（共4 题：基础1 道，中等难度1 道，较难2 道）
12、XML 文档定义有几种形式？它们之间有何本质区别？解析XML 文档有哪几种方式？【基础】
答：1）两种形式：dtd 以及schema；
2）本质区别：schema 本身是xml 的，可以被XML 解析器解析(这也是从DTD
上发展schema 的根本目的)；
3）解析方式：有DOM,SAX,STAX 等：
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM 的树结构所造成的，这种结构占用的内存较多，而且DOM 必须在解析文件之前把整个文档装入内存,适合对XML 的随机访问；SAX:不同于DOM,SAX 是事件驱动型的XML 解析方式。它顺序读取XML 文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML 文件，适合对XML 的顺序访问；STAX:Streaming API for XML (StAX)。

13、你在项目中用到了xml 技术的哪些方面?如何实现的? 【中等难度】
答:用到了数据存贮，信息配置两方面。在做数据交换平台时，将不能数据源的数据组装成XML 文件，然后将XML 文件压缩打包加密后通过网络传送给接收者，接收解密与解压缩后再同XML 文件中还原相关信息进行处理。在做软件配置时，利用XML 可以很方便的进行，软件的各种配置参数都存贮在XML 文件中。

14、用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.DocumentBuilder 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.appendChild(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.setOutputProperty(
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());
}
}
}

15、编程用JAVA 解析XML 的方式。【较难】
答：用SAX 方式解析XML，XML 文件如下：


王小明
信息学院
6258113
男,1955 年生,博士，95 年调入海南大学

事件回调类SAXHandler.java ：
import java.io.*;
import java.util.Hashtable;
import org.xml.sax.*;
public class SAXHandler extends HandlerBase{
private Hashtable table = new Hashtable();
private String currentElement = null;
private String currentValue = null;
public void setTable(Hashtable table){
this.table = table;
}
public Hashtable getTable(){
return table;
}
public void startElement(String tag, AttributeList attrs)
throws SAXException{
currentElement = tag;
}
public void characters(char[] ch, int start, int length)
throws SAXException{
currentValue = new String(ch, start, length);
}
public void endElement(String name) throws SAXException{
if (currentElement.equals(name))
table.put(currentElement, currentValue);
}
}
JSP 内容显示源码,SaxXml.jsp:





<%@ page errorPage=”ErrPage.jsp”
contentType=”text/html;charset=GB2312″ %>
<%@ page import=”java.io.*” %>
<%@ page import=”java.util.Hashtable” %>
<%@ page import=”org.w3c.dom.*” %>
<%@ page import=”org.xml.sax.*” %>
<%@ page import=”javax.xml.parsers.SAXParserFactory” %>
<%@ page import=”javax.xml.parsers.SAXParser” %>
<%@ page import=”SAXHandler” %>
<%
File file = new File(“c:\people.xml”);
FileReader reader = new FileReader(file);
Parser parser;
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser sp = spf.newSAXParser();
SAXHandler handler = new SAXHandler();
sp.parse(new InputSource(reader), handler);
Hashtable hashTable = handler.getTable();
out.println(“

”);
out.println(“” + “”);
out.println(“” + “”);
out.println(“” + “”);
out.println(“” + “”);
out.println(“

” +”教师信息表

姓名	” +(String)hashTable.get(new String(“name”)) +”
学院	” +(String)hashTable.get(new String(“college”))+”
电话	” +(String)hashTable.get(new String(“telephone”))+ “
备注	” +(String)hashTable.get(new String(“notes”))+ “

”);
%>

四、数据库及SQL 部分：（共4 题：基础3 道，中等难度1 道）
16、有3 个表（15 分钟）：【基础】
Student 学生表(学号，姓名，性别，年龄，组织部门)
Course 课程表(编号，课程名称)
Sc 选课表(学号，课程编号，成绩)
表结构如下：
1）写一个SQL 语句，查询选修了’计算机原理’的学生学号和姓名（3 分钟）
2）写一个SQL 语句，查询’周星驰’同学选修了的课程名字（3 分钟）
3）写一个SQL 语句，查询选修了5 门课程的学生学号和姓名（9 分钟）
答：1）SQL 语句如下：
select stu.sno, stu.sname from Student stu
where (select count(*) from sc where sno=stu.sno and cno =
(select cno from Course where cname=’计算机原理’)) != 0;
2）SQL 语句如下：
select cname from Course
where cno in ( select cno from sc where sno =
(select sno from Student where sname=’周星驰’));
3）SQL 语句如下：
select stu.sno, stu.sname from student stu
where (select count(*) from sc where sno=stu.sno) = 5;

17、有三张表,学生表S,课程C,学生课程表SC,学生可以选修多门课程,一门课程可以被多个学生选修,通过SC 表关联。【基础】
1）写出建表语句；
2）写出SQL 语句,查询选修了所有选修课程的学生；
3）写出SQL 语句,查询选修了至少5 门以上的课程的学生。
答：1）建表语句如下（mysql 数据库）：
create table s(id integer primary key, name varchar(20));
create table c(id integer primary key, name varchar(20));
create table sc(
sid integer references s(id),
cid integer references c(id),
primary key(sid,cid)
);
2）SQL 语句如下：
select stu.id, stu.name from s stu
where (select count(*) from sc where sid=stu.id)
= (select count(*) from c);
3）SQL 语句如下：
select stu.id, stu.name from s stu
where (select count(*) from sc where sid=stu.id)>=5;

18、数据库表(Test)结构如下：【基础】
ID NAME AGE MANAGER(所属主管人ID)
106 A 30 104
109 B 19 104
104 C 20 111
107 D 35 109
112 E 25 120
119 F 45 NULL
要求:列出所有年龄比所属主管年龄大的人的ID 和名字?
答：SQL 语句如下：
select employee.name from test employee
where employee.age > (select manager.age from test manager
where manager.id=employee.manager);

19、有如下两张表：【中等难度】
表city： 表state：
CityNo CityName StateNo
BJ 北京（Null）
SH 上海（Null）
GZ 广州GD
DL 大连LN
欲得
到如下结果： City
No City Name State No State Name BJ
北京（Null） （Null） DL
大连LN 辽宁GZ
广州GD 广东SH
上海（Null） （Null） 写相
应的SQL 语句。
答：SQL 语句为：
SELECT C.CITYNO, C.CITYNAME, C.STATENO, S.STATENAME
FROM CITY C, STATE S
WHERE C.STATENO=S.STATENO(+)
ORDER BY(C.CITYNO);

五、JDBC 及Hibernate:（共12 题：基础10 道，中等难度2 道）
20、数据库，比如100 用户同时来访，要采取什么技术解决？【基础】
答：可采用连接池。

21、什么是ORM？【基础】
答：对象关系映射（Object—Relational Mapping，简称ORM）是一种为了解决面向对象与面向关系数据库存在的互不匹配的现象的技术；简单的说，ORM 是通过使用描述对象和数据库之间映射的元数据，将java 程序中的对象自动持久化到关系数据库中；本质上就是将数据从一种形式转换到另外一种形式。

22、Hibernate 有哪5 个核心接口？【基础】
答：Configuration 接口：配置Hibernate，根据其启动hibernate，创建
SessionFactory 对象；
SessionFactory 接口：初始化Hibernate，充当数据存储源的代理，创建session 对象，sessionFactory 是线程安全的，意味着它的同一个实例可以被应用的多个线程共享，是重量级、二级缓存；
Session 接口：负责保存、更新、删除、加载和查询对象，是线程不安全的，避免多个线程共享同一个session，是轻量级、一级缓存；
Transaction 接口：管理事务；
Query 和Criteria 接口：执行数据库的查询。

23、关于hibernate: 【基础】
1）在hibernate 中，在配置文件呈标题一对多，多对多的标签是什么；
2）Hibernate 的二级缓存是什么；
3）Hibernate 是如何处理事务的；
答：1）一对多的标签为 ；多对多的标签为；
2）sessionFactory 的缓存为hibernate 的二级缓存；
3）Hibernate 的事务实际上是底层的JDBC Transaction 的封装或者是JTA
Transaction 的封装；默认情况下使用JDBCTransaction。
State
No
State
Name
GD 广东
LN 辽宁
SD 山东
NMG 内蒙古

24、Hibernate 的应用（Hibernate 的结构）？【基础】
答：//首先获得SessionFactory 的对象
SessionFactory sessionFactory = new Configuration().configure().
buildSessionFactory();
//然后获得session 的对象
Session session = sessionFactory.openSession();
//其次获得Transaction 的对象
Transaction tx = session.beginTransaction();
//执行相关的数据库操作:增,删,改,查
session.save(user); //增加, user 是User 类的对象
session.delete(user); //删除
session.update(user); //更新
Query query = session.createQuery(“from User”); //查询
List list = query.list();
//提交事务
tx.commit();
//如果有异常,我们还要作事务的回滚,恢复到操作之前
tx.rollback();
//最后还要关闭session,释放资源
session.close();

25、什么是重量级？什么是轻量级？【基础】
答：轻量级是指它的创建和销毁不需要消耗太多的资源，意味着可以在程序中经常创建和销毁session 的对象；重量级意味不能随意的创建和销毁它的实例，会占用很多的资源。

26、数据库的连接字符串？【基础】
答：MS SQL Server
//第二种连接方式
Class.forName(“com.microsoft.jdbc.sqlserver.SQLServerDriver”).
newInstance();
conn = DriverManager.getConnection(“jdbc:Microsoft:sqlserver
://localhost:1433;DatabaseName=pubs”,”sa”,””);
//Oracle
Class.forName(“oracle.jdbc.driver.OracleDriver”).newInstance();
conn = DriverManager.getConnection(“jdbc:oracle:thin:
@localhost:1521:sid”, uid, pwd);
//Mysql
Class.forName(“org.git.mm.mysql.Driver”).newInstance();
conn = DriverManager.getConnection(“jdbc:mysql
://localhost:3306/pubs”,”root”,””);
处理中文的问题:
jdbc:mysql://localhost:3306/pubs?useUnicode=true
&characterEncoding=GB2312

27、事务处理？【基础】
答：Connection 类中提供了3 个事务处理方法：
setAutoCommit(Boolean autoCommit):设置是否自动提交事务，默认为自动提交事务，即为true，通过设置false 禁止自动提交事务；
commit():提交事务；
rollback():回滚事务。

28、Java 中访问数据库的步骤？Statement 和PreparedStatement 之间的区别？【基础】
答：Java 中访问数据库的步骤如下：
1）注册驱动；
2）建立连接；
3）创建Statement；
4）执行sql 语句；
5）处理结果集（若sql 语句为查询语句）；
6）关闭连接。
PreparedStatement 被创建时即指定了SQL 语句，通常用于执行多次结构相同的SQL 语句。

29、用你熟悉的语言写一个连接ORACLE 数据库的程序,能够完成修改和查询工作。【基础】
答：JDBC 示例程序如下：
public void testJdbc(){
Connection con = null;
PreparedStatement ps = null;
ResultSet rs = null;
try{
//step1：注册驱动；
Class.forName(“oracle.jdbc.driver.OracleDriver”);
//step 2：获取数据库连接；
con=DriverManager.getConnection(
“jdbc:oracle:thin:@192.168.0.39:1521:TARENADB”,
“sd0605″,”sd0605″);
/************************查询************************/
//step 3：创建Statement；
String sql = “SELECT id, fname, lname, age, FROM
Person_Tbl”;
ps = con.prepareStatement(sql);
//step 4 ：执行查询语句，获取结果集；
rs = ps.executeQuery();
//step 5：处理结果集—输出结果集中保存的查询结果；
while (rs.next()){
System.out.print(“id = ” + rs.getLong(“id”));
System.out.print(” , fname = ” +rs.getString(“fname”));
System.out.print(” , lname = ” +rs.getString(“lname”));
System.out.print(” , age = ” + rs.getInt(“age”));
}
/************************JDBC 修改*********************/
sql = “UPDATE Person_Tbl SET age=23 WHERE id = ?”;
ps = con.prepareStatement(sql);
ps.setLong(1, 88);
int rows = ps.executeUpdate();
System.out.println(rows + ” rows affected.”);
} catch (Exception e){
e.printStackTrace();
} finally{
try{
con.close(); //关闭数据库连接，以释放资源。
} catch (Exception e1) {
}
}
}

30、JDBC，Hibernate 分页怎样实现？【中等难度】
答：方法分别为：
1) Hibernate 的分页：
Query query = session.createQuery(“from Student”);
query.setFirstResult(firstResult);//设置每页开始的记录号
query.setMaxResults(resultNumber);//设置每页显示的记录数
Collection students = query.list();
2) JDBC 的分页：根据不同的数据库采用不同的sql 分页语句
例如: Oracle 中的sql 语句为: “SELECT * FROM (SELECT a.*, rownum r FROM
TB_STUDENT) WHERE r between 2 and 10″ 查询从记录号2 到记录号10 之间的所有记录