java面试测试题

Question

接到面试通知，不过在面试之前还要先做这几个测试，刚开始以为公司要榨取方案呢，看题目还好不是，觉得题目还不错，拿出来分享一下。
本来不想发出来的，我破电脑上没有环境。等下装环境，争取明天上午之前把这些搞定。先贴题吧，我自己肯定先做，做好之后再向大家学习。
PS:工作经验一年不满，集合类用得比较少- - 大家别鄙视我哈
1.     写一个函数, 把字符串集合按照长度进行分拣
a)          输入:  Set<String>
b)          输出:  Map<Integer, List<String>>, key 是输入字符串中的各种长度, value 是同一个长度的所有字符串的List.
2.    要求将多个有序数组合并成一个数组，要求得到的最终结果数组有序排列，同时剔除两个数组中的重复数据。
请设计一个简便算法。
例如：第一个数组为1，3，5，9，11，18
      第二个数组为2，4，7，8，11，20
要求得到的最终数组为1，2，3，4，5，7，8，9，11，18，20
第一个数组为1，3，5，9，11，18
     第二个数组为2，4，7，8，11，20
第三个数组为14，13
要求得到的最终数组为1，2，3，4，5，7，8，9，11，13，14，18，20
3.    有一个List集合，集合元素为Set对象，每一个Set对象含有元素为Character。
要求设计一个算法得到Set对象所有元素可能组合。
例如：List中有3个set对象，
      第一个set对象元素为11，12，13
      第二个set对象元素为99，AA,B,DD
      第三个set对象元素为7，8，34
那么可能组合为
      11997，11998，119934,11AA7,11AA8,11AA34……

Answer 1

第一个问题，你用长度做KEY，如果set集合中字符串的长度有相同的话，将只能加进去一个。

Answer 2

1、计算set中每个String的长度，判断map中是否有此长度的List存在，有则加入；没有就put进map。
2、借助List实现去重合并，借助Collections实现排序。
3、只会三层循环，见笑了。

Answer 3

public static void outMap(){
Set<String> set=new HashSet<String>();
String[] array={"aa","123","ccccc","dddddddd","2222","hh","123123123"};
for(String str:array)
set.add(str);
Map<Integer,List<String>> map=new HashMap<Integer,List<String>>();
List<String> list=null;
    for(String key:set){
     if(map.isEmpty()||!map.containsKey(key.length())){
     list=new ArrayList<String>();
     list.add(key);
     map.put(key.length(),list);
     }else{
     list=map.get(key.length());
     list.add(key);
     map.put(key.length(),list);
     }
    }
    System.out.println(map);
}

public static void ArraySort(){
int[] array1={1,3,5,9,11,18};
int[] array2={2,4,7,8,11,20};
Set<Integer> set=new TreeSet<Integer>();
for(int i:array1)
set.add(i);
for(int j:array2)
set.add(j);
System.out.println(Arrays.toString(set.toArray(new Integer[0]))); }第三题Set中放Character，还得把11,12,13之类的转化成char，然后转回来。麻烦不做了、

Answer 4

 import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;public class Test {
public static void main(String[] args) {
//测试1
Set<String> set = new HashSet<String>();
set.add("123");
set.add("12");
set.add("321");
set.add("21");
set.add("1234");
Map<Integer, List<String>> map = mapStringByLength(set);
Set<Integer> keySet = map.keySet();
for(int key : keySet){
System.out.println("字符串长度为:"+key+"的有：");
List<String> list = (List<String>)map.get(key);
System.out.println(list);
}

//测试2
List<int[]> list = new ArrayList<int[]>();
int[] a = {1,3,5,9,11,18};
list.add(a);
int[] b = {2,4,7,8,11,20};
list.add(b);
int[] c = {14,13};
list.add(c);
int[] result = arrayMergerSort(list);
for(int number : result){
System.out.print(number+",");
}
}
/**
 * 1. 写一个函数, 把字符串集合按照长度进行分拣
   a) 输入: Set<String>
   b) 输出: Map<Integer, List<String>>, 
   key 是输入字符串中的各种长度, value 是同一个长度的所有字符串的List.
 */
public static Map<Integer, List<String>> mapStringByLength(Set<String> set){
Map<Integer, List<String>> map = new HashMap<Integer, List<String>>();
for(String str : set){
int len = str.length();
List<String> list = map.get(len);
if(null == list || list.size() == 0){
list = new ArrayList<String>();
list.add(str);
map.put(len, list);
}

else{
list.add(str);
map.put(len, list);
}
}
return map;
}

/**
 * 2. 要求将多个有序数组合并成一个数组，要求得到的最终结果数组有序排列，同时剔除两个数组中的重复数据。
请设计一个简便算法。
例如：第一个数组为1，3，5，9，11，18
    第二个数组为2，4，7，8，11，20
 要求得到的最终数组为1，2，3，4，5，7，8，9，11，18，20

第一个数组为1，3，5，9，11，18
   第二个数组为2，4，7，8，11，20
第三个数组为14，13
要求得到的最终数组为1，2，3，4，5，7，8，9，11，13，14，18，20
 * @param int[]集合
 * @return int[]
 */
public static int[] arrayMergerSort(List<int[]> list){
if(list == null || list.size() == 0) return new int[0];
else{
Set<Integer> set = new TreeSet<Integer>();
int[] result = null;
for(int[] arr : list){
for(int number : arr){
set.add(number);
}
}

result = new int[set.size()];
int count = 0;
for(int number : set){
result[count] = number;
count++;
}
return result;
}
}
}写了俩，第3个没想出来，关键set有几个不知道，多次循环的话，我估计会死人的

Answer 5

public static Map<Integer, List<String>> Method1(Set<String> aStrSet){
     HashMap<Integer, List<String>> result = new HashMap<Integer, List<String>>();
     Iterator<String> itr = aStrSet.iterator();
     while(itr.hasNext()) {
         String strElement = itr.next(); 
         if (!result.containsKey(strElement.length())){
          ArrayList<String> list = new ArrayList<String>();
          list.add(strElement);
          result.put(strElement.length(), list);
         }
         else {
          result.get(strElement.length()).add(strElement);
         }
     }
     return result;
    }
第二第三题前两天已经有一模一样的题了，不少人给出了很好的办法

Answer 6

第三个没找到，重写一下
public static void main(String args[]) {
     /*
      * 3
      */
     String[] array = {""};
     Set<String> strSet = new HashSet<String>();
     strSet.add("11");
     strSet.add("12");
     strSet.add("13");
     Set<String> strSet1 = new HashSet<String>();
     strSet1.add("99");
     strSet1.add("AA");
     strSet1.add("B");
     strSet1.add("DD");
     Set<String> strSet2 = new HashSet<String>();
     strSet2.add("7");
     strSet2.add("8");
     strSet2.add("34");
     array =  method3(array,strSet);
     array =  method3(array,strSet1);
     array =  method3(array,strSet2); for (Object s:array)
System.out.println(s);
    
    }
public static String[] method3(String strArray[],Set<String> strSet){
     List<String> list = new ArrayList<String>(); 
     for (String str:strArray){
     for (String endStr:strSet){    
     list.add(str + endStr);
     }
     }    
     return  (String[]) list.toArray(new String[0]);
    }

Answer 7

你这个写的有点死板了，注意是List里放Set对象，他们各自数目未定，应该用到递归来进行排列组合

Answer 8

第二题：
TreeSet set = new TreeSet(Arrays.asList(数组1));
set.addAll(Arrays.asList(数组2));
set.addAll(Arrays.asList(数组3));
....
return set.toArray();

Answer 9

1. 写一个函数, 把字符串集合按照长度进行分拣
a) 输入: Set<String>
b) 输出: Map<Integer, List<String>>, key 是输入字符串中的各种长度, value 是同一个长度的所有字符串的List.Map<Integer, List<String>> map = new HashMap<Integer, List<String>>(); 
for(String str :set){
 List list =(List) map.get(str);
 if(list==null){
    list = Arrays.asList(new String[]{str});
 }else{
    list.add(str);
 }
   map.put(str.length(), list);
}
return map;

Answer 10

第三题很奇怪，为什么说了是Character对象，还会出现AA,DD这样的

Answer 11

1、计算set中每个String的长度，判断map中是否有此长度的List存在，有则加入；没有就put进map。
2、如果数字都比较小，那么以当前数字中最大的为list长度，将每个数字add到对应的下标中 。 如 add（“123”，123）；
3、递归 

Answer 12

public static Integer[] sortList(int[]... array)
{
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < array.length; i++) //数组数
{
for (int j = 0; j < array[i].length; j++) //某个数组
{
if (!list.contains(array[i][j])) 
{
list.add(array[i][j]);
}
}
}
Integer[] newint = new Integer[list.size()];
list.toArray(newint);
Arrays.sort(newint);
return newint;
}