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 {View Code
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）：一旦事务提交，则其所做的修改就会永久保存到数据库中。此时即使系统崩溃，修改的数据也不会丢失。