当前位置：首页 > 教学范文 > 试题试卷> java面试题网站

java面试题网站

时间：2024-02-04 08:08:10 试题试卷收藏本文下载本文

java面试题网站（锦集9篇）由网友“kaikai687”投稿提供，下面小编为大家整理后的java面试题网站，希望大家喜欢!

java面试题网站

篇1：java面试题

1. 什么情况下会发生栈内存溢出。

至于是堆内存溢出还是方法区内存溢出还是栈内存溢出，其实可以用一些工具比如

JConsole来监视

2. JVM 的内存结构，Eden 和 Survivor 比例。

3. jvm 中一次完整的 GC 流程是怎样的，对象如何晋升到老年代，说说你知道的几种主要的 jvm 参数。

4. 你知道哪几种垃圾收集器，各自的优缺点，重点讲下 cms，包括原理，流程，优缺点

5. 垃圾回收算法的实现原理。

6. 当出现了内存溢出，你怎么排错。

7. JVM 内存模型的相关知识了解多少，比如重排序，内存屏障，happen-before，主内存，工作内存等。

8. 简单说说你了解的类加载器。

9. 讲讲 JAVA 的反射机制。

10. 你们线上应用的 JVM 参数有哪些。

11. g1 和 cms 区别,吞吐量优先和响应优先的垃圾收集器选择。

12. 请解释如下 jvm 参数的含义：

-server -Xms512m -Xmx512m -Xss1024K

-XX:PermSize=256m -XX:MaxPermSize=512m -XX:MaxTenuringThreshold=20 XX:CMSInitiatingOccupancyFraction=80 -XX:+UseCMSInitiatingOccupancyOnly。

blog.csdn.net/a503921892/article/details/39048889

Xmx3550m：设置JVM最大可用内存为3550M。

-Xms3550m：设置JVM初始内存为3550m。此值可以设置与-Xmx相同，以避免每次垃圾回收完成后JVM重新分配内存。

-Xss128k：设置每个线程的堆栈大小。在相同物理内存下，减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的，不能无限生成，

经验值在3000~5000左右

-XX:MaxPermSize=16m:设置持久代大小为16m

-XX:MaxTenuringThreshold=0：设置垃圾最大年龄。如果设置为0的话，则年轻代对象不经过Survivor区，直接进入年老代。对于年老代比较多的应用，可以提高效率。

如果将此值设置为一个较大值，则年轻代对象会在Survivor区进行多次复制，这样可以增加对象再年轻代的存活时间，增加在年轻代即被回收的概论。

开源框架知识

1. 简单讲讲 tomcat 结构，以及其类加载器流程。

2. tomcat 如何调优，涉及哪些参数。

3. 讲讲 Spring 加载流程。

4. 讲讲 Spring 事务的传播属性。

PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

5. Spring 如何管理事务的。

6. Spring 怎么配置事务（具体说出一些关键的 xml元素）。

tx:advice，aop:config

7. 说说你对 Spring 的理解，非单例注入的原理？它的生命周期？循环注入的原理，aop 的实现原理，说说 aop 中的几个术语，它们是怎么相互工作的。

8. Springmvc 中 DispatcherServlet初始化过程。

操作系统

1. Linux 系统下你关注过哪些内核参数，说说你知道的。

2. Linux 下 IO 模型有几种，各自的含义是什么。

3. epoll 和 poll 有什么区别。

4.平时用到哪些 Linux 命令。

5. 用一行命令查看文件的最后五行。

输出test文件的后五行：

liyi@liyi:~/Desktop >tail -n 5 test

输出test文件的前五行：

liyi@liyi:~/Desktop >head -n 5 test

6. 用一行命令输出正在运行的 java 进程。

7. 介绍下你理解的操作系统中线程切换过程。

8. 进程和线程的区别。

多线程

1. 多线程的几种实现方式，什么是线程安全。

2. volatile 的原理，作用，能代替锁么。

3. 画一个线程的生命周期状态图。

4. sleep 和 wait 的区别。

5. Lock 与 Synchronized 的区别。

6. synchronized 的原理是什么，解释以下名词：重排序，自旋锁，偏向锁，轻量级锁，可重入锁，公平锁，非公平锁，乐观锁，悲观锁。

7. 用过哪些原子类，他们的原理是什么。

8. 用过线程池吗，newCache 和 newFixed 有什么区别，他们的原理简单概括下，构造函数的各个参数的含义是什么，比如 coreSize，maxsize 等。

9. 线程池的关闭方式有几种，各自的区别是什么。

10. 假如有一个第三方接口，有很多个线程去调用获取数据，现在规定每秒钟最多有 10 个线程同时调用它，如何做到。

11. spring 的 controller 是单例还是多例，怎么保证并发的安全。

singleton : bean在每个Spring ioc 容器中只有一个实例。

prototype：一个bean的定义可以有多个实例。

request：每次http请求都会创建一个bean，该作用域仅在基于web的Spring ApplicationContext情形下有效。

12. 用三个线程按顺序循环打印 abc 三个字母，比如 abcabcabc。

思路：解题思路大概是这样的，开启三个线程，每个线程一次打印一个字母，并且按照一定的顺序打印，当打印A的时候，其他线程处于阻塞状态，打印完A以后，

将线程解锁，让打印B的那个线程开启，其他线程处于阻塞状态，同理打印C的时候，阻塞其他线程，这三个线程顺序循环，就达到顺序多次打印ABC的目的了。

这道题看似思路简单，其实主要需要用到wait方法和notify()方法，还有关键字synchronized，只有充分理解了这些，才能解出这道题。下面我有必要讲解一下这两个方法，

还有关键字synchronized。

13. ThreadLocal 用过么，用途是什么，原理是什么，用的时候要注意什么。

14. 如果让你实现一个并发安全的链表，你会怎么做。

15. 有哪些无锁数据结构，他们实现的原理是什么。

16. 讲讲 java 同步机制的 wait 和 notify。

17. 多线程如果线程挂住了怎么办。

18. countdowlatch 和 cyclicbarrier的内部原理和用法，以及相互之间的差别。

19. 使用 synchronized 修饰静态方法和非静态方法有什么区别。

所有的非静态同步方法用的都是同一把锁――实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，

该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，

可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，

所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

而所有的静态同步方法用的也是同一把锁――类对象本身，这两把锁是两个不同的对象，

所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，

其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，

还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！

20. 简述 ConcurrentLinkedQueue 和 LinkedBlockingQueue 的用处和不同之处。

21. 导致线程死锁的原因？怎么解除线程死锁。

22. 非常多个线程（可能是不同机器），相互之间需要等待协调，才能完成某种工作，问怎么设计这种协调方案。

23. 正确使用 Volatile 变量

正确使用 volatile 变量的条件

您只能在有限的一些情形下使用 volatile 变量替代锁。要使 volatile 变量提供理想的线程安全，必须同时满足下面两个条件：

1对变量的写操作不依赖于当前值。

2该变量没有包含在具有其他变量的不变式中。

www.ibm.com/developerworks/cn/java/j-jtp06197.html

TCP与HTTP

1. http1.0 和 http1.1 有什么区别。

在http1.0中，当建立连接后，客户端发送一个请求，服务器端返回一个信息后就关闭连接，

当浏览器下次请求的时候又要建立连接，显然这种不断建立连接的方式，会造成很多问题。

在http1.1中，引入了持续连接的概念，通过这种连接，浏览器可以建立一个连接之后，

发送请求并得到返回信息，然后继续发送请求再次等到返回信息，也就是说客户端可以连续发送多个请求，而不用等待每一个响应的到来。

2. TCP 三次握手和四次挥手的流程，为什么断开连接要 4次,如果握手只有两次，会出现什么。

3. TIME_WAIT 和 CLOSE_WAIT 的区别。

4. 说说你知道的几种 HTTP 响应码，比如 200, 302, 404。

5. 当你用浏览器打开一个链接的时候，计算机做了哪些工作步骤。

6. TCP/IP 如何保证可靠性，说说 TCP 头的结构。

7. 如何避免浏览器缓存。

8. 简述 Http 请求 get 和 post 的区别以及数据包格式。

GET提交，请求的数据会附在URL之后（就是把数据放置在HTTP协议头＜request-line＞中

POST提交：把提交的数据放置在是HTTP包的包体＜request-body＞中

[java面试题]

篇2：java面试题

三、线程的四种状态

1. 新状态：线程已被创建但尚未执行(start() 尚未被调用)。

2. 可执行状态：线程可以执行，虽然不一定正在执行。CPU 时间随时可能被分配给该线程，从而使得它执行。

3. 死亡状态：正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。

4. 阻塞状态：线程不会被分配 CPU 时间，无法执行。

四、线程的优先级

线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。

你可以调用 Thread 类的方法 getPriority() 和 setPriority()来存取线程的优先级，线程的优先级界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之间，缺省是5(NORM_PRIORITY)。

5)你用过哪种设计模式?(瞬联，IBM，aspenTech)

设计:design

模式:pattern

框架:framework

创建模式，结构模式和行为模式

GoF设计模式

A.创建模式

设计模式之Factory(工厂模式)

使用工厂模式就象使用new一样频繁./10/9更新

设计模式之Prototype(原型模式)

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

设计模式之Builder

汽车由车轮方向盘发动机很多部件组成，同时，将这些部件组装成汽车也是一件复杂的工作，Builder模式就是将这两种情况分开进行。

设计模式之Singleton(单态模式)

保证一个类只有一个实例,并提供一个访问它的全局访问点 2002/10/9更新

B.结构模式

设计模式之Facade

可扩展的使用JDBC针对不同的数据库编程,Facade提供了一种灵活的实现.

设计模式之Proxy

以Jive为例,剖析代理模式在用户级别授权机制上的应用

设计模式之Adapter

使用类再生的两个方式:组合(new)和继承(extends),这个已经在“thinking in java”中提到过.

设计模式之Composite

就是将类用树形结构组合成一个单位.你向别人介绍你是某单位，你是单位中的一个元素，别人和你做买卖，相当于和单位做买卖。文章中还对Jive再进行了剖析。

设计模式之Decorator

Decorator是个油漆工,给你的东东的外表刷上美丽的颜色.

设计模式之Bridge

将“牛郎织女”分开(本应在一起,分开他们,形成两个接口),在他们之间搭建一个桥(动态的结合)

设计模式之Flyweight

提供Java运行性能,降低小而大量重复的类的开销.

C.行为模式

设计模式之Template

实际上向你介绍了为什么要使用Java 抽象类,该模式原理简单,使用很普遍.

设计模式之Memento

很简单一个模式,就是在内存中保留原来数据的拷贝.

设计模式之Observer

介绍如何使用Java API提供的现成Observer

设计模式之Chain of Responsibility

各司其职的类串成一串,好象击鼓传花,当然如果自己能完成,就不要推委给下一个.

设计模式之Command

什么是将行为封装,Command是最好的说明.

设计模式之State

状态是编程中经常碰到的实例,将状态对象化,设立状态变换器,便可在状态中轻松切换.

设计模式之Strategy

不同算法各自封装,用户端可随意挑选需要的算法.

设计模式之Mediator

Mediator很象十字路口的红绿灯,每个车辆只需和红绿灯交互就可以.

设计模式之Interpreter

主要用来对语言的分析,应用机会不多.

设计模式之Visitor

访问者在进行访问时,完成一系列实质性操作,而且还可以扩展.

设计模式之Iterator

这个模式已经被整合入Java的Collection.在大多数场合下无需自己制造一个Iterator,只要将对象装入Collection中，直接使用Iterator进行对象遍历。

6)请说一下MVC架构(瞬联，IBM，aspenTech)

Model:模型层

View:视图层

Controller:控制层

MVC (Modal View Controler)本来是存在于Desktop程序中的，M是指数据模型，V是指用户界面，C则是控制器。使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。比如一批统计数据你可以分别用柱状图、饼图来表示。C存在的目的则是确保M和V的同步，一旦M改变，V应该同步更新。

模型-视图-控制器(MVC)是Xerox PARC在八十年代为编程语言Smalltalk-80发明的一种软件设计模式，至今已被广泛使用。最近几年被推荐为Sun公司J2EE平台的设计模式，并且受到越来越多的使用 ColdFusion 和 PHP 的开发者的欢迎。模型-视图-控制器模式是一个有用的工具箱，它有很多好处，但也有一些缺点。

MVC如何工作

MVC是一个设计模式，它强制性的使应用程序的输入、处理和输出分开。使用MVC应用程序被分成三个核心部件：模型、视图、控制器。它们各自处理自己的任务。

视图

视图是用户看到并与之交互的界面。对老式的Web应用程序来说，视图就是由HTML元素组成的界面，在新式的Web应用程序中，HTML依旧在视图中扮演着重要的角色，但一些新的技术已层出不穷，它们包括Macromedia Flash和象XHTML，XML/XSL，WML等一些标识语言和Web services.

如何处理应用程序的界面变得越来越有挑战性。MVC一个大的好处是它能为你的应用程序处理很多不同的视图。在视图中其实没有真正的处理发生，不管这些数据是联机存储的还是一个雇员列表，作为视图来讲，它只是作为一种输出数据并允许用户操纵的方式。

模型

模型表示企业数据和业务规则。在MVC的三个部件中，模型拥有最多的处理任务。例如它可能用象EJBs和ColdFusion Components这样的构件对象来处理数据库。被模型返回的数据是中立的，就是说模型与数据格式无关，这样一个模型能为多个视图提供数据。由于应用于模型的代码只需写一次就可以被多个视图重用，所以减少了代码的重复性。

控制器

控制器接受用户的输入并调用模型和视图去完成用户的需求。所以当单击Web页面中的超链接和发送HTML表单时，控制器本身不输出任何东西和做任何处理。它只是接收请求并决定调用哪个模型构件去处理请求，然后用确定用哪个视图来显示模型处理返回的数据。

现在我们总结MVC的处理过程，首先控制器接收用户的请求，并决定应该调用哪个模型来进行处理，然后模型用业务逻辑来处理用户的请求并返回数据，最后控制器用相应的视图格式化模型返回的数据，并通过表示层呈现给用户。

为什么要使用 MVC

大部分Web应用程序都是用像ASP，PHP，或者CFML这样的过程化语言来创建的。它们将像数据库查询语句这样的数据层代码和像HTML这样的表示层代码混在一起。经验比较丰富的开发者会将数据从表示层分离开来，但这通常不是很容易做到的，它需要精心的计划和不断的尝试。MVC从根本上强制性的将它们分开。尽管构造MVC应用程序需要一些额外的工作，但是它给我们带来的好处是无庸质疑的。

首先，最重要的一点是多个视图能共享一个模型，正如我所提及的，现在需要用越来越多的方式来访问你的应用程序。对此，其中一个解决之道是使用MVC，无论你的用户想要Flash界面或是 WAP 界面;用一个模型就能处理它们。由于你已经将数据和业务规则从表示层分开，所以你可以最大化的重用你的代码了。

由于模型返回的数据没有进行格式化，所以同样的构件能被不同界面使用。例如，很多数据可能用HTML来表示，但是它们也有可能要用Macromedia Flash和WAP来表示。模型也有状态管理和数据持久性处理的功能，例如，基于会话的购物车和电子商务过程也能被Flash网站或者无线联网的应用程序所重用。

因为模型是自包含的，并且与控制器和视图相分离，所以很容易改变你的应用程序的数据层和业务规则。如果你想把你的数据库从MySQL移植到Oracle，或者改变你的基于RDBMS数据源到LDAP，只需改变你的模型即可。一旦你正确的实现了模型，不管你的数据来自数据库或是LDAP服务器，视图将会正确的显示它们。由于运用MVC的应用程序的三个部件是相互对立，改变其中一个不会影响其它两个，所以依据这种设计思想你能构造良好的松偶合的构件。

对我来说，控制器的也提供了一个好处，就是可以使用控制器来联接不同的模型和视图去完成用户的需求，这样控制器可以为构造应用程序提供强有力的手段。给定一些可重用的模型和视图，控制器可以根据用户的需求选择模型进行处理，然后选择视图将处理结果显示给用户。

MVC的缺点

MVC的缺点是由于它没有明确的定义，所以完全理解MVC并不是很容易。使用MVC需要精心的计划，由于它的内部原理比较复杂，所以需要花费一些时间去思考。

你将不得不花费相当可观的时间去考虑如何将MVC运用到你的应用程序，同时由于模型和视图要严格的分离，这样也给调试应用程序到来了一定的困难。每个构件在使用之前都需要经过彻底的测试。一旦你的构件经过了测试，你就可以毫无顾忌的重用它们了。

根据我个人经验，由于我们将一个应用程序分成了三个部件，所以使用MVC同时也意味着你将要管理比以前更多的文件，这一点是显而易见的。这样好像我们的工作量增加了，但是请记住这比起它所能带给我们的好处是不值一提。

MVC并不适合小型甚至中等规模的应用程序，花费大量时间将MVC应用到规模并不是很大的应用程序通常会得不偿失。

MVC是一条创建软件的好途径

MVC设计模式是一个很好创建软件的途径，它所提倡的一些原则，像内容和显示互相分离可能比较好理解。但是如果你要隔离模型、视图和控制器的构件，你可能需要重新思考你的应用程序，尤其是应用程序的构架方面。如果你肯接受MVC，并且有能力应付它所带来的额外的工作和复杂性，MVC将会使你的软件在健壮性，代码重用和结构方面上一个新的台阶。

7)如果类a继承类b，实现接口c，而类b和接口c中定义了同名变量，请问会出现什么问题?(瞬联)

interface A

{

int x = 0;

}

class B

{

int x =1;

}

class C extends B implements A

{

public void pX()

{

System.out.println(x);

}

public static void main(String[] args) {

new C().pX();

}

答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，两个x都匹配(就象在同时import java.util和java.sql两个包时直接声明Date一样)。对于父类的变量,可以用super.x来明确(输出的是1)，而接口的属性默认隐含为 public static final.所以可以通过A.x来明确(输出的是0)。

下面的代码运行时会不会报错

interface Playable

{

void play();

}

interface Bounceable

{

void play();

}

interface Rollable extends Playable, Bounceable

{

Ball ball = new Ball(“PingPang”);

}

class Ball implements Rollable

{

private String name;

public String getName()

{

return name;

}

public Ball(String name)

{

this.name = name;

}

public void play()

{

ball = new Ball(“Football”);

System.out.println(ball.getName());

}

答案: 错。“interface Rollable extends Playable, Bounceable”没有问题。interface可继承多个interfaces，所以这里没错。问题出在interface Rollable里的“Ball ball = new Ball(”PingPang“);”。任何在interface里声明的interface variable (接口变量，也可称成员变量)，默认为public static final。也就是说“Ball ball = new Ball(”PingPang“);”实际上是“public static final Ball ball = new Ball(”PingPang“);”。在Ball类的Play()方法中，“ball = new Ball(”Football“);”改变了ball的reference，而这里的ball来自Rollable interface，Rollable interface里的ball是public static final的，final的object是不能被改变reference的。因此编译器将在“ball = new Ball(”Football“);”这里显示有错。

8)请说一下java中为什么要引入内部类?还有匿名内部类?(瞬联，IBM)

9)请说一下final，finally和finalize的区别?(瞬联)

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

10)请说一下HTTP请求的基本过程(IBM)

11)java中存在内存泄漏问题吗?请举例说明?(IBM)

会

int i,i2; return (i-i2); //when i为足够大的正数,i2为足够大的负数。结果会造成溢位，导致错误。

12)请说一下java中的内存回收机制所采用的算法(IBM，瞬联)

虽然垃圾回收关心着大部分的问题，包括内存管理，使得程序员的任务显得更加轻松，但是程序员还是可能犯些错误导致内存泄漏问题。GC(垃圾回收)通过递归对所有从“根”对象(堆栈中的对象，静态数据成员，JNI句柄等等)继承下来的引用进行工作，然后标记所有可以访问的活动着的对象。而这些对象变成了程序唯一能够操纵的对象，其他的对象都被释放了。因为GC使得程序不能够访问那些被释放的对象，所以这样做是安全的。

篇3：java面试题

1、面向对象的特征有哪些方面?

1.抽象：

抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

2.继承：

继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新类的基类(父类)。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

3.封装：

封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

4. 多态性：

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

2、String是最基本的数据类型吗?

基本数据类型包括byte、int、char、long、float、double、boolean和short。

java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类

3、int 和 Integer 有什么区别

Java 提供两种不同的类型：引用类型和原始类型(或内置类型)。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。

原始类型封装类

booleanBoolean

charCharacter

byteByte

shortShort

intInteger

longLong

floatFloat

doubleDouble

引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。

4、String 和StringBuffer的区别

JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。

5、运行时异常与一般异常有何异同?

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

6、说出Servlet的生命周期，并说出Servlet和CGI的区别。

Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法(doGet，doPost)等，当服务器决定将实例销毁的时候调用其destroy方法。

与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。

7、说出ArrayList,Vector, LinkedList的存储性能和特性

ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法(线程安全)，通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

8、EJB是基于哪些技术实现的?并说出SessionBean和EntityBean的区别，StatefulBean和StatelessBean的区别。

EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现。

SessionBean在J2EE应用程序中被用来完成一些服务器端的业务操作，例如访问数据库、调用其他EJB组件。EntityBean被用来代表应用系统中用到的数据。

对于客户机，SessionBean是一种非持久性对象，它实现某些在服务器上运行的业务逻辑。

对于客户机，EntityBean是一种持久性对象，它代表一个存储在持久性存储器中的实体的对象视图，或是一个由现有企业应用程序实现的实体。

Session Bean 还可以再细分为 Stateful Session Bean 与 Stateless Session Bean ，这两种的 Session Bean都可以将系统逻辑放在 method之中执行，不同的是 Stateful Session Bean 可以记录呼叫者的状态，因此通常来说，一个使用者会有一个相对应的 Stateful Session Bean 的实体。Stateless Session Bean 虽然也是逻辑组件，但是他却不负责记录使用者状态，也就是说当使用者呼叫 Stateless Session Bean 的时候，EJB Container 并不会找寻特定的 Stateless Session Bean 的实体来执行这个 method。换言之，很可能数个使用者在执行某个 Stateless Session Bean 的 methods 时，会是同一个 Bean 的 Instance 在执行。从内存方面来看， Stateful Session Bean 与 Stateless Session Bean 比较， Stateful Session Bean 会消耗 J2EE Server 较多的内存，然而 Stateful Session Bean 的优势却在于他可以维持使用者的状态。

9、Collection 和 Collections的区别。

Collection是集合类的上级接口，继承与他的接口主要有Set 和List.

Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

10、&和&&的区别。

&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与(and)。

11、HashMap和Hashtable的区别。

HashMap是Hashtable的轻量级实现(非线程安全的实现)，他们都完成了Map接口，主要区别在于HashMap允许空(null)键值(key),由于非线程安全，效率上可能高于Hashtable。

HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。

HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。

Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。

最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。

Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

12、final, finally, finalize的区别。

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

13、sleep 和 wait() 有什么区别?

sleep是线程类(Thread)的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。

篇4：java面试题

13)请说一下System.gc()函数的作用。什么时候可以调用垃圾回收器?(瞬联)

垃圾回收函数,手动调用的.

当一个对象停止被活动声明所引用，它就变成了垃圾(garbage)可以被回收重新使用

14)你做过的项目中采用了什么安全认证机制?(IBM)

15)Math.round()什么作用?

Math.Round(3.44, 1) = 3.4

Math.Round(3.45, 1) = 3.4

Math.Round(3.46, 1) = 3.5

-----------------------------------------------

Math.Round(3.54, 1) = 3.5

Math.Round(3.55, 1) = 3.6

Math.Round(3.56, 1) = 3.6

-----------------------------------------------

Math.Round(3.64, 1) = 3.6

Math.Round(3.65, 1) = 3.6

Math.Round(3.66, 1) = 3.7

-----------------------------------------------

Math.Round(3.74, 1) = 3.7

Math.Round(3.75, 1) = 3.8

Math.Round(3.76, 1) = 3.8

这种舍入方法叫做银行家舍入(Banker'sRound)，这就是已经规定下来的标准、Round的标准、世界的标准。

Round 四舍五入

16、设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。

以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。

package java_example150;

public class TestThread3{

private int j;

public static void main(String[] args){

TestThread3 t = new TestThread3();

Inc inc = t.new Inc();

Dec dec = t.new Dec();

for(int i=0;i<2;i++){

Thread ts = new Thread(inc);

ts.start();

ts= new Thread(dec);

ts.start();

}

private synchronized void inc(){

j++;

System.out.println(Thread.currentThread().getName()+“-inc:”+j);

}

private synchronized void dec(){

j--;

System.out.println(Thread.currentThread().getName()+“-dec:”+j);

}

class Inc implements Runnable{

public void run(){

for(int i=0;i<10;i++){

inc();

}

class Dec implements Runnable{

public void run(){

for(int i=0;i<10;i++){

dec();

}

17.CORBA是什么?用途是什么?

答：CORBA 标准是公共对象请求代理结构(Common Object Request Broker Architecture)，由对象管理组织 (Object Management Group，缩写为 OMG)标准化。它的组成是接口定义语言(IDL), 语言绑定(binding:也译为联编)和允许应用程序间互操作的协议。其目的为：

1. 用不同的程序设计语言书写

2. 在不同的进程中运行

3. 为不同的操作系统开发

18.JAVA代码查错

abstract class Name

{

private String name;

public abstract boolean isStupidName(String name) {}

}

答案: 错。abstract method必须以分号结尾，且不带花括号。

public class Something

{

void doSomething ()

{

private String s = “”;

int l = s.length();

}

答案: 错。局部变量前不能放置任何访问修饰符 (private，public，和protected)。final可以用来修饰局部变量

(final如同abstract和strictfp，都是非访问修饰符，strictfp只能修饰class和method而非variable)。

abstract class Something

{

private abstract String doSomething ();

}

答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstractmethod封锁起来呢? (同理，abstract method前不能加final)。

public class Something

{

public int addOne(final int x)

{

return ++x;

}

答案: 错。int x被修饰成final，意味着x不能在addOne method中被修改。

public class Something

{

public static void main(String[] args)

{

Other o = new Other();

new Something().addOne(o);

}

public void addOne(final Other o)

{

o.i++;

}

class Other

{

public int i;

}

答案: 正确。在addOne method中，参数o被修饰成final。如果在addOne method里我们修改了o的reference

(比如: o = new Other();)，那么如同上例这题也是错的。但这里修改的是o的member vairable

(成员变量)，而o的reference并没有改变。

class Something

{

int i;

public void doSomething()

{

System.out.println(“i = ” + i);

}

答案: 正确。输出的是“i = 0”。int i属於instant variable (实例变量，或叫成员变量)。instant variable有default value。int的default value是0。

class Something

{

final int i;

public void doSomething()

{

System.out.println(“i = ” + i);

}

答案: 错。final int i 是个final的 instant variable (实例变量，或叫成员变量)。final的instant variable没有default value，必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为“final int i = 0;”。

public class Something

{

public static void main(String[] args)

{

Something s = new Something();

System.out.println(“s.doSomething() returns ” + doSomething());

}

public String doSomething()

{

return “Do something ...”;

}

答案: 错。看上去在main里call doSomething没有什么问题，毕竟两个methods都在同一个class里。但仔细看，main是static的。static method不能直接call non-static methods。可改成“System.out.println(”s.doSomething() returns “ + s.doSomething());”。同理，static method不能访问non-static instant variable。

篇5：java面试题

(没有想到华为的面试题就是非同一般，很多题不是一眼就能够看得出来，至少对我这种鸟来说是这样。对我个人来说，看看这样的题，可能比看《Think In Java》都还要好，因为这里面有很多的东西，都是我们平时没有太在意，或者是只是懂一点皮毛而已，通过做一下这样的练习，把自己不知道、不熟悉的知识点，利用这个机会好好的巩固一下。这些答案是我自己做的，有一些是从网上来的，有一部是自己做的，并且还有一部份没有做完，我不敢保证都对，所以请你在引用的时候，务必通过自己核对一下。当然，我既然能够把这些答案放在这里，那说明我肯定是自己检验了一遍的，也不是那么恐怖的)

QUESTION NO: 1

publicclass Test1 {

publicstaticvoid changeStr(String str){

str=“welcome”;

}

publicstaticvoid main(String[] args) {

String str=“1234”;

changeStr(str);

System.out.println(str);

}

//输出结果：1234

//这里虽然是一个静态方法，但是里面的变量是一个局部变量，

//所以这里不因为是静态方法，就误认为里面的变量也是静态变量了

QUESTION NO:2

publicclass Test2 {

staticboolean foo(char c) {

System.out.print(c);

returntrue;

}

publicstaticvoid main(String[] argv) {

int i = 0;

//for(65;88&&(i<2);67)

for (foo('A'); foo('B') && (i < 2); foo('C')) {

i++;

foo('D');

}

What is the result?

A. ABDCBDCB

B. ABCDABCD

C. Compilation fails.

D. An exception is thrown at runtime.

//输出结果是：ABDCBDCB

分析：FOR循环里面讲究的条件要为真，与你的判断式是什么没有关系

就像这里，虽然是打印的字母，但是却不是false，所以可以执行

第一次进行循环：

foo('A')打印字母A，(注：这里不是false条件就默认为true条件)

foo('B')打印字母B，i=0,比较(i < 2)，条件为true，进行循环体，foo('D')打印D

foo('C')打印字母C

第二次循环：

foo('B')打印B，i=1,比较(i < 2)为true，进行循环体，foo('D')打印D

foo('C')打印字母C

第三次循环：

foo('B')打印字母B，i=2，比较(i < 2)为false，退出循环，得结果

QUESTION NO: 3

1. class A {

2. protected int method1(int a, int b) { return 0; }

3. }

Which two are valid in a class that extends class A? (Choose two)

A. public int method1(int a, int b) { return 0; }

B. private int method1(int a, int b) { return 0; }

C. private int method1(int a, long b) { return 0; }

D. public short method1(int a, int b) { return 0; }

E. static protected int method1(int a, int b) { return 0; }

publicclass B extends A{

/**

*@paramargs

//can not reduce the visibility of the inherited method from A

//即不能够使从类A中继续来的方法的可见性降低

//private int method1(int a, int b) { return 0; }

//This static method cannot hide the instance method from A

//静态方法不能够隐藏继承于A的实例

//static protected int method1(int a, int b) { return 0; }

//返回类型与A中的该方法不一致

//public short method1(int a, int b) { return 0; }

/**

*总结：类的继承中，如果要想重载父类的方法，必须要和父类中的返回类型、可见性等等都要操作一致

*否则，程序就会报错。一定遵守子类要遵从于父类的原则

*而我选择的答案居然是privateintmethod1和staticprotectedint

*我选择第一个的错误理由是：因为原来为保护的，如果我这里设为public，那么就扩展了其原来的可见性

*本来原来就是对包外不可见的，现在变成对包外可见的了，所以就选择的是private

*选择第二个的错误理由是：都是保护的，这里只是变成了静态的而已

//这里是写了一个重载方法，因为参数类型不一致，不会报错

privateint method1(int a, long b) { return 0; }

//可见性可以增大，但是不能够缩小，正确

publicint method1(int a, int b) { return 0; }

publicstaticvoid main(String[] args) {

// TODO Auto-generated method stub

}

QUESTION NO: 4

1. public class Outer{

2. public void someOuterMethod {

3. // Line 3

4. }

5. public class Inner{}

6. public static void main( String[]argv ) {

7. Outer o = new Outer();

8. // Line 8

9. }

10. }

Which instantiates an instance of Inner?

A. new Inner(); // At line 3

B. new Inner(); // At line 8

C. new o.Inner(); // At line 8

D. new Outer.Inner(); // At line 8//new Outer().new Inner()

答案如下：

publicclass Outer {

publicvoid someOuterMethod() {

// Line 3

new Inner();//放在这里不出错

}

publicclass Inner {

}

publicstaticvoid main(String[] argv) {

Outer o= new Outer();

// Line 8

//o不能够被解释成为一种类型，出错

//new o.Inner();

/**

*下面两种用法，都报下面的错误：

*NoenclosinginstanceoftypeOuterisaccessible.

*Mustqualifytheallocationwithanenclosinginstance

*oftypeOuter(e.g.x.newA()wherexisaninstanceofOuter)

//new Outer.Inner();

//new Inner();

}

QUESTION NO: 5

Which method is used by a servlet to place its session ID in a URL that is written to the servlet’s response output stream?

(译：那个方法是servlet用于将其session ID入在一个URL中，该URL写入servlet的响应输出流)

A. The encodeURL method of the HttpServletRequest interface.

B. The encodeURL method of the HttpServletResponse interface.

C. The rewriteURL method of the HttpServletRequest interface.

D. The rewriteURL method of the HttpServletResponse interface.

QUESTION NO: 6

Which two are equivalent? (Choose two)

A. <%= YoshiBean.size%>

B. <%= YoshiBean.getSize()%>

C. <%= YoshiBean.getProperty(“size”)%>

QUESTION NO: 7

Which of the following statements regarding the lifecycle of a session bean are correct?

1. java.lang.IllegalStateException is thrown if SessionContext.getEJBObject() is invoked when a stateful session bean instance is passivated.

2. SessionContext.getRollbackOnly() does not throw an exception when a session bean with bean-managed transaction demarcation is activated.

3. An exception is not thrown when SessionContext.getUserTransaction() is called in the afterBegin method of a bean with container-managed transactions.

4. JNDI access to java:comp/env is permitted in all the SessionSynchronization methods of a stateful session bean with container-managed transaction demarcation.

5. Accessing resource managers in the SessionSynchronization.afterBegin method of a stateful session bean with bean-managed transaction does not throw an exception.

第二部分：概念题

1. 描述Struts体系结构?对应各个部分的开发工作主要包括哪些?

Struts 是MVC的一种实现，它将 Servlet和 JSP 标记(属于 J2EE 规范)用作实现的一部分。Struts继承了MVC的各项特性，并根据J2EE的特点，做了相应的变化与扩展。Struts的体系结构与工作原理如下图2所示：

1)模型(Model)

在Struts的体系结构中，模型分为两个部分：系统的内部状态和可以改变状态的操作(事务逻辑)。内部状态通常由一组Actinform Bean表示。根据设计或应用程序复杂度的不同，这些Bean可以是自包含的并具有持续的状态，或只在需要时才获得数据(从某个数据库)。大型应用程序通常在方法内部封装事务逻辑(操作)，这些方法可以被拥有状态信息的bean调用。比如购物车bean，它拥有用户购买商品的信息，可能还有checkOut()方法用来检查用户的信用卡，并向仓库发定货信息。小型程

篇6：网站面试题

1、你为什么选择做一个网站编辑?

网络是个新兴的媒体，他潜力大，发展快，但在我国的发展时间并不算太长，所以好的网站编辑和网站经营者并不多，所以网站编辑是个很多挑战的工作，我喜欢接受挑战，也希望自己是最出色的一个。

2、你觉得网站编辑应具备什么素质?

首先，网站编辑的首要责任是定位，制定编辑方针，根据客户(包括潜在客户)合作伙伴的需求来策划栏目和收集资讯，所以这就牵涉到一个专业知识的问题了，网站编辑只有做深才能打动客户的心，所以网站编辑应是一个既懂编辑知识又懂专业知识的复合型人才。

其次，网站编辑的责任是编辑和整合文章，要能熟练使用网络搜索工具，最大可能的搜集信息，并编辑出你想要的文章，吸引客户的眼球。

第三，制作网页和美化网页的视觉效果。

第四，要有团结合作精神，每个页面的生成都是编辑、技术人员、美编集体智慧的结晶。

第五，网站编辑最好懂营销知识(对市场有一个明确的把握)。

3、你觉得你身上有什么优点来做好这个网站编辑?

首先，我敢于尝试，遇到困难决不会退缩，困难应成为我们成长的动力而不是阻力。

其次，我很好学，对新鲜事物，和工作有关的事我都喜欢钻研，我希望能尽快入行，对工作有越来越多的发言权。

4、如果你来公司上班，会如何做一个网站编辑?

首先，我会把主管交给我的任务贯彻到底，这是一个员工基本执行力的表现，不管有多少工作，都会高效高质的完成。

其次，对现有工作提出合理有创意的见解。当我对整个工作上手后，我会以一个经营者的眼光来看待这个网站，提出营销策划。

最后，我会不断学习，不断充实自己，做一个能独当一面的复合型人才。

5、你觉得对一家企业门户网站，应开办什么栏目，提供什么资讯?

设定栏目和资讯必须先了解客户的需求，根据他们的需求来推广这个网站。作为一个企业门户网站，那么各个行业动态、企业信息、供求信息、新闻、人物访谈、论坛等必须很丰富。其次，还可以提供免费的邮箱、邮件、电子商务工具等，以增加点击量，推广品牌。

[网站面试题]

篇7：java常见面试题

用java实现一种排序，java类实现序列化的方法(二种)？如在collection框架中，实现比较要实现什么样的接口？

答:用插入法进行排序代码如下

package test;

import java.util.*;

class insertsort

{

arraylist al;

public insertsort(int num,int mod)

{

al = new arraylist(num);

random rand = new random;

system.out.println(”the arraylist sort before:”);

for (int i=0;i

{

al.add(new integer(math.abs(rand.nextint()) % mod + 1));

system.out.println(”al[“+i+”]=”+al.get(i));

}

public void sortit()

{

integer tempint;

int maxsize=1;

for(int i=1;i

{

tempint = (integer)al.remove(i);

if(tempint.intvalue()>=((integer)al.get(maxsize-1)).intvalue())

{

al.add(maxsize,tempint);

maxsize++;

system.out.println(al.tostring());

} else {

for (int j=0;j

{

(((integer)al.get(j)).intvalue()>=tempint.intvalue())

{

al.add(j,tempint);

maxsize++;

system.out.println(al.tostring());

break;

}

system.out.println(”the arraylist sort after:”);

for(int i=0;i

{

system.out.println(”al[“+i+”]=”+al.get(i));

}

public static void main(string[] args)

{

insertsort is = new insertsort(10,100);

is.sortit();

}

篇8：阿里巴巴 java 面试题

1. 下列运算符中优先级别最高的是?

A：&

B：&&

C：!=

D：?：

2：若用数组S[0…n]作为两个栈S1和S2的存储结构，对任何一个栈只有当S全满时才不能做入栈操作。为这两个栈分配空间的最佳方案是

A：S1的栈底位置为0，S2的栈底位置为n+1

B：S1的栈底位置为0，S2的栈底位置为n/2

C：S1的栈底位置为1，S2的栈底位置为n/2

3. 经过强制类型转换以后，变量a，b的分别为

Short a =128;byte b =(byte)a;

A：128 127

B：128 -128

C：128 128

D：编译错误

4. Java 的Daemon线程，setDaemon设置必须要：

A：在Start之前

B：在Start之后

C：前后都可以

5. 下列不属于Java语言鲁棒性特点的是

A：java能程序在编译和运行时的错误

B：Java能运行虚拟机实现跨平台

C：Java自己操纵内存减少了内存出错的可能性

D：Java还实现了真数组，避免了覆盖数据类型的可能

6. 有以下一个对象：

public class DataObject implements Serializable{

private static int i=0;

private String word=””;

public void setWord(String word){

this.word=word;

}

public void set I(int i){

DataObject.i =I;

}

创建一个如下方式的

DataObject:DataObject object = new DataObject();

Object.setWord(“123”);object.setI(2);

将此对象序列化为文件，并在另外一个JVM中读取文件，进行反序列化，请问此时读出的DataObject对象中的word和i的值分别为：

A：”” ,0

B：”” ,2

C：”123” ,2

D：”123” ,0

7. 基于Servlet API如何实现转向时不在地址栏中显示转向后的地址?

A：redirect()

B：sendRedirect()

C：forward()

D：transform()

8. 假设有以下代码

String s=”hello”;

String t=”hello”;

Char c[] ={‘h’,’e’,’l’,’l’,o’’};

下列选项中返回false的语句是：

A：s.equals(t);

B：t.equals(c);

C：s==t;

D：t.equals(new String(“hello”));

9. 下面的代码运行的结果是：

class B extends Object{

static{

System.out.println(“Load B”);

}

public B(){

System.out.println(“Create B”);

}

class A extends B{

static{

System.out.println(“Load A”);

}

public A(){

System.out.println(“Create A”);

}

public class Testclass{

public static void main(String[] args) {

new A();

}

A：Load B à Create B à Load A à Create A

B：Load Bà Load A àCreate B àCreate A

C：Load B à Create B à Create A à Load A

D：Create B àCreate A àLoad B àLoad A

[阿里巴巴 java 面试题]

篇9：java应届生面试题

在公司当技术面试官几年间，从应届生到工作十几年的应聘者都遇到过。先表达一下我自己对面试的观点：

1.笔试、面试去评价一个人肯定是不够准确的，了解一个人最准确的方式就是“路遥知马力，日久见人心”。通过一、二个小时内的做题、交流，只是没有其他办法下进行的无奈之举，所以通过了面试不代表有多成功，没通过也不代表有多失败。

2.好的面试官本身交谈的时候就不应当把自己一个居高临下的角色上，应当把自己和应聘者当做两个做技术的人平等的交流，把自己当作权威往往就会受到观点的角度、语言表达、工作领域的惯性的制约。

3.好的考察题目则是大家能经常接触，不同层次的人能有不同层次的答案，能从问题引申出后面继续讨论的话题。

举个例子抛砖引玉，下面这个问题是我以前常问的，从应届生到工作十几年的人都问过：

引用

“地球人都知道，Java有个东西叫垃圾收集器，它让创建的对象不需要像c/cpp那样、free掉，你能不能谈谈，GC是在什么时候，对什么东西，做了什么事情?”

我自己分析一下这个问题，首先是“什么时候”，不同层次的回答从低到高排列：

1.系统空闲的时候。

分析：这种回答大约占30%，遇到的话一般我就会准备转向别的话题，譬如算法、譬如SSH看看能否发掘一些他擅长的其他方面。

2.系统自身决定，不可预测的时间/调用System.gc()的时候。

分析：这种回答大约占55%，大部分应届生都能回答到这个答案，起码不能算错误是吧，后续应当细分一下到底是语言表述导致答案太笼统，还是本身就只有这样一个模糊的认识。

3.能说出新生代、老年代结构，能提出minor gc/full gc

分析：到了这个层次，基本上能说对GC运作有概念上的了解，譬如看过《深入JVM虚拟机》之类的。这部分不足10%。

4.能说明minorgc/full gc的触发条件、OOM的触发条件，降低GC的调优的策略。

分析：列举一些我期望的回答：eden满了minor gc，升到老年代的对象大于老年代剩余空间full gc，或者小于时被HandlePromotionFailure参数强制full gc;gc与非gc时间耗时超过了GCTimeRatio的限制引发OOM，调优诸如通过NewRatio控制新生代老年代比例，通过 MaxTenuringThreshold控制进入老年前生存次数等……能回答道这个阶段就会给我带来比较高的期望了，当然面试的时候正常人都不会记得每个参数的拼写，我自己写这段话的时候也是翻过手册的。回答道这部分的小于2%。

PS：加起来不到100%，是因为有确实少数直接说不知道，或者直接拒绝回答的= =#

分析第二个问题：“对什么东西”：

1.不使用的对象。

分析：相当于没有回答，问题就是在问什么对象才是“不使用的对象”。大约占30%。

2.超出作用域的对象/引用计数为空的对象。

分析：这2个回答站了60%，相当高的比例，估计学校教java的时候老师就是这样教的。第一个回答没有解决我的疑问，gc到底怎么判断哪些对象在不在作用域的?至于引用计数来判断对象是否可收集的，我可以会补充一个下面这个例子让面试者分析一下obj1、obj2是否会被GC掉?

class C{

publicObject x;

}

C obj1、obj2= new C();

obj1.x = obj2;

obj2.x = obj1;

obj1、obj2= null;

3.从gcroot开始搜索，搜索不到的对象。

分析：根对象查找、标记已经算是不错了，小于5%的人可以回答道这步，估计是引用计数的方式太“深入民心”了。基本可以得到这个问题全部分数。

PS：有面试者在这个问补充强引用、弱引用、软引用、幻影引用区别等，不是我想问的答案，但可以加分。

4.从root搜索不到，而且经过第一次标记、清理后，仍然没有复活的对象。

分析：我期待的答案。但是的确很少面试者会回答到这一点，所以在我心中回答道第3点我就给全部分数。

最后由一个问题：“做什么事情”，这个问发挥的空间就太大了，不同年代、不同收集器的动作非常多。

1.删除不使用的对象，腾出内存空间。

分析：同问题2第一点。40%。

2.补充一些诸如停止其他线程执行、运行finalize等的说明。

分析：起码把问题具体化了一些，如果像答案1那样我很难在回答中找到话题继续展开，大约占40%的人。

补充一点题外话，面试时我最怕遇到的回答就是“这个问题我说不上来，但是遇到的时候我上网搜一下能做出来”。做程序开发确实不是去锻炼茴香豆的“茴”有几种写法，不死记硬背我同意，我不会纠语法、单词，但是多少你说个思路呀，要直接回答一个上网搜，我完全没办法从中获取可以评价应聘者的信息，也很难从回答中继续发掘话题展开讨论。建议大家尽量回答引向自己熟悉的，可讨论的领域，展现给面试官最擅长的一面。

3.能说出诸如新生代做的是复制清理、from survivor、to survivor是干啥用的、老年代做的是标记清理、标记清理后碎片要不要整理、复制清理和标记清理有有什么优劣势等。

分析：也是看过《深入JVM虚拟机》的基本都能回答道这个程度，其实到这个程度我已经比较期待了。同样小于10%。

4.除了3外，还能讲清楚串行、并行(整理/不整理碎片)、CMS等搜集器可作用的年代、特点、优劣势，并且能说明控制/调整收集器选择的方式。

分析：同上面2个问题的第四点。

最后介绍一下自己的背景，在一间不大不小的上市软件公司担任平台架构师，有3年左右的面试官经验，工作主要方向是大规模企业级应用，参与过若干个亿元级的项目的底层架构工作。

[java应届生面试题]