（1）、java.lang.String split

String value = "a,b,c,d,e";

String[] names = value.split(",");

for(int i=0,n=names.length;i

System.out.print(names[i]);

}

public String[] split(String regex)其中的参数，表示正则表达式。

（2）、设置页面不缓存信息（在过滤器中设置）

httpResponse.setHeader("Cache-Control", "no-cache");

       httpResponse.setHeader("Cache-Control", "no-store");

       httpResponse.setDateHeader("Expires", 0);

package com.wyq.WebFilter;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.struts.Globals;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionMessage;
import org.apache.struts.action.ActionMessages;

public class ContextFilter implements Filter{
    private String onErrorUrl;
    private FilterConfig filterConfig;
    public void destroy() {
        // TODO Auto-generated method stub
        
    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain doFilter) throws IOException, ServletException {
        HttpServletRequest httpRequest=(HttpServletRequest)request;
        HttpServletResponse httpResponse=(HttpServletResponse)response;
        HttpSession httpSession=httpRequest.getSession();
        httpResponse.setHeader("Cache-Control", "no-cache");
        httpResponse.setHeader("Cache-Control", "no-store");
        httpResponse.setDateHeader("Expires", 0);
        
        if(httpSession.getAttribute("epAccountInfo")==null){
            ActionErrors errors=new ActionErrors();
            errors.add(ActionMessages.GLOBAL_MESSAGE,new ActionMessage("没有登陆"));
            httpRequest.setAttribute(Globals.ERROR_KEY,errors);
            httpRequest.getRequestDispatcher(onErrorUrl).forward(httpRequest, httpResponse);
        }else{
            doFilter.doFilter(request, response);
        }
        
    }

    public void init(FilterConfig config) throws ServletException {
        filterConfig=config;
        onErrorUrl=filterConfig.getInitParameter("onError");
        if(onErrorUrl==null||"".equals(onErrorUrl)){
            onErrorUrl="onError";
        }
    }
    
}

第二，Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

　可以继承其他类或完成其他接口，在swing编程中常用此方式。　

第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统)。

　Static Nested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。　　

第四，&和&&的区别。

 　&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）.　　

第五，HashMap和Hashtable的区别。

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

第六，Collection 和 Collections的区别。
　　
　Collection是集合类的上级接口，继承与他的接口主要有Set 和List.Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。　　

第七，什么时候用assert。

　1.4新增关键字（语法），用于测试boolean表达式状态，可用于调试程序。使用方法 assert ，表示如果表达式为真（true）,则下面的语句执行，否则抛出AssertionError。另外的使用方式assert < boolean表达式>:，表示如果表达式为真，后面的表达式忽略，否则后面表达式的值用于AssertionError的构建参数。注意编译时要增加-source 1.4 参数，否则报错。]运行时要增加 –ea参数，否则assert行被忽略　　

第八，GC是什么? 为什么要有GC?
　　
　GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以 自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。 　　

第九，String s = new String("xyz");创建了几个String Object?

　两个　　

第十，Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

　Math.round(11.5)==12Math.round(-11.5)==-11round方法返回与参数最接近的长整数，参数加1/2后求其floor.　　

第十一，short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

　short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）short s1 = 1; s1 += 1;（可以正确编译）　　

第十二，sleep() 和 wait() 有什么区别?

　sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用 sleep不会释放对象锁。wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对 象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。　　

第十三，Java有没有goto?

　没有　　很十三的问题，如果哪个面试的问到这个问题，我劝你还是别进这家公司。

第十四，数组有没有length()这个方法? String有没有length()这个方法？

　数组没有length()这个方法，有length的属性。
　String有有length()这个方法。

第十五，Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

　方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现， 重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方 法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

第十八，error和exception有什么区别?

　error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。
　exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

第十九，List, Set, Map是否继承自Collection接口?

List，Set是
Map不是

第二十，abstract class和interface有什么区别?

　声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

　接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个 有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。 然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到 接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

第二十一，abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?

都不能

第二十二，接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

　接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。

第二十三，启动一个线程是用run()还是start()?

　启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

第二十四，构造器Constructor是否可被override?

　构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

第二十五，是否可以继承String类?

　String类是final类故不可以继承。

第二十六，当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

　不能，一个对象的一个synchronized方法只能由一个线程访问。

第二十七，try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

会执行，在return前执行。

第二十八，编程题: 用最有效率的方法算出2乘以8等於几?

有C背景的程序员特别喜欢问这种问题。
2 << 3

第二十九，两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?

不对，有相同的hash code。

第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

　是值传递。Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?

　switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。

第三十二，编程题: 写一个Singleton出来。

     Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
一般Singleton模式通常有几种种形式:

　第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

public class Singleton { 　　private Singleton(){} 　　//在自己内部定义自己一个实例，是不是很奇怪？ 　　//注意这是private 只供内部调用 　　private static Singleton instance = new Singleton(); 　　//这里提供了一个供外部访问本class的静态方法，可以直接访问　　 　　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的。
一般认为第一种形式要更加安全些

        六、wait()和notify()、notifyAll() 
        这三个方法用于协调多个线程对共享数据的存取，所以必须在Synchronized语句块内使用这三个方法。前面说过Synchronized这个关键字用于保护共享数据，阻止其他线程对共享数据的存取。但是这样程序的流程就很不灵活了，如何才能在当前线程还没退出Synchronized数据块时让其他线程也有机会访问共享数据呢？此时就用这三个方法来灵活控制。

wait()方法使当前线程暂停执行并释放对象锁标志，让其他线程可以进入Synchronized数据块，当前线程被放入对象等待池中。当调用 notify()方法后，将从对象的等待池中移走一个任意的线程并放到锁标志等待池中，只有锁标志等待池中的线程能够获取锁标志；如果锁标志等待池中没有线程，则notify()不起作用。

notifyAll()则从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中。

OutputStreamWriter out = ...
java.sql.Connection conn = ...
try {
　Statement stat = conn.createStatement();
　ResultSet rs = stat.executeQuery(
　　"select uid, name from user");
　while (rs.next())
　{
　　out.println("ID：" + rs.getString("uid") + "，姓名: "                                      + rs.getString("name"));
　}
}
catch(SQLException sqlex)
{
　out.println("警告：数据不完整");
　throw new ApplicationException("读取数据时出现SQL错误", sqlex);
}
catch(IOException ioex)
{
　throw new ApplicationException("写入数据时出现IO错误", ioex);
}
finally
{
　if (conn != null) {
　　try {
　　　conn.close();
　　}
　　catch(SQLException sqlex2)
　　{
　　　System.err(this.getClass().getName() + ".mymethod - 不能关闭数据库连接:                               " + sqlex2.toString());
　　}
　}

　if (out != null) {
　　try {
　　　out.close();
　　}
　　catch(IOException ioex2)
　　{
　　　System.err(this.getClass().getName() + ".mymethod - 不能关闭输出文件"              + ioex2.toString());
　　}
　}
}

import javax.xml.rpc.encoding.XMLType;

import org.apache.axis.client.Call;
import org.apache.axis.client.Service;

public class TestWebservice {
 public String sendAjax(){
  String result="";
  String url="";
  try{
   //创建一个服务
   Service service=new Service();
   //建立服务调用实例
   Call call=(Call)service.createCall();
   
   url="http://localhost:8000/webService/services/TestService";
   //设定调用路径
   call.setTargetEndpointAddress(url);
   //设定调用方法
   call.setOperation("helloWord");
   //设定返回类型
   call.setReturnType(XMLType.XSD_STRING);
   //开始调用
   result=(String)call.invoke(new Object[] {});
  }catch(Exception e){
   e.printStackTrace();
  }
  return result;
 }
}

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.TagSupport;

public class Hello extends TagSupport{

 @Override
 public int doStartTag() throws JspException {
   //从页面获取request,得到页面的值
   ServletRequest request = pageContext.getRequest();
  String str="www.wyq.cn";
  //在servlet中打印要使用printWriter
  //如果在标签中打印需要使用pageContext
  JspWriter out=pageContext.getOut();
  try{
   out.print(str);
  }catch(Exception e){
   e.printStackTrace();
  }
  //只要打印完了字符串，则后面的代码就不需要执行了
  
  return TagSupport.SKIP_BODY;
 }

}

tld文件的配置：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" "web-jsptaglibrary_1_2.dtd" >
<taglib>
  <tlib-version>1.0</tlib-version>
  <jsp-version>2.0</jsp-version>
  <short-name>hello</short-name>
  <tag>
    <name>mldn</name>
    <tag-class>com.wyq.TagTest.Hello</tag-class>
    <body-content>empty</body-content>
  </tag>
</taglib>

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Properties;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class Example {
 //建立一个静态的工场对象
 private static SessionFactory session_factory = null;
 //建立一个存储配置文件的对象--properties
 private static Properties pops=new Properties();
 //取得配置文件路径,配置文件存放在class路径下
 private static String path=Example.class.getClassLoader().getResource("").getPath()+"hibernate.properties";
 //建立一个静态方法，用来读取配置文件---hibernate.properties,在static静态方法中只能引用静态变量
 static{
  try{
   String s=path.substring(1,path.length());
   //读取配置文件
   InputStream stream= new FileInputStream(s);
   //如果配置文件和类放在同一个目录下，这种情况不建议使用
   InputStream streams=Example.class.getResourceAsStream("hibernate.properties");
   //将配置文件存储在pops中
   pops.load(stream);
   //建立配置文件管理对象
   Configuration cfg=new Configuration();
   //将Person添加到cfg中，类似于将xxx.hbm.xml写在hibernate.hbm.xml中
   cfg.addClass(Person.class);
   //将pops添加到cfg中，就是hiberante.hbm.xml
   cfg.setProperties(pops);
   //建立对象工厂
   session_factory=cfg.buildSessionFactory();
  }catch(Exception e){
   e.printStackTrace();
  }
 }
 public static void main(String[] args)throws HibernateException{
  Person person=new Person();
  person.setName("wyq");
  person.setEmail("hibernate.com.cn");
  
  //取得一个session,获得连接
  Session session=session_factory.openSession();
  //定义一个事务
  Transaction tx=null;
  try{
   //开启一个事务
   tx=session.beginTransaction();
           //具体业务操作
   session.save(person);
   tx.commit();
   
  }catch(HibernateException ex){
   if(tx!=null){
    tx.rollback();
   }
  }
  finally{
   session.close();
  }
 }
}

package com.wyq.test;

import java.net.URL;
import java.util.*;

public class PropertyReader {
    public static Properties getProperties(String propertyFile) {
        try {
            URL url = getPropertiesURL(propertyFile);
            return getProperties(url);
        }
        catch (Exception e) {
            return null;
        }
    }

    public static URL getPropertiesURL(String fileName) {
        try {
            URL url = null;
            url = PropertyReader.class.getResource("/" + fileName);
            String s = url.toString();
            return url;
        }
        catch (Exception e) {
            return null;
        }
    }
    public static Properties getProperties(URL url) {
        try {
            Properties props = new Properties();
            props.load(url.openStream());
            return props;
        }
        catch (Exception e) {
            return null;
        }
    }
}

private java.util.Timer timer;
timer = new Timer(true);
timer.schedule(
new java.util.TimerTask() { public void run() { //server.checkNewMail(); 要操作的方法 } }, 0, 5*60*1000); 
      第一个参数是要操作的方法，第二个参数是要设定延迟的时间，第三个参数是周期的设定，每隔多长时间执行该操作。

    使用这几行代码之后，Timer本身会每隔5分钟调用一遍server.checkNewMail()方法，不需要自己启动线程。Timer本身也是多线程同步的，多个线程可以共用一个Timer，不需要外部的同步代码。

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.Scheduler;
import org.springframework.web.context.WebApplicationContext;

public class ReceiveJobd implements Job{
 public void ReceiveJobd(){
 }
 //作业具体实现的功能
 public void execute(JobExecutionContext context) throws
    JobExecutionException {
     try {
           
            //建立JobDataMap对象，用来接收传递的参数
            JobDataMap dataMap = context.getMergedJobDataMap();
            int ipLength = dataMap.getInt("ipLength");
            int tablenameLength = dataMap.getInt("tablenameLength");
            WebApplicationContext wc=(WebApplicationContext)dataMap.get("wcx");
           
            String ip = "";
            String tablename = "";
            for (int i = 0; i < ipLength; i++) {
                ip = dataMap.getString("ip" + i);
                for (int j = 0; j < tablenameLength; j++) {
                    tablename = dataMap.getString("tablename" + j);
                    ExchangeAccess ea=new ExchangeAccess(ip,tablename,wc);
                     //启动线程
                    ea.start();
                }
            }
            Scheduler scheduler = (Scheduler) dataMap.get("scheduler");
            scheduler.deleteJob("ReceiveOnTimed", Scheduler.DEFAULT_GROUP);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
 }
}