java面试题总结

1.写出下面代码的打印结果：

public class Demo {
	test te=new test();
	static {
		System.out.println("static test");
	}
	public Demo() {
		System.out.println("Demo 构造函数");
	}
	public static void main(String[] args) {
		new MyTest();
	}


}
class test{
	static {
		System.out.println( "test 方法快");
	}
	public  test() {
		System.out.println("test gouzhaohans ");
	}
	
	public test(String str) {
		System.out.println("class"+str);
	}

	
}

class  MyTest extends  Demo{
	test sr=new test("Mytest");

	static {
		System.out.println( "Mytest ");
	}
	public MyTest() {
		System.out.println("Mytest 构造函数");
	}
}

打印结果：

static test

Mytest

test 方法快

test gouzhaohans

Demo 构造函数

classMytest

Mytest 构造函数

 2.写出一个阶乘方法体（写出一个完整的方法体 如3！=3*2*1 ；2！=2*1 ；1！=1）

public class TestRecursive {  
  
    public static void main(String[] arg) {  
        Scanner scanner = new Scanner(System.in);  
        int n = scanner.nextInt();  
        System.out.println(factorial(n));  
    }  
    /** 
     * 使用递归方法计算n的阶乘 
     *  
     * @param n 
     * @return 
     */  
    private long factorial(int n) {  
        if (n == 0) {  
            System.out.println(n + "! = " + 1);  
            return 1;  
        } else {  
            long num = n * factorial(n - 1);  
            System.out.println(n + "! = " + num);  
            return num;  
        }  
    }  
  
    /** 
     * 使用循环方式计算n的阶乘 
     *  
     * @param n 
     * @return 
     */  
    private long test(int n) {  
        long num = 1;  
        for (int i = 1; i <= n; i++) {  
            num *= i;  
        }  
        return num;  
    }  
}  

3.写出一个排序方法

package com.rimi.week3;

import java.util.Arrays;

public class ArraySort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//int [] arr={5,2,3,1,7,8,3,2,2};
		//System.out.println("arr 排序前 ："+Arrays.toString(arr));
	//slectedSort(arr);
		//bubSort(  arr);
		//insertSort(arr);
		//insertSort2(arr);
	//	factorial(4);
		//factorial2(4);
		//System.out.println("arr 排序后 ："+Arrays.toString(arr));
		//System.out.println(factorial(4));
		int  arr[]={3,1,5,2};
	//	merge(arr,0,2,arr.length-1);
		System.out.println(Arrays.toString(arr));
		split(arr,0,arr.length-1);
		System.out.println(Arrays.toString(arr));
	}
	/**
	 * 递归的拆分一个数组
	 * @param arr
	 * @param left
	 * @param right
	 */
	public static void  split(int[] arr, int left, int right){
		int  mid = (right+left)/2;
		if(left<right){
			split(arr,left,mid);
			split(arr,mid+1,right);
			merge(arr,left,mid,right);
			
		}
	}
	
	
	
	/**
	 * 把一个数组两边有序的元素，组合成一个有序数组。
	 * @param arr
	 * @param left
	 * @param mid
	 * @param right
	 */
	public  static  void merge(int []arr, int left, int mid, int right){
	//	int [] temp =new int [arr.length];
		int [] temp =new int [right-left+1];
		int low1= left;
		int  low2=mid+1;
		int  index= 0;
		while (low1<=mid && low2<=right){
			if(arr[low1]<arr[low2]){
				temp[index++] =arr[low1++];
				
			}else{
				temp[index++] = arr[low2++];
			}
		}
		while (low1<=mid){
			temp[index++] = arr[low1++];
		}
		while(low2<=right){
			temp[index++] =arr[low2++];
		}
		System.out.println("left = "+left);
		System.out.println("arr = "+Arrays.toString(arr));
		for (int i = 0; i < index; i++) {
			arr[left++]=temp[i];
		}
		System.out.println("temp = "+Arrays.toString(temp));
		System.out.println("arr = "+Arrays.toString(arr));
		System.out.println("========================");
	}
	
	
	
	
	
	/*
	 * 递归算法 - 阶乘
	 * 实际的计算过程，是从最后一步开始计算；
	 */
	
	
	
	public  static int  factorial(int i){
		while (i !=1){
			System.out.println((i)+"x"+(i-1)+"!");
		return factorial(i-1)*i;// 3!=3*2!
	}
	    return 1;
	}
	
	
	//不是递归算法的阶乘
	
	public  static void  factorial2(int i){
		int result = 1;
	   for (int j = 1; j <=i; j++) {
		   result *=j;
		
	}
		System.out.println( result);
	}
	
	
	
	//while循环实现插入排序
	public  static void  insertSort2(int [] arr){
		for(int i=1;i<arr.length ;i++){
			int j =i;//2,i=2,j=2
			int temp= arr[i];
			while(j>0 && temp<arr[j-1]){
				arr[j]=arr[j-1];
				j--;
			}
			arr[j] = temp;
		}
	}
	
	
	
	
	
	
	//插入排序
	public  static void  insertSort(int [] arr){
		/*
		 * 因为第一个拿出来要做比较的数，前面必须要有数。所以说 i 从1 开始。
		 */
		for(int i=1;i<arr.length;i++){
			int temp =arr[i];   //temp 临时数据
			int  index =0;
			/*
			 *  j 一定要从外循环取出到 temp 数的前一个开始，一直往前面遍历，如果一直找不到
			 *  比取出到temp 里面的数还小的数，就到 j==-1 的时候结束。
			 *  冯喆，到找到比temp 里面数还要小的数就结束。
			 */
			for(int j=i-1;j>=-1;j--){
				index++;
				System.out.println("arr 第"+i+"次外循环，第"+index+"次比较："+Arrays.toString(arr));
				if( j==-1){//如果找到最前面没有元素可找了，就把temp 放入最前面arr[0];
					arr[0]= temp;
					break;
				}
					if(temp <arr[j]){//如果找到的元素比 temp 大，就往后面移动一位。
						arr[j+1]= arr[j];
						
					}else{
						arr[j+1]=temp;//如果找到的元素比 temp 小，就往该数后面放入temp。
						break;
					}
				
				
			}
		}
		
		
	}
	
	
	
	
	//冒泡排序
	public  static  void  bubSort( int[] arr){
		for (int i=0;i<arr.length-1;i++){//控制比较次数， n-1 次 （n表示元素个数）
			/**
			 * 控制相邻的两个元素进行比较，如果说后者小，就交换。
			 * 因为每次外循环完成之后，都会找到一个最大值，放在最后面。
			 * 所以说 j 能取到的最大值，应该依次减小。（j< arr.length-1-i）
			 */
		
			for(int j=0;j<arr.length-1-i;j++){
				if(arr[j]>arr[j+1]){
					int  temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]= temp;
				}
				System.out.println("arr  第"+(i+1)+"次外循环,第"+(j+1)+"比较后"+Arrays.toString(arr));
			}
		}
		
	}
	
	
   //选择排序
	public  static void  slectedSort(int[] arr){
		
		for(int i=0; i<arr.length-1;i++){//控制遍历次数
			int  minIndex = i;
			for (int j=i+1;j<arr.length;j++){//控制比较，找到最小值
				if(  arr[minIndex]>arr[j]){
					minIndex = j;//找到后面的元素，比最前面的元素还要小，就记录其下标
				}
				System.out.println("minIndex = "+minIndex);
				}
				if(minIndex != i){//最小值下标改变过才交换
					 int temp = arr[i];
					 arr[i] =arr[minIndex];
					 arr[minIndex] = temp;
			}
				System.out.println("arr 第 "+(i+1)+"次排序后"+Arrays.toString(arr));
		}

4.个SQL语句；字段有评论详情，被评论人分别在User表和content表中（效果如下）

张三：

 你好，很高兴认识你；

解答：在content表中增加一个字段与user表中进行关联。然后使用内连接（inner join） 后面跟上user.id=增加字段.id

二。面试题

1.servlet和p的区别？

Servlet是一种服务器端的Java应用程序，具有独立于平台和协议的特性，可以生成动态的Web页面。

JSP技术使用Java编程语言编写类XML的tags和scriptlets，来封装产生动态网页的处理逻辑。

【1】JSP第一次运行的时候会编译成Servlet，驻留在内存中以供调用。

【2】JSP是web开发技术，Servlet是服务器端运用的小程序，我们访问一个JSP页面时，服务器会将这个JSP页面转变成Servlet小程序运行得到结果后，反馈给用户端的浏览器。

【3】Servlet相当于一个控制层再去调用相应的JavaBean处理数据,最后把结果返回给JSP。

【4】一般在多层应用中, JSP主要用作表现层,而Servlet则用作控制层,因为在JSP中放太多的代码不利于维护，而把这留给Servlet来实现,而大量的重复代码写在 JavaBean中

总结：jsp中可写java和HTML，jsp是servlet的升级。当第一次编译后jsp文件会转变为servlet文件，jsp主要用做视图。servlet主要做逻辑处理。

2.原生js的ajax和jquery 的ajax的区别

面试官解答：jQuery中ajax的兼容性更好；js原生的ajax在不同的浏览器中可能不会响应。

3.Redis中有50条数据，现在要插入条数据在不用全部清空Redis的情况下怎么处理；

待解答：

4.MySQL的优化？

1. 为查询缓存优化你的查询

2.字段建索引

3.避免 SELECT *

4.远为每张表设置一个ID

5.用 ENUM 而不是 VARCHAR

6.可能的使用 NOT NULL

7固定长度的表会更快

8 拆分大的 DELETE 或 INSERT 语句

9 设计合适的索引,基于主键的查找,上亿数据也是很快的;
10反范式化设计,以空间换时间,避免join,有些join操作可以在用代码实现,没必要用数据库来实现;
11buffer,尽量让内存大于数据.

参考资料：https://www.zhihu.com/question/19719997

参考资料二：http://database.51cto.com/art/201505/476659.htm

5.Mysql的三范式

 第一范式:确保每列的原子性.
第二范式:在第一范式的基础上更进一层,目标是确保表中的每列都和主键相关.
第三范式:在第二范式的基础上更进一层,目标是确保每列都和主键列直接相关,而不是间接相关.

解释: 
1NF:原子性 字段不可再分,否则就不是关系数据库; 
2NF:唯一性 一个表只说明一个事物; 
3NF:每列都与主键有直接关系，不存在传递依赖; 

6.中间件

 activeMQ、

7.Faremark静态页面处理

Freemarker 是一款模板引擎，是一种基于模版生成静态文件的通用 工具，它是为java程序员提供的一个开发包，或者说是一个类库，它不是面向最终用户的，而是为程序员提供了一款可以嵌入他们开发产品的应用程序。

  Freemarker 是使用纯java编写的，为了提高页面的访问速度，需要把页面静态化， 那么Freemarker就是被用来生成html页面。

参考资料：http://blog.csdn.net/chenghui0317/article/details/7832474

8.简述下你对NGINX的了解（集群；程序在高并发的情况下怎么处理）

Nginx (engine x) 是一个高性能的HTTP和反向代理服务器，也是一个IMAP/POP3/SMTP服务器

其特点是占有内存少，并发能力强，能够支持高达 50,000 个并发连接数的响应（实际只有2万）；

9.E-R图模型的组成是由实体，属性和联系。

10.mysql事物的四大特性？

1.原子性（atomicity）：一个事务必须视为一个不可分割的最小工作单元，整个事务中的所有操作要么全部提交成功，要么全部失败回滚，对于一个事务来说，不可能只执行其中的一部分操作，这就是事务的原子性。

2.一致性（consistency）：数据库总数从一个一致性的状态转换到另一个一致性的状态。

3.隔离性（isolation）：一个事务所做的修改在最终提交以前，对其他事务是不可见的。

4.持久性（durability）：一旦事务提交，则其所做的修改就会永久保存到数据库中。此时即使系统崩溃，修改的数据也不会丢失。