think in java interview-高级开发人员面试宝典(四)

算出num个数内的质数

质数即大于1的一个自然数,这个数可以被1和自身整除,如算出20之内的质数,它们有2,3,5,7,11,13,17,19这样的数字。这道题也是面试过程中笔试常问的一道题。

这道题的其目的在于:

1. 看笔试者的数学还记不记得

2. 看笔试者平时的算法

因此答题有两种。

第一种,通用做法

[java] view plain copy print ?
  1. public class prime {  
  2. public static boolean isPrime(int num) {  
  3.     for (int i = 2; i <= Math.sqrt(num); i++) {  
  4.         if (num % i == 0) {  
  5.             return false;  
  6.         }  
  7.     }  
  8.         return true;  
  9. }  
  10.   
  11. public static void main(String[] args) {  
  12.     for (int j = 2; j <= 20; j++) {  
  13.         if (isPrime(j)) {  
  14.             System.out.println(j + " is a prime");  
  15.         }  
  16.     }  
  17. }  
  18.   
  19. }  





这种做法是对每个2--num个数内的数,进行扫描,需要用到2个循环,其重复度高,效率低下,因此我们还有一种更先进的做法。

“筛选"法

[java] view plain copy print ?
  1. public class Prime2 {  
  2.   
  3.     /** 
  4.      * @param args 
  5.      */  
  6.     public static void main(String[] args) {  
  7.   
  8.         int n = 20;  
  9.   
  10.         int[] array = new int[n];  
  11.   
  12.         for (int i = 2; i < n; i++) {  
  13.   
  14.             array[i] = i;  
  15.   
  16.         }  
  17.   
  18.         for (int i = 2; i < n; i++) {  
  19.             if (array[i] != 0) {  
  20.   
  21.                 int j, temp;  
  22.   
  23.                 temp = array[i];  
  24.   
  25.                 for (j = 2 * temp; j < n; j = j + temp) {  
  26.                     array[j] = 0;  
  27.                 }  
  28.                 System.out.println("\n");  
  29.   
  30.             }  
  31.   
  32.         }  
  33.   
  34.     }  
  35.   
  36. }  


它的原理就是把所有的偶数去掉后即留下质数。


 

约瑟夫环算法

假设有20个人手拉手围成一圈,顺时针开始报号,报到3的人出圈,然后继续往后报,报到3的人出圈,依次把所有报到3的人都踢出圈,最后剩下一人也踢出圈,问先后被踢出圈的那些人原来是圈内的几号?

不难不难,关键记住这个环的算法(有人看到这个”环“字,要笑了,打住,别想歪了,俗人!)

环的算法即闭合算法,永远依次1,2,3,4,5...20...1再2,3,4,5...20这样一直转下去,假设要让20以内的20个数以环型转起来,它的核心算法如下:

[java] view plain copy print ?
  1. int flag=0;       
  2. while(true){  
  3.         flag=(flag+1)%n;   
  4. }  


即”取模运算“,循环继续。


有了核心算法,我们的问题就可以解决了,来:

[java] view plain copy print ?
  1. public class JosephCircle {  
  2.   
  3.     /** 
  4.      * @param args 
  5.      */  
  6.     public void josephCircle(int n,int k){  
  7.         int flag=0;  
  8.         boolean[] kick = new boolean[n];  
  9.         //set kick flag to False;  
  10.         for(int i=0;i<n-1;i++){  
  11.             kick[flag]=false;  
  12.         }  
  13.         int counter=0;  
  14.         int accumulate=0;  
  15.         while(true){  
  16.             if(!kick[flag]){  
  17.                 accumulate++;  
  18.                 if(counter==n-1){  
  19.                     System.out.println("kick last person===="+(flag+1));  
  20.                     break;  
  21.                 }  
  22.                 if(accumulate==k){  
  23.                     kick[flag]=true;  
  24.                     System.out.println("kick person===="+(flag+1));  
  25.                     accumulate=0;  
  26.                     counter++;  
  27.                 }                 
  28.             }  
  29.             flag=(flag+1)%n;  
  30.         }  
  31.           
  32.     }  
  33.     public static void main(String[] args) {  
  34.         JosephCircle jCircle = new JosephCircle();  
  35.         jCircle.josephCircle(203);  
  36.   
  37.     }  
  38.   
  39. }  



 

求Missed Number,找丢失的那个数

上次有朋友在美国去yahoo面试,说一道题把它给整了,题目如下:

说有一数组如 int[]{0,1,2} 这样的一个数组,这个数组的第一个必须从0开始,以次+1列出,该数组内最后一个数是这个数组的长度,因此:

int[]{1,2}, missed number为0

int[]{0,1,2}, missed number为3

int[]{0,2}, missed number为1

我朋友和我说这看上去有点像等差数列,我当时就在MSN里和他说:等差数你个头啊!

然后我朋友说,他用了两个循环嵌套也搞不定

我和他说:两个循环你个头啊

他在MSN上又要和我说什么,我还没等他把它打出来直接就是”你个头啊“回过去了。

大家看,这个找missed number是很好玩的一个东西,如果你想着用什么循环,什么算法,什么数据结构,我一律在这边回”你个头啊“,为什么,这么简单的东西,直接套公式啊,唉。。。

[java] view plain copy print ?
  1. public class MissedNumber {  
  2.   
  3.     public int findMissedOne(int[] numArray) {  
  4.         int sum = 0;  
  5.         int idx = -1;  
  6.         for (int i = 0; i < numArray.length; i++) {  
  7.             if (numArray[i] == 0) {  
  8.                 idx = i;  
  9.             } else {  
  10.                 sum += numArray[i];  
  11.             }  
  12.         }  
  13.   
  14.         // the total sum of numbers between 1 and arr.length.  
  15.         int total = (numArray.length + 1) * numArray.length / 2;  
  16.         int missedNumber = total - sum;  
  17.         return missedNumber;  
  18.   
  19.     }  
  20. }  



来个测试类

[java] view plain copy print ?
  1. public class TestMissedNumber {  
  2.   
  3.     protected MissedNumber mNum = new MissedNumber();  
  4.   
  5.     @Test  
  6.     public void testFindMissedOne() {  
  7.         int[] testArray = new int[] {0,2};  
  8.         int missedNumber = mNum.findMissedOne(testArray);  
  9.         System.out.println(missedNumber);  
  10.     }  
  11.   
  12. }  



简单吧,数组内的数的总和减去((数组长度+1)*数组长度/2),即为missed number

所以你就循环求一个数组内各数的和即可鸟。


 

硬币组合问题

这道题老套了,即2角,5角,1角硬币,问有多少种组合可得到1块钱(一块钱?一块钱以前能够买奶油雪糕,一块钱以前可以买一个铅笔盒,一块钱以前可以吃到大排面,现在能干吗?)

[java] view plain copy print ?
  1. public class CentsCombinations {  
  2.     public static void main(String[] args) {  
  3.         int i, j, k, total;  
  4.         System.out.println("1 cent"+"  2 cents"+"  5 cents");  
  5.         for (i = 0; i <= 10; i++)  
  6.             for (j = 0; j <= 5; j++)  
  7.                 for (k = 0; k <= 2; k++) {  
  8.                     total = i * 1 + j * 2 + k * 5;  
  9.                     if (total > 10)  
  10.                         break;  
  11.                     if (10 == total)  
  12.                         System.out.println("    " + i + ",    " + j + ",    " + k);  
  13.                 }  
  14.   
  15.     }  
  16. }  



 

在List内去除重复值的问题

说有一个ArrayList{1,2,3,5,1,2,7,5,3,3,4,5,6,9,11,11},它里面有许多重复数,我要求去除所有的重复数据,得到一个不重复的List。

有的人碰到这个问题,循环2个,嵌套,还有用二分算法的(这种人已经算好的了)。

要什么循环啊?

这道题考的是你对JDK的API是否熟悉,来看下面答案,如果以前没碰到过这个问题的人看完下面的答案后直接就吐血了

[java] view plain copy print ?
  1. public class DuplicateValue {  
  2.   
  3.     public void removeDuplicateValue() {  
  4.         List myList = new ArrayList();  
  5.         myList.add(1);  
  6.         myList.add(2);  
  7.         myList.add(1);  
  8.         myList.add(3);  
  9.         myList.add(4);  
  10.         myList.add(5);  
  11.         myList.add(6);  
  12.         myList.add(5);  
  13.   
  14.         Set myset = new HashSet(myList);  
  15.         myList = new ArrayList(myset);  
  16.         Iterator it = myList.iterator();  
  17.         while (it.hasNext()) {  
  18.             System.out.println(""+it.next());  
  19.         }  
  20.     }  
  21.   
  22.     public static void main(String[] args) {  
  23.         DuplicateValue dv = new DuplicateValue();  
  24.         dv.removeDuplicateValue();  
  25.   
  26.     }  
  27.   
  28. }  




 

一道题即考了冒泡又考了二分

说有一数组int[]{1,2,2,4,6,8,9,5,3,7,5},里面可能还有很多,想要知道”两两相加等于10“的这样的数有几对,可以重复如:2+6,6+2

上手就是冒泡

[java] view plain copy print ?
  1. public Vector<SumPossibleBean> checkSumPossible(ArrayList<Integer> intList,  
  2.             int sumResult) {  
  3.         Vector<SumPossibleBean> possibleList = new Vector<SumPossibleBean>();  
  4.         int size = intList.size();  
  5.         for (int i = 0; i < size; i++) {  
  6.             for (int j = i + 1; j < size; j++) {  
  7.                 if ((intList.get(i).intValue() + intList.get(j).intValue()) == sumResult) {  
  8.   
  9.                     SumPossibleBean spBean = new SumPossibleBean();  
  10.                     spBean.setFirst(intList.get(i).intValue());  
  11.                     spBean.setSecond(intList.get(j).intValue());  
  12.                     possibleList.addElement(spBean);  
  13.                 }  
  14.             }  
  15.         }  
  16.         return possibleList;  
  17. }  


不错,两个循环嵌套,当考官问你,有没有更好的算法时,70%以上的人基本歇菜!!!

唉哎。。。二分来一个吗,以前在学校怎么学的?

[java] view plain copy print ?
  1. public Vector<SumPossibleBean> checkSumPossibleBinSearch(  
  2.             ArrayList<Integer> intList, int sumResult) {  
  3.         Vector<SumPossibleBean> possibleList = new Vector<SumPossibleBean>();  
  4.         int size = intList.size();  
  5.         Collections.sort(intList);  
  6.         for (int i = 0, j = (intList.size() - 1); i < j;) {  
  7.             Integer s = intList.get(i);  
  8.             Integer e = intList.get(j);  
  9.             if ((s + e) == sumResult) {  
  10.                 SumPossibleBean spBean = new SumPossibleBean();  
  11.                 spBean.setFirst(intList.get(i).intValue());  
  12.                 spBean.setSecond(intList.get(j).intValue());  
  13.                 possibleList.addElement(spBean);  
  14.                 i++;  
  15.                 j--;  
  16.             } else if ((s + e) > sumResult) {  
  17.                 j--;  
  18.             } else if ((s + e) < sumResult) {  
  19.                 i++;  
  20.             }  
  21.         }  
  22.         return possibleList;  
  23. }  




算法讲一些,讲多了枯燥,来几道问答题,如果你没准备过的话也一样可以让你爽到吐血。


 

Collection 和 Collections的区别 


Collections是个java.util下的类,它包含有各种有关集合操作的静态方法。 
Collection是个java.util下的接口,它是各种集合结构的父接口。

吐血了吗?没吐,OK,下面这道如果在面试时问到一定让你吐,面架构师的人50%以上被问到过这道题


 

什么时候用assert

断言是一个包含布尔表达式的语句,在执行这个语句时假定该表达式为 true。如果表达式计算为 false,那么系统会报告一个 AssertionError。它用于调试目的:  

assert(a > 0); // throws an AssertionError if a <= 0  


断言可以有两种形式:  


assert Expression1 ;  
assert Expression1 : Expression2 ;  

Expression1 应该总是产生一个布尔值。  
Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。  

断言在默认情况下是禁用的。要在编译时启用断言,需要使用 source 1.4 标记:  

javac -source 1.4 Test.java  

要在运行时启用断言,可使用 -enableassertions 或者 -ea 标记。  

要在运行时选择禁用断言,可使用 -da 或者 -disableassertions 标记。

要系统类中启用断言,可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。  


可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过,断言不应该用于验证传递给公有方法的参数,因为不管是否启用了断言,公有方法都必须检查其参数。不过,既可以在公有方法中,也可以在非公有方法中利用断言测试后置条件。另外,断言不应该以任何方式改变程序的状态。


 

企业级开发写多了,忘了JAVA是一门计算机语言,计算机语言最早是用来做运算的

来一道

问:Math.round(11.5)等於多少? Math.round(-11.5)等於多少

Math.round(11.5)返回(long)12

Math.round(-11.5)返回(long)-11;

再来一道

问:short s1 = 1; s1 = s1+ 1;有什么错? short s1 = 1; s1 += 1;有什么错

short s1 = 1; s1 = s1 + 1;有错,s1是short型,s1+1是int型,不能显式转化为short型。可修改为s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正确。


 

数组有没有length()这个方法? String有没有length()这个方法

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

 

String有有length()这个方法。


 

error和exception有什么区别?

error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。

 

exception 表示一种设计或实现问题。也就是说,它表示如果程序运行正常,从不会发生的情况。


 

abstract的method是否可同时是static,是否可同时是native,是否可同时是synchronized?

 

都不能 



 

可变类与不可变类的区别

所谓不可变类:

是指当创建了这个类的实例后,就不允许修改它的属性值。在JDK的基本类库中,所有基本类型的包装类,如Integer和Long类,都是不可变类,java.lang.String也是不可变类。

不可变类:

当你获得这个类的一个实例引用时,你不可以改变这个实例的内容。不可变类的实例一但创建,其内在成员变量的值就不能被修改。

如何创建一个可变类?

这道题90%以上的人都会被挂或者只回答一半对,来看:

1. 所有成员都是private
2. 不提供对成员的改变方法,例如:setXXXX
3. 确保所有的方法不会被重载。手段有两种:使用final Class(强不可变类),或者将所有类方法加上final(弱不可变类)。
4. 如果某一个类成员不是原始变量(primitive)或者不可变类,必须通过在成员初始化(in)或者get方法(out)时通过深度clone方法,来确保类的不可变。

四点中少一点,回答失败,来看一个例子:

[java] view plain copy print ?
  1. public final class MyImmutableWrong {  
  2.     private final int[] myArray;  
  3.   
  4.   
  5.     public MyImmutableWrong(int[] anArray) {  
  6.         this.myArray = anArray; // wrong  
  7.     }  
  8.   
  9.   
  10.     public String toString() {  
  11.         StringBuffer sb = new StringBuffer("Numbers are: ");  
  12.         for (int i = 0; i < myArray.length; i++) {  
  13.             sb.append(myArray[i] + " ");  
  14.         }  
  15.         return sb.toString();  
  16.     }  
  17. }  


以上可变类书写错误,为什么?违犯了第四点

正确的写法:

[java] view plain copy print ?
  1. public final class MyImmutableCorrect {  
  2.     private final int[] myArray;  
  3.   
  4.     public MyImmutableCorrect(int[] anArray) {  
  5.         this.myArray = anArray.clone();   
  6.     }  
  7.   
  8.     public String toString() {  
  9.         StringBuffer sb = new StringBuffer("Numbers are: ");  
  10.         for (int i = 0; i < myArray.length; i++) {  
  11.             sb.append(myArray[i] + " ");  
  12.         }  
  13.         return sb.toString();  
  14.     }  
  15. }  



记住,不可变类的写法,我说过90%的人碰到这个问题会挂,另10%回答出。

但 是这10%里90%的人只回答出第1点,第2点和第3点,对于第四点即:

如果某一个类成员不是原始变量(primitive)或者不可变类,必须通过在成员初始化(in)或者get方法(out)时通过深度clone方法,来确保类的不可变。

则都没回答上来。

由此可判断这个面试者是真正写过还是只是为了应付面试而背原理

所以,不要把面试当儿戏,每一次面试可能就是对自己这段时间的一个检查,看看自己平时缺了什么,JAVA是一门体系化的语言,要想面试的好,不只是死记硬背,是真的平时要化时间自己去补一些基础的。

上手就学SSH,JSP能连个数据库满天飞,这就是JAVA了?这就是中国IT了。。。这是错误的

今天暂写这么多,下次继续。

你可能感兴趣的:(think in java interview-高级开发人员面试宝典(四))