今天面试家公司，说是一个星期内有回复

1.第一反应冒泡排序。。。
2.第一反应是InvocationHandler动态代理
4.一致性哈希算法，听说过
7.Strategy 模式

lz面的是互联网公司吧~
lz这么厚道的发面试题，我觉得按人品来说，有戏！

真惭愧，工作两年了，也答不上来几个。

祝愿lz收到offer

阿？5用抽象工厂可以吗？

1.题目没理解，无规则进入方法是指多次调用？还是多线程调用？
2.spring不输，直接说不会
3.资源消耗完 要先确定什么资源消耗完。内存？cpu？内存的话确定是heap 还是stack消耗完 或者是方法区内存等各种情况，
都有不同的解决方案，这个聊聊就看面试者怎么应答了。单纯线程多就考虑换成线程池。io资源消耗完就考虑io池 nio等技术
4.分布式这个问题大了，我答的话会根据自己接触的一些实际例子来聊，不会罗列概念。具体聊到哪看面试者交互。
缓存实现方式 不太了解面试者意图？是指架构方面的考量还是啥？分布式系统缓存我自己经验主要考虑数据一致性问题了。
考虑用集中式缓存设计，memcache这些，不过我自己也没搞过，普通搞个本地内存缓存就够了。还有命中率 退出机制啥的只知道
理论 自己没弄过。
5.先把不同数组的处理类抽取出来：handle（String[]） handle(int[]) handle(object[]) 然后方法内根据list内保存的数据类型
用List.toArray(T[]) 获取对应的数组，调用handle方法（overload）。
个人感觉答得不太好，因为toArray比较耗资源，懒得想了，面试的时候估计也没多少时间考虑。
6.这个随便聊了。。各人还接触过一些多线程的设计模式，可以多吹一点。。
7.不太懂
8.map list set 用法这个比较熟悉，hash算法实现原理懂也研究过hashMap源代码，让我写一个hash算法估计有难度。
为啥注意equals呵hashCode自然跟hash算法原理有关。
concurrent包的几个容器Queue blockingqueue也接触比较多，源代码也研究过 可以稍微聊下

俺也是3年经验，深圳有招人的吗？

3、JVM线程多，资源快消耗被完，应该怎么处理。  线程多需要消耗的主要是栈空间和OS内存，如果资源不够，只能用池化的方式来解决，未执行到的阻塞或者超过最大值的抛弃/自己定义策略，如果做了监控我们可以直观的看到一个机器的load以及gc各个区的值, 线程栈主要是调整jvm的-Xxs值

应该基本阵亡了吧！

好的都是当场就定下的

给一个有趣的实现，第1题

package test;
public class Test {
	public static void main(String[] args) {
		Test t = new Test();
		
		int[] source = {1,1,1,1,1,2,5,6,5,6,4,8,5,4,5,4,2,1,2,3,2,1,2,3,8,5,2,2,2,4,4,4,3,2,7,9,0,3,4,5,5,5,5,5,5};
		
		/**
		 * 其中count的加法是每个if后面都加一个，计算判断的次数吧，用循环次数对于这种小的循环，可能不够直观
		 */
		
		/*方法1*/
		int[] result = t.orderInt(source);
		for(int i=0;i<result.length;i++){
			System.out.println(""+result[i]);
		}
		System.out.println("执行判断的次数"+t.count);
		
		/*方法2*/
		int[] result2 = t.orderInt2(source);
		for(int i=0;i<result2.length;i++){
			System.out.println(""+result2[i]);
		}
		System.out.println("执行判断的次数"+t.count2);

	}
	
	private int count =0;
	private int count2 =0;
	
	/**
	 * 排序
	 * @param ord
	 * @return
	 */
	public int[] orderInt(int[] ord){
		int[] result = new int[10];
		long max = 3L*5L*7L*11L*13L*17L*19L*23L*29L*31L;//100280245065L,用乘法的大家可能看得懂些
		int resultCount = 0;
		boolean flag = true;
		for(int i=0;i<ord.length&&flag;i++){
			int j = replaceInt(ord[i]);
			if(max%j==0){
				max = max/j;
				result[resultCount++] = ord[i];
				if(resultCount == 10){
					flag = false;
				}
				count++;
			}
			count++;
		}
		return result;
	}
	
	/**
	 * 替换
	 * @param ind
	 * @return
	 */
	public int replaceInt(int ind){
		int res = 1;
		if(ind == 0){
			count += 1;
			return 3;
		}else if(ind == 1){
			count += 2;
			return 5;
		}else if(ind == 2){
			count += 3;
			return 7;
		}else if(ind == 3){
			count += 4;
			return 11;
		}else if(ind == 4){
			count += 5;
			return 13;
		}else if(ind == 5){
			count += 6;
			return 17;
		}else if(ind == 6){
			count += 7;
			return 19;
		}else if(ind == 7){
			count += 8;
			return 23;
		}else if(ind == 8){
			count += 9;
			return 29;
		}else if(ind == 9){
			count += 10;
			return 31;
		}
		return res;
	}
	
	/**
	 * 排序2
	 * @param ord
	 * @return
	 */
	public int[] orderInt2(int[] ord){
		int[] result = new int[10];
		int resultCount = 0;
		boolean flag1 = true;
		boolean flag2 = true;
		
		for(int i=0;i<ord.length&&flag1;i++){
			if(resultCount > 0){
				for(int j=0;j<resultCount+1&&flag2;j++){
					if(ord[i] == result[j]){
						flag2 = false;
					}
					count2++;
				}
				if(flag2){
					result[resultCount++]=ord[i];
				}
				count2++;
			}else {
				result[resultCount++]=ord[i];
				count2++;
			}
			count2++;
			
			if(resultCount == 10){
				flag1 = false;
			}
			count2++;
			flag2 = true;
		}

		return result;
	}
	
}

 

1
2
5
6
4
8
3
7
9
0
执行判断的次数211
1
2
5
6
4
8
3
7
9
0
执行判断的次数302