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

算出num个数内的质数

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

这道题的其目的在于：

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

2. 看笔试者平时的算法

因此答题有两种。

第一种，通用做法

public class prime {
public static boolean isPrime(int num) {
    for (int i = 2; i <= Math.sqrt(num); i++) {
        if (num % i == 0) {
            return false;
        }
    }
        return true;
}

public static void main(String[] args) {
    for (int j = 2; j <= 20; j++) {
        if (isPrime(j)) {
            System.out.println(j + " is a prime");
        }
    }
}

}

public class prime {
public static boolean isPrime(int num) {
	for (int i = 2; i <= Math.sqrt(num); i++) {
		if (num % i == 0) {
			return false;
		}
	}
		return true;
}

public static void main(String[] args) {
	for (int j = 2; j <= 20; j++) {
		if (isPrime(j)) {
			System.out.println(j + " is a prime");
		}
	}
}

}

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

“筛选"法

public class Prime2 {

    /**
     * @param args
     */
    public static void main(String[] args) {

        int n = 20;

        int[] array = new int[n];

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

            array[i] = i;

        }

        for (int i = 2; i < n; i++) {
            if (array[i] != 0) {

                int j, temp;

                temp = array[i];

                for (j = 2 * temp; j < n; j = j + temp) {
                    array[j] = 0;
                }
                System.out.println("\n");

            }

        }

    }

}

public class Prime2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		int n = 20;

		int[] array = new int[n];

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

			array[i] = i;

		}

		for (int i = 2; i < n; i++) {
			if (array[i] != 0) {

				int j, temp;

				temp = array[i];

				for (j = 2 * temp; j < n; j = j + temp) {
					array[j] = 0;
				}
				System.out.println("\n");

			}

		}

	}

}

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

 

约瑟夫环算法

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

不难不难，关键记住这个环的算法（有人看到这个”环“字，要笑了，打住，别想歪了，俗人！）

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

int flag=0;
while(true){
        flag=(flag+1)%n;
}

int flag=0;		
while(true){
		flag=(flag+1)%n; 
}

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

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

public class JosephCircle {

    /**
     * @param args
     */
    public void josephCircle(int n,int k){
        int flag=0;
        boolean[] kick = new boolean[n];
        //set kick flag to False;
        for(int i=0;i<n-1;i++){
            kick[flag]=false;
        }
        int counter=0;
        int accumulate=0;
        while(true){
            if(!kick[flag]){
                accumulate++;
                if(counter==n-1){
                    System.out.println("kick last person===="+(flag+1));
                    break;
                }
                if(accumulate==k){
                    kick[flag]=true;
                    System.out.println("kick person===="+(flag+1));
                    accumulate=0;
                    counter++;
                }
            }
            flag=(flag+1)%n;
        }

    }
    public static void main(String[] args) {
        JosephCircle jCircle = new JosephCircle();
        jCircle.josephCircle(20, 3);

    }

}

public class JosephCircle {

	/**
	 * @param args
	 */
	public void josephCircle(int n,int k){
		int flag=0;
		boolean[] kick = new boolean[n];
		//set kick flag to False;
		for(int i=0;i<n-1;i++){
			kick[flag]=false;
		}
		int counter=0;
		int accumulate=0;
		while(true){
			if(!kick[flag]){
				accumulate++;
				if(counter==n-1){
					System.out.println("kick last person===="+(flag+1));
					break;
				}
				if(accumulate==k){
					kick[flag]=true;
					System.out.println("kick person===="+(flag+1));
					accumulate=0;
					counter++;
				}				
			}
			flag=(flag+1)%n;
		}
		
	}
	public static void main(String[] args) {
		JosephCircle jCircle = new JosephCircle();
		jCircle.josephCircle(20, 3);

	}

}

 

求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是很好玩的一个东西，如果你想着用什么循环，什么算法，什么数据结构，我一律在这边回”你个头啊“，为什么，这么简单的东西，直接套公式啊，唉。。。

public class MissedNumber {

    public int findMissedOne(int[] numArray) {
        int sum = 0;
        int idx = -1;
        for (int i = 0; i < numArray.length; i++) {
            if (numArray[i] == 0) {
                idx = i;
            } else {
                sum += numArray[i];
            }
        }

        // the total sum of numbers between 1 and arr.length.
        int total = (numArray.length + 1) * numArray.length / 2;
        int missedNumber = total - sum;
        return missedNumber;

    }
}

public class MissedNumber {

	public int findMissedOne(int[] numArray) {
		int sum = 0;
		int idx = -1;
		for (int i = 0; i < numArray.length; i++) {
			if (numArray[i] == 0) {
				idx = i;
			} else {
				sum += numArray[i];
			}
		}

		// the total sum of numbers between 1 and arr.length.
		int total = (numArray.length + 1) * numArray.length / 2;
		int missedNumber = total - sum;
		return missedNumber;

	}
}

来个测试类

public class TestMissedNumber {

    protected MissedNumber mNum = new MissedNumber();

    @Test
    public void testFindMissedOne() {
        int[] testArray = new int[] {0,2};
        int missedNumber = mNum.findMissedOne(testArray);
        System.out.println(missedNumber);
    }

}

public class TestMissedNumber {

	protected MissedNumber mNum = new MissedNumber();

	@Test
	public void testFindMissedOne() {
		int[] testArray = new int[] {0,2};
		int missedNumber = mNum.findMissedOne(testArray);
		System.out.println(missedNumber);
	}

}

简单吧，数组内的数的总和减去（（数组长度+1）*数组长度/2），即为missed number

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

 

硬币组合问题

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

public class CentsCombinations {
    public static void main(String[] args) {
        int i, j, k, total;
        System.out.println("1 cent"+"  2 cents"+"  5 cents");
        for (i = 0; i <= 10; i++)
            for (j = 0; j <= 5; j++)
                for (k = 0; k <= 2; k++) {
                    total = i * 1 + j * 2 + k * 5;
                    if (total > 10)
                        break;
                    if (10 == total)
                        System.out.println("    " + i + ",    " + j + ",    " + k);
                }

    }
}

public class CentsCombinations {
	public static void main(String[] args) {
		int i, j, k, total;
		System.out.println("1 cent"+"  2 cents"+"  5 cents");
		for (i = 0; i <= 10; i++)
			for (j = 0; j <= 5; j++)
				for (k = 0; k <= 2; k++) {
					total = i * 1 + j * 2 + k * 5;
					if (total > 10)
						break;
					if (10 == total)
						System.out.println("    " + i + ",    " + j + ",    " + k);
				}

	}
}

 

在List内去除重复值的问题

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

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

要什么循环啊？

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

public class DuplicateValue {

    public void removeDuplicateValue() {
        List myList = new ArrayList();
        myList.add(1);
        myList.add(2);
        myList.add(1);
        myList.add(3);
        myList.add(4);
        myList.add(5);
        myList.add(6);
        myList.add(5);

        Set myset = new HashSet(myList);
        myList = new ArrayList(myset);
        Iterator it = myList.iterator();
        while (it.hasNext()) {
            System.out.println(""+it.next());
        }
    }

    public static void main(String[] args) {
        DuplicateValue dv = new DuplicateValue();
        dv.removeDuplicateValue();

    }

}

public class DuplicateValue {

	public void removeDuplicateValue() {
		List myList = new ArrayList();
		myList.add(1);
		myList.add(2);
		myList.add(1);
		myList.add(3);
		myList.add(4);
		myList.add(5);
		myList.add(6);
		myList.add(5);

		Set myset = new HashSet(myList);
		myList = new ArrayList(myset);
		Iterator it = myList.iterator();
		while (it.hasNext()) {
			System.out.println(""+it.next());
		}
	}

	public static void main(String[] args) {
		DuplicateValue dv = new DuplicateValue();
		dv.removeDuplicateValue();

	}

}

 

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

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

上手就是冒泡

public Vector<SumPossibleBean> checkSumPossible(ArrayList<Integer> intList,
            int sumResult) {
        Vector<SumPossibleBean> possibleList = new Vector<SumPossibleBean>();
        int size = intList.size();
        for (int i = 0; i < size; i++) {
            for (int j = i + 1; j < size; j++) {
                if ((intList.get(i).intValue() + intList.get(j).intValue()) == sumResult) {

                    SumPossibleBean spBean = new SumPossibleBean();
                    spBean.setFirst(intList.get(i).intValue());
                    spBean.setSecond(intList.get(j).intValue());
                    possibleList.addElement(spBean);
                }
            }
        }
        return possibleList;
}

public Vector<SumPossibleBean> checkSumPossible(ArrayList<Integer> intList,
			int sumResult) {
		Vector<SumPossibleBean> possibleList = new Vector<SumPossibleBean>();
		int size = intList.size();
		for (int i = 0; i < size; i++) {
			for (int j = i + 1; j < size; j++) {
				if ((intList.get(i).intValue() + intList.get(j).intValue()) == sumResult) {

					SumPossibleBean spBean = new SumPossibleBean();
					spBean.setFirst(intList.get(i).intValue());
					spBean.setSecond(intList.get(j).intValue());
					possibleList.addElement(spBean);
				}
			}
		}
		return possibleList;
}

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

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

public Vector<SumPossibleBean> checkSumPossibleBinSearch(
            ArrayList<Integer> intList, int sumResult) {
        Vector<SumPossibleBean> possibleList = new Vector<SumPossibleBean>();
        int size = intList.size();
        Collections.sort(intList);
        for (int i = 0, j = (intList.size() - 1); i < j;) {
            Integer s = intList.get(i);
            Integer e = intList.get(j);
            if ((s + e) == sumResult) {
                SumPossibleBean spBean = new SumPossibleBean();
                spBean.setFirst(intList.get(i).intValue());
                spBean.setSecond(intList.get(j).intValue());
                possibleList.addElement(spBean);
                i++;
                j--;
            } else if ((s + e) > sumResult) {
                j--;
            } else if ((s + e) < sumResult) {
                i++;
            }
        }
        return possibleList;
}

public Vector<SumPossibleBean> checkSumPossibleBinSearch(
			ArrayList<Integer> intList, int sumResult) {
		Vector<SumPossibleBean> possibleList = new Vector<SumPossibleBean>();
		int size = intList.size();
		Collections.sort(intList);
		for (int i = 0, j = (intList.size() - 1); i < j;) {
			Integer s = intList.get(i);
			Integer e = intList.get(j);
			if ((s + e) == sumResult) {
				SumPossibleBean spBean = new SumPossibleBean();
				spBean.setFirst(intList.get(i).intValue());
				spBean.setSecond(intList.get(j).intValue());
				possibleList.addElement(spBean);
				i++;
				j--;
			} else if ((s + e) > sumResult) {
				j--;
			} else if ((s + e) < sumResult) {
				i++;
			}
		}
		return possibleList;
}

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

 

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方法，来确保类的不可变。

四点中少一点，回答失败，来看一个例子：

public final class MyImmutableWrong {
    private final int[] myArray;


    public MyImmutableWrong(int[] anArray) {
        this.myArray = anArray; // wrong
    }


    public String toString() {
        StringBuffer sb = new StringBuffer("Numbers are: ");
        for (int i = 0; i < myArray.length; i++) {
            sb.append(myArray[i] + " ");
        }
        return sb.toString();
    }
}

public final class MyImmutableWrong {
	private final int[] myArray;


	public MyImmutableWrong(int[] anArray) {
		this.myArray = anArray; // wrong
	}


	public String toString() {
		StringBuffer sb = new StringBuffer("Numbers are: ");
		for (int i = 0; i < myArray.length; i++) {
			sb.append(myArray[i] + " ");
		}
		return sb.toString();
	}
}

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

正确的写法：

public final class MyImmutableCorrect {
    private final int[] myArray;

    public MyImmutableCorrect(int[] anArray) {
        this.myArray = anArray.clone();
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("Numbers are: ");
        for (int i = 0; i < myArray.length; i++) {
            sb.append(myArray[i] + " ");
        }
        return sb.toString();
    }
}

public final class MyImmutableCorrect {
	private final int[] myArray;

	public MyImmutableCorrect(int[] anArray) {
		this.myArray = anArray.clone(); 
	}

	public String toString() {
		StringBuffer sb = new StringBuffer("Numbers are: ");
		for (int i = 0; i < myArray.length; i++) {
			sb.append(myArray[i] + " ");
		}
		return sb.toString();
	}
}

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

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

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

则都没回答上来。

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

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

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

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