本人java笔试常见题目小结

注：这是本人java笔试常见题目小结，不是笔试题大全，也不一定是其他公司常见面试题。

1.Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

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

 

2.servlet的生命周期

web容器加载servlet，生命周期开始。通过调用servlet的init()方法进行servlet的初始化。通过调用service()方法实现，根据请求的不同调用不同的do***()方法。结束服务，web容器调用servlet的destroy()方法。

servlet生命周期.jpg 见附件

 

3.说出ArrayList,Vector, LinkedList的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized同步方法保证线程安全，通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

4.final, finally, finalize的区别。 
　　final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

 

5.forward 和redirect的区别
forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。
    redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以session,request参数都可以获取。

6.JSP中动态INCLUDE与静态INCLUDE的区别？
动态INCLUDE用jsp:include动作实现 <jsp:include page="included.jsp" flush="true" />它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。
静态INCLUDE用include伪码实现,不会检查所含文件的变化，适用于包含静态页面<%@ include file="included.htm" %>

7.设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。
以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。
public class ThreadTest1{
  private int j;
  public static void main(String args[]){
ThreadTest1 tt=new ThreadTest1();
Inc inc=tt.new Inc();
Dec dec=tt.new Dec();
for(int i=0;i<2;i++){
Thread t=new Thread(inc);
t.start();
t=new Thread(dec);
t.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<100;i++){
inc();
}
}
  }
  class Dec implements Runnable{
public void run(){
for(int i=0;i<100;i++){
dec();
}
 }
  }
}

8.编程题: 写一个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的。
一般认为第一种形式要更加安全些

9.编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。 但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6，应该输出为“我ABC”而不是“我ABC+汉的半个”。

public class SubStringTest {

	public static void main(String[] args) {
		String inStr = "我ABC";
		String str = subString(inStr, 4);
		System.out.println(str);

		inStr = "我ABC汉DEF";
		str = subString(inStr, 6);
		System.out.println(str);
	}

	/**
	 * 字符串按字节截取
	 * @param str 原字符
	 * @param len 截取长度
	 * @return String
	 * @author zheng
	 */
	public static String subString(String str, int len) {
		if (str == null || ("").equals(str)) {
			return "";
		}
		byte[] strByte = null;
		try {
			strByte = str.getBytes("GBK");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		int strLen = strByte.length;
		if (len >= strLen || len < 1) {
			return str;
		}
		int count = 0;
		for (int i = 0; i < len; i++) {
			int value = (int) strByte[i];
			if (value < 0) {
				count++;
			}
		}
		if (count % 2 != 0) {
			len = (len == 1) ? len + 1 : len - 1; 
		}
		
		return str.substring(0, len-1);
	}
}

 

 

评论

32 楼 lovelimx 2010-10-15  

public String subString2(String string, int length)
			throws UnsupportedEncodingException {
		if (string == null || "".equals(string)) {
			return "";
		}
		byte[] temp = string.getBytes("GBK");
		int tempLength = temp.length;
		if (tempLength < length || length < 1) {
			return string;
		}
		// 记录汉字的字节个数
		int count = 0;
		for (int i = 0; i < length; i++) {
			if (temp[i] < 0) {
				count++;
			}
		}
		if (count % 2 != 0) {
			length = length - 1;
		}
		count /= 2;
		return string.substring(0, length - count);
	}

这个是我实现的算法

31 楼 zdz8207 2010-03-29  

xiao1230 写道

楼主的subString(String str, int len)方法小弟没看懂，如果我想要得到subString(“我ABC汉DEF”,  7)
不知可否得到"我ABC汉"

自己运行下不就知道了

30 楼 wujiazhao88 2010-03-28  

好容易的一些面试题。。
我也出道线程的题目，楼主做做看。

给出一个程序，用最好的方法使用10个线程按递增的顺序打印出1~100即可。

29 楼 jayming 2010-03-28  

yabo 写道

http://en.wikipedia.org/wiki/Singleton_pattern#The_solution_of_Bill_Pugh

public class Singleton {
   // Private constructor prevents instantiation from other classes
   private Singleton() {}

   /**
    * SingletonHolder is loaded on the first execution of Singleton.getInstance()
    * or the first access to SingletonHolder.INSTANCE, not before.
    */
   private static class SingletonHolder {
     private static final Singleton INSTANCE = new Singleton();
   }

   public static Singleton getInstance() {
     return SingletonHolder.INSTANCE;
   }
}

这才是我认为的单例

28 楼 esanone 2010-03-27  

小朋友,这应该是你第一次面试经验吧.

27 楼 lyb520320 2010-03-27  

我感觉应聘技术不是主要的

26 楼 cartonwang 2010-03-27  

很经典的题目~~~

25 楼 hrwhat 2010-03-27  

性能性能，性能差异到底有多大？量化一下！

24 楼 seraphim871211 2010-03-27  

jmu 写道

显然用部分是反驳不了整体的

明明你先说单例是低性能的，我从来没有下结论，只说场合和优缺点，这话你自己反省比较适合。

引用

这位童鞋,  我是看你们讨论的侧重点有点偏了 , lazy和不lazy, 不是单单因为lazy的初始化次数少而优先选他,  而是结合使用场景,   比如这个singleton是用来读取程序设置文件的, 而且有可能只读取1次或几次,那么 是否是懒汉没多大区别,  有些程序需要重启才能更新设置,用的大概就是懒汉式, 如果客户要求不要重启就能生效,那饿汉就比较合适了
这是应用场景优先的例子

lazy初始化次数少又是怎么来的？没错，正式应用场景优先的，难道就没有性能也属于于应用场景关键因素的情况吗？

引用

在java的信仰里 良好的结构美感永远高于对于性能的追求

这句话对于我来说是绝对的  如果你不赞同, 也不怕,   在这话前面加上"我" 就行了

我并没有不赞同，但你藐视性能和随意下结论的态度，很有可能误导别人。

23 楼 jmu 2010-03-27  

引用

singleton和低性能有必然的联系吗？如果用singleton对象对内存不敏感，用eager initialization策略对性能有什么损耗？

单例本身就是个低性能的做法  是和多例相比的    而多例按上面说是空间换时间的  
单例写法本来就分懒汉和饿汉, 或者其他 , 这位童鞋单单用饿汉就能反驳单例性能低的论点吗? 显然用部分是反驳不了整体的

而饿汉和不使用单例两个非要比性能上的差异  我看还是不要比了  不同场合结果是不同的
而且方向也错了, 单例的结构是真正有用处的  而必须用单例的地方往往性能都不在主要考虑之内了

引用

懒汉和饿汉的使用按需求而定 而不是那点可怜的性能

引用

你这话不是很矛盾吗？既然认同lazy initialization策略有其适合的场合。为什么又在后面下绝对的结论，发贴本来就是大家讨论各种全面情况，对各种情况下有清楚的认识才能正确的选择。

这位童鞋,  我是看你们讨论的侧重点有点偏了 , lazy和不lazy, 不是单单因为lazy的初始化次数少而优先选他,  而是结合使用场景,   比如这个singleton是用来读取程序设置文件的, 而且有可能只读取1次或几次,那么 是否是懒汉没多大区别,  有些程序需要重启才能更新设置,用的大概就是懒汉式, 如果客户要求不要重启就能生效,那饿汉就比较合适了
这是应用场景优先的例子

引用

在java的信仰里 良好的结构美感永远高于对于性能的追求

这句话对于我来说是绝对的  如果你不赞同, 也不怕,   在这话前面加上"我" 就行了
单例本身这是结构优先的例子  为了某些场合的适用, 使用同步也是没问题的  但是用错场合了 就可能影响性能了

我发帖也是一家之言 希望不要对模式有误解

22 楼 wpxdong 2010-03-26  

xiao1230 写道

楼主的subString(String str, int len)方法小弟没看懂，如果我想要得到subString(“我ABC汉DEF”,  7)
不知可否得到"我ABC汉"

改为这个应该可以
return str.substring(0, (count%2==0)?(len-count/2):(len-count/2-1));

21 楼 wpxdong 2010-03-26  

楼主的subString(String str, int len)方法小弟没看懂，如果我想要得到subString(“我ABC汉DEF”,  7)
不知可否得到"我ABC汉"

楼主代码有问题，只考虑偶数了

20 楼 徐风子 2010-03-26  

主题：本人java笔试常见题目小结
精华帖 (0) :: 良好帖 (0) :: 新手帖 (0) :: 隐藏帖 (7)
可怜的孩子…………

19 楼 yabo 2010-03-26  

http://en.wikipedia.org/wiki/Singleton_pattern#The_solution_of_Bill_Pugh

public class Singleton {
   // Private constructor prevents instantiation from other classes
   private Singleton() {}

   /**
    * SingletonHolder is loaded on the first execution of Singleton.getInstance()
    * or the first access to SingletonHolder.INSTANCE, not before.
    */
   private static class SingletonHolder {
     private static final Singleton INSTANCE = new Singleton();
   }

   public static Singleton getInstance() {
     return SingletonHolder.INSTANCE;
   }
}

18 楼 xiao1230 2010-03-26  

楼主的subString(String str, int len)方法小弟没看懂，如果我想要得到subString(“我ABC汉DEF”,  7)
不知可否得到"我ABC汉"

17 楼 seraphim871211 2010-03-26  

jmu 写道

双重检查成例---在阎宏的书中看到, 提到在c/c++下成立的   在java中可能出问题
中文的讨论在这里
http://www.jdon.com/jivejdon/thread/23890

我认为无论这个成不成立，都最好不要用吧，， 单例本身就是个低性能的做法，只有在最适合单例的地方才会用到，除了理论学术的考量，没必要非要死扣怎么写性能怎么好。
在java的信仰里 良好的结构美感永远高于对于性能的追求 

singleton和低性能有必然的联系吗？如果用singleton对象对内存不敏感，用eager initialization策略对性能有什么损耗？

引用

懒汉和饿汉的使用按需求而定 而不是那点可怜的性能

引用

在java的信仰里 良好的结构美感永远高于对于性能的追求

你这话不是很矛盾吗？既然认同lazy initialization策略有其适合的场合。为什么又在后面下绝对的结论，发贴本来就是大家讨论各种全面情况，对各种情况下有清楚的认识才能正确的选择。

16 楼 jmu 2010-03-26  

seraphim871211 写道

J-catTeam 写道

crabboy 写道

diaodou 写道

Singleton必须添加private构造函数，不然就失去singleton的意义了。而且，性能太差了，会继续追问有很有更好的方式？

对这个话题请继续谈谈。。。。

我也觉得奇怪：性能差在哪里

Singleton类肯定要提供默认的private构造函数，要不然就不叫Singleton了。
另外，楼主的第一种方式是空间换时间。第二种方式：

引用

第二种形式:
public class Singleton {
　　private static Singleton instance = null;
　　 public static synchronized Singleton getInstance() {
　　//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　 　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance＝new Singleton();
return instance; 　　}
}

在每次调用Singleton.getInstance()方法的时候都用synchronized同步确实会影响性能，实际上除了第一次instance==null时需要同步，初始化之后同步是没有必要的。通常会这样写：

public class Singleton{
    private volatile static Singleton instance = null;

    private Singleton(){}

    public static Singleton getInstance(){
        if(instance == null){
        	synchronized(Singleton.class){
        		if(instance == null){
        			instance = new Singleton();
        		}
        	}
        }
        
        return instance;
    }
}

上述代码保证了只在第一次初始化时同步多线程的安全，性能也不错。唯一的缺点是可能在某些老式的JVM上还是会出现多线程不安全的问题。

双重检查成例---在阎宏的书中看到, 提到在c/c++下成立的   在java中可能出问题
中文的讨论在这里
http://www.jdon.com/jivejdon/thread/23890

我认为无论这个成不成立，都最好不要用吧，懒汉和饿汉的使用按需求而定 而不是那点可怜的性能， 单例本身就是个低性能的做法，只有在最适合单例的地方才会用到，除了理论学术的考量，没必要非要死扣怎么写性能怎么好。
在java的信仰里 良好的结构美感永远高于对于性能的追求 

15 楼 seraphim871211 2010-03-26  

J-catTeam 写道

seraphim871211 写道

J-catTeam 写道

多线程不安全又体现在哪里了？ 我承认 synchronized(Singleton.class){
        if(instance == null){
        instance = new Singleton();
        }
        }这种写法较之在方法前同步性能在理论上确实是好，但是他的目的不是为了性能吧，因为仅仅是多了一句if代码。

。。。。。。理论和实际上那种方式都要比在方法前加synchronized要好，影响性能的不是if语句，是每次调用getInstance方法都必须要同步。

引用

应该是为了保持至始至终产生一个单例。

用Singleton pattern不就是为了保证只有一个实例吗？加同步不就是为了在多线程的情况下保证只产生一个实例？

引用

多线程不安全又体现在哪里了？

传送门：http://www.ibm.com/developerworks/java/library/j-dcl.html

翻译下 哈哈~

。。。不用吧

14 楼 J-catTeam 2010-03-26  

seraphim871211 写道

J-catTeam 写道

多线程不安全又体现在哪里了？ 我承认 synchronized(Singleton.class){
        if(instance == null){
        instance = new Singleton();
        }
        }这种写法较之在方法前同步性能在理论上确实是好，但是他的目的不是为了性能吧，因为仅仅是多了一句if代码。

。。。。。。理论和实际上那种方式都要比在方法前加synchronized要好，影响性能的不是if语句，是每次调用getInstance方法都必须要同步。

引用

应该是为了保持至始至终产生一个单例。

用Singleton pattern不就是为了保证只有一个实例吗？加同步不就是为了在多线程的情况下保证只产生一个实例？

引用

多线程不安全又体现在哪里了？

传送门：http://www.ibm.com/developerworks/java/library/j-dcl.html

翻译下 哈哈~

13 楼 seraphim871211 2010-03-26  

J-catTeam 写道

多线程不安全又体现在哪里了？ 我承认 synchronized(Singleton.class){
        if(instance == null){
        instance = new Singleton();
        }
        }这种写法较之在方法前同步性能在理论上确实是好，但是他的目的不是为了性能吧，因为仅仅是多了一句if代码。

。。。。。。理论和实际上那种方式都要比在方法前加synchronized要好，影响性能的不是if语句，是每次调用getInstance方法都必须要同步。

引用

应该是为了保持至始至终产生一个单例。

用Singleton pattern不就是为了保证只有一个实例吗？加同步不就是为了在多线程的情况下保证只产生一个实例？

引用

多线程不安全又体现在哪里了？

传送门：http://www.ibm.com/developerworks/java/library/j-dcl.html