关于09年迅雷面试+笔试+上机题目的总结（解答来自网络）

一、笔试题：

A)JAVA基础多项选择题，比较简单，略

B)问答：
1）ajax原理、如何实现刷新数据及优点？

Ajax 基本上就是把 JavaScript 技术和XMLHttpRequest对象放在 Web 表单和服务器之间。当用户填写表单时，数据发送给一些 JavaScript 代码而不是直接发送给服务器。相反，JavaScript 代码捕获表单数据并向服务器发送请求。同时用户屏幕上的表单也不会闪烁、消失或延迟。换句话说，JavaScript 代码在幕后发送请求，用户甚至不知道请求的发出。更好的是，请求是异步发送的，就是说 JavaScript 代码（和用户）不用等待服务器的响应。因此用户可以继续输入数据、滚动屏幕和使用应用程序。

然后，服务器将数据返回 JavaScript 代码（仍然在 Web 表单中），后者决定如何处理这些数据。它可以迅速更新表单数据，让人感觉应用程序是立即完成的，表单没有提交或刷新而用户得到了新数据。JavaScript 代码甚至可以对收到的数据执行某种计算，再发送另一个请求，完全不需要用户干预！这就是XMLHttpRequest的强大之处。它可以根据需要自行与服务器进行交互，用户甚至可以完全不知道幕后发生的一切。结果就是类似于桌面应用程序的动态、快速响应、高交互性的体验，但是背后又拥有互联网的全部强大力量。

http://java.itpub.net/post/20968/186684

2）门面模式的解释、适用场合？
在许多开源的框架中都充分的利用了设计模式这一概念，Struts典型的MVC模式的化身，Spring是工厂模式和单例模式的充分体现。在项目开发中，能充分利用设计模式的思想来考虑问题，来解决问题，来通过代码去实现。不但可以提高 代码的质量，对程序的扩展，重用带来很大方便。其实我们项目中用设计模式编程就是加了一个封装层，减少客户必须处理的对象的数量。

在设计模式中一般都遵循这样的原则：

(1)按接口编程。

(2)尽量用聚合代替继承。

(3)找出变化并封装之。

上面主要讲了一些设计模式的作用和原则。接下来我要讲的是在实际项目中应用的比较多的其中一个模式----->门面模式（Facade），有的叫正面，外观模式，其实都是一个意识，都指的这个模式。它也是美国著名的四人帮（GOF）写的2 3种模式之一。

简单的理解：我们需要用一种比原有的方法更简单的方法与系统交互，或者说，我们需要以一种特殊的方式使用系统。主要是为子系统中的一组接口提供一个统一的接口。Facade模式定义了一个更高的接口，使子系统更加容易使用。它的 意图要求一个一致的高层接口。

我简单的用代码方式表现出来。我写的都是一些伪代码。主要是来讲清Facade的应用。

以简单的登录为例：

我们一般都会写一个DAO层，主要封装了数据库里增，删，该，查作用。

我们一般会写一个接口：简单声明一个方法。根据用户名和密码来从数据库中查找是否存在。

public interface UserDAO {
public abstract List findByUserName(Object userName,Object passWord);
public abstract List findByUserName(Object userName);
public abstract List findByUserPassword(Object userPassword);
public abstract List findByUserPortraitUrl(Object userPortraitUrl);
public abstract List findByEmail(Object email);
public abstract List findByUrl(Object url);
public abstract List findByRole(Object role);
}
然后再写一个接口的实现：public class UserDAOImp implements W3csTUserDAO {
public List findByUserName(Object userName,Object passWord){
//判断用户是否存在。存在返回一个list,反之为null.
}
public List findByUserName(Object userName){
//实现
}
public List findByUserPassword(Object userPassword){
//实现
}
public List findByUserPortraitUrl(Object userPortraitUrl){
//实现
}
public List findByEmail(Object email){
//实现
}
public List findByUrl(Object url){
//实现
}
public List findByRole(Object role){
//实现
}
}

我们一般应用门面模式是在业务层。我们在写一个业务方法：和上面一样先声明一个接口。

public interface UserService{
public boolean login(Stirng userName,String passWord);
}

写一个业务接口的实现。

public class UserServiceImp implements UserService{
private UserDAO userDao;
public void setUserDAO(UserDAO userDao){
this.userDao = userDao;
}
public UserDAO getUserDao(){
return userDao;
}
public boolean login(Stirng userName,String passWord){
if(userDao.findByUserName(userName,passWord)!=null){
//合法用户，登录成功。
}else{
//登录失败。
}
}
}
我们可以看到我们在业务层中对DAO层又进行了一层封装。这就是Facade模式的简单应用的场合，有人可能会想为什么不直接调用DAO层呢？因为在实际的应用中，也许DAO中的方法太多，而我们实际用到的方法只是其中的一个或几个，所有把业务中用到的方法在提出出来封装处理，对调用者来说也很方便，它不会直接接触到DAO，我们把DAO封装在Service层中是为了让各个层职责分明。这样做还有一个用处，我们可能还会对用户的登录信息进行记录，这是我们就可以在Service层中处理，以及事务等。之所以把它封装在业务层中，避免了用户直接对数据库DAO层的直接操作，对用户来说是透明的。这样就简单了实现了松耦合。

Facade模式可以应用于：

<1>不需要使用一个复杂系统的所有功能，而且可以创建一个新的类，包含访问系统的所用规则。如果只需要使用系统的部分功能，那么你为新类创建的API将比原有系统的API简单的多。

<2>希望封装或者隐藏原系统。

<3>希望使用原系统的功能，而且还希望增加一些附件功能。

/article/4341659.html

3）写6个linux常用命令？

su
su命令是最基本的命令之一，常用于不同用户间切换。例如，如果登录为 user1，要切换为user2，只要用如下命令：
$su user2
然后系统提示输入user2口令，输入正确的口令之后就可以切换到user2。完成之后就可以用exit命令返回到user1。
su命令的常见用法是变成根用户或超级用户。如果发出不带用户名的su命令 ，则系统提示输入根口令，输入之后则可切换为根用户。
如果登录为根用户，则可以用su命令成为系统上任何用户而不需要口令。
pwd
pwd命令也是最常用最基本的命令之一，用于显示用户当前所在的目录。
cd
cd命令不仅显示当前状态，还改变当前状态，它的用发跟dos下的cd命令基本一致。
cd ..可进入上一层目录
cd -可进入上一个进入的目录
cd ~可进入用户的home目录
ls
ls命令跟dos下的dir命令一样，用于显示当前目录的内容。
如果想取得详细的信息，可用ls -l命令， 这样就可以显示目录内容的详细信息。
如果目录下的文件太多，用一屏显示不了，可以用ls -l |more分屏显示 。
find
find命令用于查找文件。这个命令可以按文件名、建立或修改日期、所有者(通常是建立文件的用户)、文件长度或文件类型进行搜索。
find命令的基本结构如下：
$find
其中指定从哪个目录开始搜索。指定搜索条件。表示找到文件怎么处理。一般来说，要用-print动作，显示整个文件路径和名称。如果没有这个动作，则find命令进行所要搜索而不显示结果，等于白费劲。
例如，要搜索系统上所有名称为ye的文件，可用如下命令：
$find / -name ye -print
这样就可以显示出系统上所有名称为ye的文件。
tar
tar最初用于建立磁带备份系统，目前广泛用于建立文件发布档案。可用如下方法建立tar档案：
$tar cvf
例如，如果要将当前目录中所有文件存档到ye.tar中，可用如下命令：
$tar cvf ye.tar *.*
要浏览档案内容，将c选项变成t。如果要浏览ye.tar档案中的内容，可用如下命令：
$tar tvf ye.tar
要取出档案内的内容，将c选项变成x。如果要将ye.tar档案中的内容取到当前目录中，可用如下命令：
$tar xvf ye.tar
gzip
gzip命令用于压缩文件。 例如，如果要将ye.txt文件压缩，可用如下命令：
$gzip ye.txt
这样就可以压缩文件并在文件名后面加上gz扩展名，变成文件ye.txt.gz。
解压缩文件可用gzip -d命令实现：
$gzip -d ye.txt.gz
这样就可以解压缩文件并删除gz扩展名。除此之外还可以用gunzip命令来解压缩文件，效果跟用gzip -d命令一样。
旧版的tar命令不压缩档案，可用gzip压缩。例如：
$tar cvf ye.tar *.txt
$gzip ye.tar
则可建立压缩档案ye.tar.gz。
新版的tar可以直接访问和建立gzip压缩的tar档案，只要在tar命令中加上z 选项就可以了。例如：
$tar czvf ye.tar *.txt
生成压缩档案ye.tar.gz，
$tar tzvf ye.tar *.txt
显示压缩档案ye.tar.gz的内容，而
$tar xzvf ye.tar *.txt
取出压缩档案ye.tar.gz的内容。
mkdir
这个命令很简单，跟dos的md命令用法几乎一样，用于建立目录。
cp
cp命令用于复制文件或目录。
cp命令可以一次复制多个文件，例如：
$cp *.txt *.doc *.bak /home
将当前目录中扩展名为txt、doc和bak的文件全部复制到/home目录中。
如果要复制整个目录及其所有子目录，可以用cp -R命令。
rm
rm命令用于删除文件或目录。
rm命令会强制删除文件，如果想要在删除时提示确认，可用rm -i命令。
如果要删除目录，可用rm -r命令。rm -r命令在删除目录时，每删除一个文件或目录都会显示提示，如果目录太大，响应每个提示是不现实的。这时可以用 rm -rf命令来强制删除目录，这样即使用了-i标志也当无效处理。
mv
mv命令用于移动文件和更名文件。例如：
$mv ye.txt /home
将当前目录下的ye.txt文件移动到/home目录下，
$mv ye.txt ye1.txt
将ye.txt文件改名为ye1.txt。
类似于跟cp命令，mv命令也可以一次移动多个文件，在此不再赘叙。
reboot
重启命令，不必多说。
halt
关机命令，不必多说。

http://linux.chinaitlab.com/command/4641.html

4）SQL语句题，较简单

C)编程:

1）有三个线程ID分别是A、B、C,请有多线编程实现，在屏幕上循环打印10次ABCABC…

/*
*******************************************************************************
* Operation.java
*
*＜项目内容＞
* 项目名 ： ThreeThreads
*＜类名＞
* Operation
*＜功能概要＞
*
*＜更新履历＞
* 日期 版本 作成者 描述
* 2009-12-3 1.00 yanfengg 新规做成
*******************************************************************************
*/
package com.icyy.test;

/**
*
* [概 要]
* 描述一個操作的接口
* [详 细]
*
* [备 考]
*
* [环 境] J2SE 1.5
*
*
* @author Sidney Yang
* @version 1.0
*/
public interface Operation {

// 要執行的操作
public void run();
}

/*
*******************************************************************************
* Abc.java
*
*＜项目内容＞
* 项目名 ： ThreeThreads
*＜类名＞
* Abc
*＜功能概要＞
*
*＜更新履历＞
* 日期 版本 作成者 描述
* 2009-12-3 1.00 Sidney Yang 新规做成
*******************************************************************************
*/

package com.icyy.test;
import java.util.ArrayList;
import java.util.List;

/**
*
* [概 要]
* 將一系列操作分配給不同的線程并重複同步依次執行這些線程（操作）直到滿足退出條件。
* [详 细]
*
* [备 考]
*
* [环 境] J2SE 1.5
*
*
* @author Sidney Yang
* @version 1.0
*/
public class Abc{

// 用於存放所有線程的list.
private List operArray = new ArrayList();
// 線程計數器，每有一個線程被執行，自增1.
private int threadCounter = 0;

// 添加一個帶操作的線程
public void push(Operation oper){
operArray.add(new ThreadsWithOperation(oper));
}

// 啟動所有線程
public void start(){
for(ThreadsWithOperation thread : operArray){
thread.start();
}
}

/**
* 帶操作的線程類
* @author Sidney Yang
* @version 1.0
*/
class ThreadsWithOperation extends Thread{
// 表示一個操作的對象。
private Operation oper;

/**
* 用一個Operation得對象構造一個ThreadsWithOperation
* Constructors ThreadsWithOperation
* @param oper 表示一個操作的對象
*/
ThreadsWithOperation(Operation oper){
this.oper = oper;
}

/**
* 線程方法。執行流程為：
* 1.判斷是否輪到本線程執行，若不是，則跳到3步驟。
* 2.執行Operation對象里的操作，并將執行權移交給下一個線程。
* 3.喚醒所有等待線程并判斷是否滿足退出條件，如果不滿足則跳到步驟5。
* 4.將自己加入等待隊列。
* 5.結束
*
* @Create Date: 2009-12-3
* @author Sidney Yang
* @see java.lang.Thread#run()
*
*/
@Override
public void run(){
while(!Abc.this.readyToQuit()){
synchronized(Abc.this){
if(isMyTurn()){
oper.run();
turnNext();
}
Abc.this.notifyAll();
if(!Abc.this.readyToQuit()){
try {
Abc.this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}

/**
*
* 判斷是否輪到本線程執行
*
* @Create Date: 2009-12-3
* @author Sidney Yang
* @return 如果輪到本線程執行返回true，否則返回false
*
*/
private boolean isMyTurn(){
int threadIndex = Abc.this.operArray.indexOf(this);
return Abc.this.threadCounter % Abc.this.operArray.size() == threadIndex;
}

/**
*
* 將執行權交給下一個線程
*
* @Create Date: 2009-12-3
* @author Sidney Yang
*
*/
protected void turnNext(){
Abc.this.threadCounter++;
}
}
/**
*
* 此方法給出所有線程退出的條件，若返回true則所有線程結束，子類應根據情況重寫此方法。
*
* @Create Date: 2009-12-3
* @author Sidney Yang
* @return 若滿足線程結束條件返回true,否則返回false.
*
*/
protected boolean readyToQuit() {
return false;
}

/**
*
* 返回線程計數器
*
* @Create Date: 2009-12-3
* @author Sidney Yang
* @return 線程計數器的值
*
*/
public int getThreadCounter(){
return threadCounter;
}

/**
*
* 測試用main方法
*
* @Create Date: 2009-12-3
* @author Sidney Yang
* @param args 控制臺傳入的參數
*
*/
public static void main(String[] args){
Abc abc = new Abc(){

/**
* 重寫readyToQuit方法使3個線程各執行10次。
*
* @Create Date: 2009-12-3
* @author Sidney Yang
* @return 若滿足線程結束條件返回true,否則返回false.
* @see com.icyy.test.Abc#readyToQuit()
*
*/
@Override
public boolean readyToQuit() {
return this.getThreadCounter() >= 30;
}
};

abc.push(new Operation(){
public void run() {
System.out.print("A");
}
});
abc.push(new Operation(){
public void run() {
System.out.print("B");
}
});
abc.push(new Operation(){
public void run() {
System.out.print("C");
}
});

abc.start();
}
}

2）假如有字符串“6sabcsssfsfs33” ，用最有快速的方法去掉字符“ab3”，不能用java内置字符串方法（indeOf,substring,replaceAll等）？

package test;

public class Myreplace {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Myreplace.myReplaceAll("abcdefghhhhcedcdehabchhhh", "cde","!");
}

public static String myReplaceAll(String input,String regx,String rep)
{
// 特殊情况判断

char i [] = input.toCharArray();
char r [] = regx.toCharArray();
StringBuffer buf = new StringBuffer();
boolean b = false;
for(int k=0;kif(i.length-r.length>0)
{
for(int j=0;j是否匹配"+r[j]);
if(i[k+j]==r[j])
{
b=true;
}
else
{
b=false;
break;
}
}
}
if(b)
{
k+=regx.length()-1;
buf.append(rep);

}else
{
buf.append(i[k]);
}
}
System.out.println(input);
System.out.println(buf);
System.out.println(input.replace(regx, rep));

return input;
}

}二、上机题：
Java上机实现统计某一目录下每个文件中出现的字母个数、数字个数、空格个数及行数？

import java.io.*;
class Ex6_5 {
public static void main ( String[] args ) {
String fileName = "C:/Hello.txt" , line;
int i,j,f,k;

BufferedReader in = new BufferedReader(
new FileReader( fileName ) );
line = in.readLine(); //读取一行内容
while ( line != null ) {
int cU = 0 ;
int cL = 0 ;
int cN = 0 ;
char c ;
for(int i=0 ;iif(c > 'a' && c < 'z') {
cL ++ ;
}
else if(c > 'A' && c < 'Z') {
cU ++ ;
}
else {
cN ++ ;
}
line = in.readLine();
k++ ;
}
System.out.println("Number of LowerCase:" + cL) ;
System.out.println("Number of UpperCase:" + cU) ;
System.out.println("Number of NotChar:" + cN) ;
}

三、面试题：
1、说说JVM原理？内存泄露与溢出区别，何时产生内存泄露？

(1)Java 虚拟机
在Java中引入了虚拟机的概念，即在机器和编译程序之间加入了一层抽象的虚拟的机器。这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由解释器来将虚拟机代码转换为特定系统的机器码执行。在Java中，这种供虚拟机理解的代码叫做字节码(ByteCode)，它不面向任何特定的处理器，只面向虚拟机。每一种平台的解释器是不同的，但是实现的虚拟机是相同的。Java源程序经过编译器编译后变成字节码，字节码由虚拟机解释执行，虚拟机将每一条要执行的字节码送给解释器，解释器将其翻译成特定机器上的机器码，然后在特定的机器上运行。
可以说，Java虚拟机是Java语言的基础。它是Java技术的重要组成部分。Java虚拟机是一个抽象的计算机，和实际的计算机一样，它具有一个指令集并使用不同的存储区域。它负责执行指令，还要管理数据、内存和寄存器。Java解释器负责将字节代码翻译成特定机器的机器代码。Java是一种简单的语言。它用到的概念不多，而且多为程序员所熟悉。如果你是一名程序员，掌握Java对你来说是易如反掌的事。即使你没有学过任何编程语言，学习Java也要比学习C++要容易的多。
由于Java最初是为控制电子产品设计的，因此它必须简单明了。为了保证这种简单性，Java去掉了C++中许多复杂的、冗余的、有二义性的概念，例如操作符重载、多继承、数据类型自动转换等。为了将程序员从复杂的内存管理的负担中解脱出来，同时也是为了减少错误，Java使用了自动内存垃圾收集机制，程序员只要在需要的时候申请即可，不需要释放,而由Java自己来收集、释放内存中的无用的块。
与C++相比，Java有着更强的面向对象特性，是一种比较纯粹的面向对象语言。一般我们使用的一些所谓的面向对象的编程语言，如C++，Object Pascal等，实际上都是一种混合型的语言，即在过程式的语言中加上面向对象的扩展。在Java中，几乎万物皆对象，就连一些基本数据类型，如整型、字符型、浮点型等，在Java中都可以作为对象处理。Java的面向对象特性几乎可以与Smalltalk媲美，但是其适用于分布式计算环境的特性却远远超过了Smalltalk。
Java是一种支持分布式操作的程序设计语言。使用Java提供的URL类，用户可以象访问本地文件一样访问网络上的对象，使用非常方便。在客户机/服务器的模式下，Java还可以将运算从服务器端分散到客户端，提高系统的效率，避免了服务器的瓶颈制约。Java的网络类库支持分布式的编程。Socket类提供可靠的流式网络的连接，支持TCP/IP协议。通过编写协议句柄，程序员还可以扩充 Java支持的协议集合。
Java提供非常有效的安全控制。由于Java应用于网络程序的开发，因而安全性变的至关重要。因为Java小程序需要下载到客户端解释执行，所以，如果没有安全控制，就会给一些网络黑客以可乘之机，这对用户来说是非常危险的。所幸的是，Java的安全机制可以有效的防止病毒程序的产生、下载程序对本地文件系统的破坏，以及网络黑客窃取密码和入侵。
Java是一种非常健壮的语言。因为在Java中使用了以下手段：
不支持指针。在C++程序中，指针的错误使用通常的程序中BUG的元凶。在Java中彻底去掉了指针，杜绝了内存的非法访问，从而保证了程序的可靠性。
强类型语言
自动内存垃圾收集机制。Java自动收集无用的内存单元，进而防止了由于内存泄漏导致的动态内存分配问题。
完善的异常处理机制，既简化了错误处理任务和恢复，也增加了程序的可读性。
Java具有非常好的平台无关性和可移植性。因为Java最初是为对电子产品编程而设计的，所以它具有完美的平台无关性。它使用一种与平台无关的代码──字节码，而不是通常的特定机器上的机器码，由平台上的Java虚拟机中的Java解释器解释执行。Java虚拟机是免费的，在许多平台上都有。
Java提供了良好的可移植性。使用Java作为编程语言，只要进行一次程序开发工作，所开发的程序不需要经过任何改动，便能在各种平台上运行。Java使用两种方法使Java的应用程序不依赖与具体的系统：
采用基于国际标准的数据类型。Java的原始数据类型在任何机器上都是一样的，例如整型总是32位，长整型总是64位等。
提供了一个用于访问底层操作系统功能的可扩展类库。
Java是一种高性能的语言。“鱼与熊掌不可兼得”，通常，健壮性、安全性、平台无关性、可移植性等方面的提高总是要以牺牲性能为代价的。Java也不例外，Java的内存管理增加了运行时系统的复杂性，因为Java运行时系统必须内嵌一个内存管理模块;同样，Java程序的解释执行的效率也要低于直接执行编译后的源码的效率。但是Java采用了一些很好的措施来弥补这些性能上的差距：
生成高效的字节码。Java字节码的设计充分考虑了性能的因素，字节码的格式简单，解释器可以生成高效的机器码。
提供了即时编译和嵌入C代码的可选措施。即时编译是指在运行时把字节码编译成机器码。支持多线程。Java提供了对多线程的语言级的接口，而且Java环境本身就是多线程的。
Java对多线程有良好的支持。多线程技术可以提高程序执行的并发度，提高图形用户界面的交互性能。Java提供了语言内置的多线程控制，简化了多线程应用程序的开发，还支持线程的同步控制。
Java是一种动态的语言。动态特性是面向对象特性的一个延伸，它使得程序能够适应不断变化的执行环境。Java的动态性主要表现在以下几个方面：
Java的类有运行时的表示，这样，即使在运行时刻，程序也能辨别类之间的关系和类型信息，可以动态的从本地或网上把一个类链接到运行系统中去。
Java的类在运行过程中动态的装载，因此，Java可以在分布式的环境中动态的维护应用程序和Java类库之间的一致性。当类库升级后，应用程序无需重新编译，也一样可以利用新类库中新增的功能。
支持动态数据类型和动态协议。通过编写协议句柄，Java可以支持新的、自定义的传输协议，编写内容句柄，可以支持新的数据类型。

http://www.029accp.com/bbs/dispbbs.asp?boardid=11&Id=49

(2)内存泄露

内存泄漏指由于疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。内存泄漏与许多其他问题有着相似的症状，并且通常情况下只能由那些可以获得程序源代码的程序员才可以分析出来。然而，有不少人习惯于把任何不需要的内存使用的增加描述为内存泄漏，即使严格意义上来说这是不准确的。
一般我们常说的内存泄漏是指堆内存的泄漏。堆内存是指程序从堆中分配的，大小任意的（内存块的大小可以在程序运行期决定），使用完后必须显示释放的内存。应用程序一般使用malloc，realloc，new等函数从堆中分配到一块内存，使用完后，程序必须负责相应的调用free或delete释放该内存块，否则，这块内存就不能被再次使用，我们就说这块内存泄漏了。
内存泄漏可以分为4类：
1. 常发性内存泄漏。发生内存泄漏的代码会被多次执行到，每次被执行的时候都会导致一块内存泄漏。
2. 偶发性内存泄漏。发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。常发性和偶发性是相对的。对于特定的环境，偶发性的也许就变成了常发性的。所以测试环境和测试方法对检测内存泄漏至关重要。
3. 一次性内存泄漏。发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块仅且一块内存发生泄漏。比如，在一个Singleton类的构造函数中分配内存，在析构函数中却没有释放该内存。而Singleton类只存在一个实例，所以内存泄漏只会发生一次。
4. 隐式内存泄漏。程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。严格的说这里并没有发生内存泄漏，因为最终程序释放了所有申请的内存。但是对于一个服务器程序，需要运行几天，几周甚至几个月，不及时释放内存也可能导致最终耗尽系统的所有内存。所以，我们称这类内存泄漏为隐式内存泄漏。

内存泄漏会因为减少可用内存的数量从而降低计算机的性能。最终，在最糟糕的情况下，过多的可用内存被分配掉导致全部或部分设备停止正常工作，或者应用程序崩溃。
内存泄漏可能不严重，甚至能够被常规的手段检测出来。在现代操作系统中，一个应用程序使用的常规内存在程序终止时被释放。这表示一个短暂运行的应用程序中的内存泄漏不会导致严重后果。
在以下情况，内存泄漏导致较严重的后果：
* 程序运行后置之不理，并且随着时间的流失消耗越来越多的内存（比如服务器上的后台任务，尤其是嵌入式系统中的后台任务，这些任务可能被运行后很多年内都置之不理）；
* 新的内存被频繁地分配，比如当显示电脑游戏或动画视频画面时；
* 程序能够请求未被释放的内存（比如共享内存），甚至是在程序终止的时候；
* 泄漏在操作系统内部发生；
* 泄漏在系统关键驱动中发生；
* 内存非常有限，比如在嵌入式系统或便携设备中；
* 当运行于一个终止时内存并不自动释放的操作系统（比如AmigaOS）之上，而且一旦丢失只能通过重启来恢复。

(3)内存溢出

内存溢出已经是软件开发历史上存在了近40年的“老大难”问题，象在“红色代码”病毒事件中表现的那样，它已经成为黑客攻击企业网络的“罪魁祸首”。 如在一个域中输入的数据超过了它的要求就会引发数据溢出问题，多余的数据就可以作为指令在计算机上运行。据有关安全小组称，操作系统中超过50%的安全漏洞都是由内存溢出引起的，其中大多数与微软的技术有关。
为了便于理解，我们不妨打个比方。缓冲区溢出好比是将十磅的糖放进一个只能装五磅的容器里。一旦该容器放满了，余下的部分就溢出在柜台和地板上，弄得一团糟。由于计算机程序的编写者写了一些编码，但是这些编码没有对目的区域或缓冲区——五磅的容器——做适当的检查，看它们是否够大，能否完全装入新的内容——十磅的糖，结果可能造成缓冲区溢出的产生。如果打算被放进新地方的数据不适合，溢得到处都是，该数据也会制造很多麻烦。但是，如果缓冲区仅仅溢出，这只是一个问题。到此时为止，它还没有破坏性。当糖溢出时，柜台被盖住。可以把糖擦掉或用吸尘器吸走，还柜台本来面貌。与之相对的是，当缓冲区溢出时，过剩的信息覆盖的是计算机内存中以前的内容。除非这些被覆盖的内容被保存或能够恢复，否则就会永远丢失。
在丢失的信息里有能够被程序调用的子程序的列表信息，直到缓冲区溢出发生。另外，给那些子程序的信息——参数——也丢失了。这意味着程序不能得到足够的信息从子程序返回，以完成它的任务。就像一个人步行穿过沙漠。如果他依赖于他的足迹走回头路，当沙暴来袭抹去了这些痕迹时，他将迷失在沙漠中。这个问题比程序仅仅迷失方向严重多了。入侵者用精心编写的入侵代码（一种恶意程序）使缓冲区溢出，然后告诉程序依据预设的方法处理缓冲区，并且执行。此时的程序已经完全被入侵者操纵了。
入侵者经常改编现有的应用程序运行不同的程序。例如，一个入侵者能启动一个新的程序，发送秘密文件（支票本记录，口令文件，或财产清单）给入侵者的电子邮件。这就好像不仅仅是沙暴吹了脚印，而且后来者也会踩出新的脚印，将我们的迷路者领向不同的地方，他自己一无所知的地方。
缓冲区溢出的处理
你屋子里的门和窗户越少，入侵者进入的方式就越少……
由于缓冲区溢出是一个编程问题，所以只能通过修复被破坏的程序的代码而解决问题。如果你没有源代码，从上面“堆栈溢出攻击”的原理可以看出，要防止此类攻击，我们可以：
1、开放程序时仔细检查溢出情况，不允许数据溢出缓冲区。由于编程和编程语言的原因，这非常困难，而且不适合大量已经在使用的程序；
2、使用检查堆栈溢出的编译器或者在程序中加入某些记号，以便程序运行时确认禁止黑客有意造成的溢出。问题是无法针对已有程序，对新程序来讲，需要修改编译器；
3、经常检查你的操作系统和应用程序提供商的站点，一旦发现他们提供的补丁程序，就马上下载并且应用在系统上，这是最好的方法。但是系统管理员总要比攻击者慢一步，如果这个有问题的软件是可选的，甚至是临时的，把它从你的系统中删除。举另外一个例子，你屋子里的门和窗户越少，入侵者进入的方式就越少-------------------------------------------------------------------------------------------------------------------------

2、用java怎么实现有每天有1亿条记录的DB存储？mysql上亿记录数据量的数据库如何设计？

3、mysql支持事务吗？DB存储引擎有哪些？

可以，配置My.ini
我的my.ini是从my-small.ini重命名来的，也没有更改里面原有的任何配置。
看英文提示，将下面的原本注释掉的行打开，再修改了一下目录即可。

# Uncomment the following if you are using InnoDB tables
innodb_data_home_dir = D:/JAVA/mysql-5.0.27-win32/data
innodb_data_file_path = ibdata1:10M:autoextend
innodb_log_group_home_dir = D:/JAVA/mysql-5.0.27-win32/data
innodb_log_arch_dir = D:/JAVA/mysql-5.0.27-win32/data
# You can set .._buffer_pool_size up to 50 - 80 %
# of RAM but beware of setting memory usage too high
innodb_buffer_pool_size = 16M
innodb_additional_mem_pool_size = 2M
# Set .._log_file_size to 25 % of buffer pool size
innodb_log_file_size = 5M
innodb_log_buffer_size = 8M
innodb_flush_log_at_trx_commit = 1
innodb_lock_wait_timeout = 50配置完毕，启动Mysql，会发现，D:/JAVA/mysql-5.0.27-win32/data【innodb_data_home_dir】
多了ibdata1，ib_logfile0，ib_logfile1三个文件。

2. 创建InnoDB表

mysql> drop database iwoo;
Query OK, 1 row affected (0.08 sec)

mysql> create database iwoo;
Query OK, 1 row affected (0.02 sec)

mysql> use iwoo;
Database changed
mysql> create table article (id bigint(20), title varchar(50)) type=InnoDB;
Query OK, 0 rows affected, 1 warning (0.08 sec)

mysql> show table status from iwoo;
+---------+--------+
| Name | Engine |
+---------+--------+
| article | InnoDB |
+---------+--------+
1 row in set (0.00 sec)

3. 转换 MyISAM与InnoDB

mysql> drop database iwoo;
Query OK, 1 row affected (0.36 sec)

mysql> create database iwoo;
Query OK, 1 row affected (0.00 sec)

mysql> use iwoo;
Database changed
mysql> create table article (id bigint(20), title varchar(50));
Query OK, 0 rows affected (0.05 sec)

mysql> show table status from iwoo;
+---------+--------+
| Name | Engine |
+---------+--------+
| article | MyISAM |
+---------+--------+
1 row in set (0.00 sec)

mysql> alter table article type=InnoDB;
Query OK, 0 rows affected, 1 warning (0.47 sec)
Records: 0 Duplicates: 0 Warnings: 0

mysql> show table status from iwoo;
+---------+--------+
| Name | Engine |
+---------+--------+
| article | InnoDB |
+---------+--------+
1 row in set (0.00 sec)

mysql> alter table article type = MyISAM;
Query OK, 0 rows affected, 1 warning (0.11 sec)
Records: 0 Duplicates: 0 Warnings: 0

mysql> show table status from iwoo;
+---------+--------+
| Name | Engine |
+---------+--------+
| article | MyISAM |
+---------+--------+
1 row in set (0.00 sec)

4。测试事务

mysql> begin;
Query OK, 0 rows affected (0.00 sec)

mysql> insert into article values(1,'z');
Query OK, 1 row affected (0.00 sec)

mysql> select * from article;
+------+-------+
| id | title |
+------+-------+
| 1 | z |
+------+-------+
1 row in set (0.00 sec)

mysql> rollback;
Query OK, 0 rows affected (0.05 sec)

mysql> select * from article;
Empty set (0.00 sec)
补充：存储引擎

存储引擎是什么?

MySQL中的数据用各种不同的技术存储在文件(或者内存)中。这些技术中的每一种技术都使用不同的存储机制、索引技巧、锁定水平并且最终提供广泛的不同的功能和能力。通过选择不同的技术，你能够获得额外的速度或者功能，从而改善你的应用的整体功能。

例如，如果你在研究大量的临时数据，你也许需要使用内存存储引擎。内存存储引擎能够在内存中存储所有的表格数据。又或者，你也许需要一个支持事务处理的数据库(以确保事务处理不成功时数据的回退能力)。

这些不同的技术以及配套的相关功能在MySQL中被称作存储引擎(也称作表类型)。MySQL默认配置了许多不同的存储引擎，可以预先设置或者在MySQL服务器中启用。你可以选择适用于服务器、数据库和表格的存储引擎，以便在选择如何存储你的信息、如何检索这些信息以及你需要你的数据结合什么性能和功能的时候为你提供最大的灵活性。

选择如何存储和检索你的数据的这种灵活性是MySQL为什么如此受欢迎的主要原因。其它数据库系统(包括大多数商业选择)仅支持一种类型的数据存储。遗憾的是，其它类型的数据库解决方案采取的“一个尺码满足一切需求”的方式意味着你要么就牺牲一些性能，要么你就用几个小时甚至几天的时间详细调整你的数据库。使用MySQL，我们仅需要修改我们使用的存储引擎就可以了。http://topinking.javaeye.com/blog/249040

4、mvc原理，mvc模式的优缺点,如果让你设计你会怎么改造MVC？



5、hibernate支持集群吗？如何实现集群？

Hibernate本身是对JDBC的轻量级封装，他无所谓集群不集群，和集群没有直接的关系，就好像你说JDBC支持不支持集群一样。不过Hibernate可以被用于集群环境中，只不过在集群环境中，有些东西是不能用的，像read-write cache。
6、tomcat 最多支持并发多少用户？

500左右
7、map原理，它是如何快速查找key的？map与set区别？

java.util 中的集合类包含 Java 中某些最常用的类。 最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象元素列表。 List 适用于按数值索引访问元素的情形。

Set接口
Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。
Map接口
请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。 从概念上而言，您可以将 List 看作是具有数值键的 Map。而实际上，除了 List 和 Map 都在定义 java.util 中外，两者并没有直接的联系。本文将着重介绍核心 Java 发行套件中附带的 Map，同时还将介绍如何采用或实现更适用于您应用程序特定数据的专用 Map。

http://www.oracle.com/technology/global/cn/pub/articles/maps1.html

8、描术算法，如何有效合并两个文件：一个是1亿条的用户基本信息，另一个是用户每天看电影连续剧等的记录，5000万条。内存只有1G？？？

核心算法就是归并算法。算法基本如下描述：
操作系统块大小是B字节（这个块是有效块,是人为规定，一般是4的倍数较为高效）。
主存是1*1024*1024*1024字节，设为M
记录占用R字节。
填满内存须要M/B次，一个块用于临时交互，那么一次可以为M/B-1个快集合填充。
得出B/R等于多少？用这个值进行划分记录。大约出现N个有限集合。
最后使用归并算法对N个集合进行归并。使用两趟归并算法就是TB数据集。基本够用。
说简单，实现也要一段时间，参考数据库大型算法中的多路归并就解决了。
9、在1亿条用户记录里，如何快速查询统计出看了5个电影以上的用户？
10、Spring如何实现IOC与AOP的，说出实现原理？

在J2EE的整个发展历程中，现在正是一个非常时刻。从很多方面来说，J2EE都是一个伟大的成功：它成功地在从前没有标准的地方建立了标准；大大提升了企业级软件的开放程度，并且得到了整个行业和开发者的广泛认可。然而，J2EE在一些方面已经开始捉襟见肘。J2EE应用开发的成本通常很高。J2EE应用项目至少和从前的非J2EE项目一样容易失败——如果不是更容易失败的话。这样的失败率高得让人难以接受。在这样的失败率之下，软件开发几乎变成了碰运气。而在J2EE遭遇失败的场景中，EJB通常都扮演着重要的角色。因此，J2EE社群不断地向着更简单的解决方案、更少使用EJB的方向发展[1]。然而，每个应用程序都需要一些基础设施，拒绝使用EJB并不意味着拒绝EJB所采用的基础设施解决方案。那么，如何利用现有的框架来提供这些基础设施服务呢，伴随着这个问题的提出，一个轻量级的J2EE解决方案出现了，这就是Spring Framework。

Spring是为简化企业级系统开发而诞生的，Spring框架为J2EE应用常见的问题提供了简单、有效的解决方案，使用Spring，你可以用简单的POJO(Plain Old Java Object)来实现那些以前只有EJB才能实现的功能。这样不只是能简化服务器端开发，任何Java系统开发都能从Spring的简单、可测试和松耦合特征中受益。可以简单的说，Spring是一个轻量级的反向控制（IoC）和面向切面编程（AOP）容器框架[3]。Spring IoC，借助于依赖注入设计模式，使得开发者不用理会对象自身的生命周期及其关系，而且能够改善开发者对J2EE模式的使用；Spring AOP，借助于Spring实现的拦截器，开发者能够实现以声明的方式使用企业级服务，比如安全性服务、事务服务等。Spring IoC和 Spring ; AOP组合，一起形成了Spring，这样一个有机整体，使得构建轻量级的J2EE架构成为可能，而且事实证明，非常有效。没有Spring IoC的Spring AOP是不完善的，没有Spring AOP的Spring IoC是不健壮的。本文是以Spring架构的成功的实际商务系统项目为背景，阐述了反向控制原理和面向切面的编程技术在Spring框架中的应用，同时抽取适量代码示意具体应用，并和传统开发模式进行对比，展示了Spring framework的简单，高效，可维护等优点。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/watson243671/archive/2009/12/20/5044709.aspx