记录自己面试遇到的一些常忘的

1.声明数组的三种方式，以int和String举例
//第一种

int [] a = new int[5];
a[0] = 10;
String []a = new String[length];再赋值
a[0]=?;
//第二种
int [] c = new int[]{1,2,3};
String []a = new String[]{?,?...};
//第三种
int [] i ={1,2,3,4};
String []a = {?,?....}

总之，具体的元素不能被【】包裹。【】包裹的应该是数组的

2.声明List与Map，并且遍历它们

public class list_map遍历{
 public static void main(String[] args) {
     List<String> list=new ArrayList<String>();
     list.add("Hello");
     list.add("World");
     list.add("HAHAHAHA");
      
     //第一种遍历方法使用foreach遍历List
     for (String str : list) {            //也可以改写for(int i=0;i<list.size();i++)这种形式
        System.out.println(str);
     }
  
     //第二种遍历，把链表变为数组相关的内容进行遍历
     String[] strArray=new String[list.size()];
     list.toArray(strArray);
     for(int i=0;i<strArray.length;i++) //这里也可以改写为  foreach(String str:strArray)这种形式
     {
        System.out.println(strArray[i]);
     }
      
    //第三种遍历 使用迭代器进行相关遍历
     Iterator<String> ite=list.iterator();
     while(ite.hasNext())//判断下一个元素之后有值
     {
         System.out.println(ite.next());
     }
      
     Map<String, String> map = new HashMap<String, String>();
     map.put("1", "value1");
     map.put("2", "value2");
     map.put("3", "value3");
      
     //第一种：普遍使用，二次取值
     System.out.println("通过Map.keySet遍历key和value：");
     for (String key : map.keySet()) {
      System.out.println("key= "+ key + " and value= " + map.get(key));
     }
      
     //第二种
     System.out.println("通过Map.entrySet使用iterator遍历key和value：");
     Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
     while (it.hasNext()) {
      Map.Entry<String, String> entry = it.next();
      System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
     }
      
     //第三种：推荐，尤其是容量大时
     System.out.println("通过Map.entrySet遍历key和value");
     for (Map.Entry<String, String> entry : map.entrySet()) {
      System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
     }
    
     //第四种
     System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
     for (String v : map.values()) {
      System.out.println("value= " + v);
     }
    }
 
}

3.list里面有map，怎么遍历出来

ArrayList list = new ArrayList();
Map map = new HashMap();
list.add(map);
ArrayList<Map> list = new ArrayList<Map>();
for(int i = 0; i < list.size(); i++) {
    Map map = list.get(i);
    Set set = map.keySet();
    Iterator it = set.iterator();
    while(it.hasNext()) {
        System.out.println(map.get(it.next()));
    }
}

4.冒泡排序与二分排序
冒泡排序是非常好理解的，以从小到大排序为例，每一轮排序就找出未排序序列中最大值放在最后。
设数组的长度为N： 
（1）比较前后相邻的二个数据，如果前面数据大于后面的数据，就将这二个数据交换。
（2）这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。
（3）N=N-1，如果N不为0就重复前面二步，否则排序完成。

以上就是冒泡排序的基本思想，按照这个定义很快就能写出代码：

public class Sort {
	public static void sort(int [] a, int n){  
	    int j , k;  
	    int flag = n ;//flag来记录最后交换的位置，也就是排序的尾边界  
	    while (flag > 0){//排序未结束标志  
	        k = flag; //k 来记录遍历的尾边界  
	        flag = 0;  
	        for(j=1; j<k; j++){  
	            if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换  
	                //交换a[j-1]和a[j]  
	                int temp;  
	                temp = a[j-1];  
	                a[j-1] = a[j];  
	                a[j]=temp;  
	                //表示交换过数据;  
	                flag = j;//记录最新的尾边界.  
	            }  
	        }  
	    }  
	}  
	//测试类  
	public static void main(String[] args) {  
	    int[] arr = {1,1,2,0,9,3,12,7,8,3,4,65,22};  
	    Sort.sort(arr, arr.length);  
	    for(int i:arr){  
	        System.out.print(i+",");  
	    }  
	}  
}

    public static void main(String[] args) {    
        int []a={4,2,1,6,3,6,0,-5,1,1};    
        int i,j;    
        int low,high,mid;    
        int temp;    
        for(i=1;i<10;i++){    
            temp=a[i];    
            low=0;    
            high=i-1;    
            while(low<=high){    
                mid=(low+high)/2;    
                if(a[mid]>temp)    
                    high=mid-1;    
                else    
                    low=mid+1;    
                    
            }    
            for(j=i-1;j>high;j--)    
                a[j+1]=a[j];    
            a[high+1]=temp;    
        }    
        for(i=0;i<10;i++){    
            System.out.print(a[i] + " ");    
        }    
    }

  //二分查找
    public static int search(int[] a, int b){   
        int low = 0;   
        int high = a.length-1;   
        while(low <= high) {   
            int middle = (low + high)/2;   
            if(b == a[middle]) {   
                return middle;   
            }else if(b <a[middle]) {   
                high = middle - 1;   
            }else {   
                low = middle + 1;   
            }  
        }  
        return -1;  
   }

5.单例模式

//饿汉式:
        public class Singleton{
            private static Singleton singleton = new Singleton ();
            private Singleton (){}
            public static Singleton getInstance(){return singletion;}
       } 

//懒汉式:
       public class Singleton{
            private static Singleton singleton = null;
            public static synchronized synchronized getInstance(){
                 if(singleton==null){
                     singleton = new Singleton();
                 }
                return singleton;
            }
       } 

6.JS中的六大数据类型

js中有六种数据类型，包括五种基本数据类型（Number,String,Boolean,Undefined,Null）,和一种复杂数据类型（Object）。

7.Servlet的生命周期
1、加载：在下列时刻加载 Servlet：
（1）如果已配置自动加载选项，则在启动服务器时自动加载 (web.xml中设置<load-on-start>)；
（2）在服务器启动后，客户机首次向 Servlet 发出请求时;
（3）重新加载 Servlet 时（只执行一次）
2、实例化：加载 Servlet 后，服务器创建一个 Servlet 实例。（只执行一次）
3、初始化：调用 Servlet 的 init() 方法。在初始化阶段，Servlet 初始化参数被传递给 Servlet 配置对象ServletConfig。 （只执行一次）
4、请求处理：对于到达服务器的客户机请求，服务器创建针对此次请求的一个“请求”对象和一个“响应”对象。服务器调用 Servlet 的 service() 方法，该方法用于传递“请求”和“响应”对象。service() 方法从“请求”对象获得请求信息、处理该请求并用“响应”对象的方法以将响应传回客户机。service() 方法可以调用其它方法来处理请求，例如 doGet()、doPost() 或其它的方法。（每次请求都执行该步骤）

5、销毁：当服务器不再需要 Servlet, 或重新装入 Servlet 的新实例时，服务器会调用 Servlet 的 destroy() 方法。（只执行一次）