Java 面试题汇总

╰+攻爆jí腚メ 2022-01-26 00:49 712阅读 0赞

## 一.Java基础知识 ##

### 1.Java 中成员变量访问权限 ###

![在这里插入图片描述][20190527093446814.png]  
1）private：只有在当前类内部中能使用  
2）default：在类内部可以被访问，也可以被同个包（同一目录下）下其他类访问  
3）protected：可以在类内部被访问，也可以被同个包下其他类访问,也可以被其子类访问  
4）public：可以被任何地方访问

### 2.super()与 this()的区别 ###

解答：  
this()：指当前类的对象的引用  
super()：指父类对象的引用

在Java类中使用super来引用父类的成份，用this来引用当前对象,如果一个类从另一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象，怎么去引用里面的父类的对象呢？使用super来引用，this指的是当前对象的引用，super是当前对象里面的父对象的引用

### 3.编程图形输出 ###

#### 3.1 图形1 ####

![在这里插入图片描述][20190527112435730.png]

public void TuXing1(){ 
            for(int j = 0;j < 4;j++){ 
                for(int i = 4;i > j;i--){ 
                    System.out.print("*");
                }
                System.out.print("\n");
            }
        }

#### 3.2 图形2 倒序输出99乘法表 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70]

public void TuXing2(){ 
            for(int i = 9;i>0;i--){ 
                for(int j = i;j>0 ;j--){ 
                    System.out.print(i + " * "+ j + " = "+ (i * j) + "\t");
                }
                System.out.println();
            }
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 1]

public void TuXing3(){ 
    	for(int i = 9; i>0; i--){ 
    		for(int j = 1;j <= i;j++){ 
    			System.out.print(j + " * " + i +" = "+ j*i + "\t");
    			}
    	System.out.print("\n");
       }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 2]

public TuXing4(){ 
    	for(int i = 1; i<=9;i++){ 
    		for(int j = 1;j<=i;j++){ 
    			System.out.print(j + " * " + i +" = "+ j*i + "\t");
              }
    		}
      }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 3]

public void TuXing6(){ 
    	for(int i=1;i<=9;i++){ 
    	//空格
    	for(int a=i ;a > 9;a++){ 
    		System.out.print("\t")
    	  }
    	for(int j= i ; j>0 ; j--){ 
    		System.out.print(j + " * " + i + "=" + i * j + "*")		
    	  }
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 4]

public void TuXing7(){ 
    	for(int i = 9;i>0;i++){ 
    		//打印空格
    		for(int a = 0;a < 9-i;a++){ 
    			System.out.print("\t")
    		}
    		for(int j = i;j>0;j--){ 
    			System.out.print(j + " * "+ i  + " = " + i * j+"\t")
    		}
    	}
    }

### 4.Java的事件委托机制和垃圾回收机制 ###

事件委托机制：一个源产生一个事件并将它送到一个或多个监听器那里。在这种方案中，监听器简单的等待，直到它收到一个事件，一旦事件被接受，监听器将处理这个事件，然后返回  
垃圾回收机制：垃圾收集是将分配给对象但不再使用的内存回收或释放的过程。如果一个对象没有指向它的引用或者其赋值为null,则此对象适合进行垃圾回收

### 5.在Java中，如何跳出当前的多重嵌套循环 ###

用break,return方法

### 6.什么是Java序列化，如何实现Java序列化 ？（写一个实例） ###

序列化：处理对象流的机制，所谓对象流就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可以将流化后的对象传输于网络之间。序列化是为了解决在对对象流 进行读写操作时所引发的问题  
序列化的实现：将需要被实例化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable

### 7.一个“.java”源文件中是否可以包括多个类（不是内部类）？有什么限制？ ###

解答：  
可以。如果这个类的修饰符是public,其类名与文件名必须相同

### 8.排序都有哪几种方法？请列举。用Java实现一个快速排序？ ###

转载：[https://blog.csdn.net/shujuelin/article/details/82423852][https_blog.csdn.net_shujuelin_article_details_82423852]  
排序的方法有：插入排序（直接插入排序，希尔排序），交换排序（冒泡排序，快速排序），选择排序（直接选择排序，堆排序），归并排序，分配排序（箱排序，基数排序）。  
快速排序之所比较快，因为相比冒泡排序，每次交换是跳跃式的。每次排序的时候设置一个基准点，将小于等于基准点的数全部放到基准点的左边，将大于等于基准点的数全部放到基准点的右边。这样在每次交换的时候就不会像冒泡排序一样每次只能在相邻的数之间进行交换，交换的距离就大的多了。因此总的比较和交换次数就少了，速度自然就提高了。当然在最坏的情况下，仍可能是相邻的两个数进行了交换。因此快速排序的最差时间复杂度和冒泡排序是一样的都是O(N2)，它的平均时间复杂度为O(NlogN)。其实快速排序是基于一种叫做“二分”的思想

public class QuickSort { 
    
    	public static void quickSort(int[] arr,int low,int high){ 
    		int i,j,temp,t;
    		if(low > height){ 
    			return;
    		}
    		 i = low;
    		 j = high;
    		 //temp就是基准位
    		 temp = arr[low];
    	   while (i<j){ 
    			//先看右边，依次往左递减
    			while (temp <= arr[j] && i<j) { 
    				j--;
    			}
    			//再看左边，依次往右递增
    			while (temp >= arr[i] && i <j){ 
    					i++;
    				}
    				//如果满足条件则交换
    				if (i < j){ 
    					t = arr[j];
    					 arr[j] = arr[i];
    					  arr[i] = t;
    			}
    		}
    		//最后将基准位与i 和 j相等位置的数字交换
    		arr[low] = arr[i];
    		arr[i] = temp;
    		//递归调用坐半数组
    		quickSort (arr,low,j-1);
    		//递归调用右半数组
    		quickSort (arr,j+1,high);
    	}
    	public static void main(String[] args){ 
            int[] arr = { 10,7,2,4,7,62,3,4,2,1,8,9,19};
            quickSort(arr, 0, arr.length-1);
            for (int i = 0; i < arr.length; i++) { 
                System.out.println(arr[i]);
            }
        }
    }

### 9.Overload 和Override的区别。Overloaded的方法是否可以改变返回值得类型? ###

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的运行时的多态性  
方法的重写Override,子类覆盖父类的方法，将子类传与父类的引用调用的还是子类的方法  
重载Overloading一个类多个方法，名称相同，参数个数类型不同。  
两者都是Java 多态性的不同表现  
Overloaded的方法是可以改变返回值得类型

### 10.单例模式 ###

什么是单例模式：  
单例：保证一个类仅有一个实例，并提供一个访问它的全局访问点  
单例模式是一种常用的软件设计模式之一，其目的是保证整个应用中只存在类的唯一一个实例  
几种单例模式的比较  
饿汉式：

*  优点：线程安全，获取实例速度快
 *  缺点：类加载即初始化实例，内存浪费

public class Singleton{ 
    	private static final Singleton singleton = new Singleton();
    	private Singleton{ 
    	}
    	public static Singleton getInstance(){ 
    		return singleton;
    	}
    }

懒汉式：

*  优点：在获取实例的方法中，进行实例的初始化，节省系统资源
 *  缺点：
    
     *  如果获取实例时，初始化工作较多，加载速度会变慢，影响系统性能
     *  每次获取实例都要进行费控检查，系统开销大
     *  非线程安全，当多个线程同时访问getInstance()时，可能会产生多个实例

public class Singleton { 
    	private static Singleton singleton = null;
    	private Singleton(){ 
    	}
    	public static Singleton getInstance(){ 
    		if(singleton == null) { 
             singleton = new Singleton();
            }
            return singleton;
    	}
    }

单例模式的优缺点  
1.优点：该类只存在一个实例，节省系统资源，对于需要频繁创建销毁的对象，使用单例模式可以提高系统性能  
2.缺点：不能外部实例化（new）

### 11.下列哪个为JSP的隐含对象 ###

**A.env  
B.page  
C.jsp info  
D.context**  
解答：B  
JSP有9个隐含对象  
request对象：保存了很多客户端请求的信息  
response对象：生成服务器响应，然后将响应结果发送到客户端  
out对象：表示输出流，此输出流将作为请求发送到客户端  
session对象：我们写个对象放在这个session对象中，这个对象就在我们的会话中都存在  
application对象：我们写个对象放在这个application对象中，这个对象就在整个应用程序中都存在  
pageContext对象:对象相当于当前页面的容器，可以访问当前页面的所有对象  
paget对象：一般我们使用Page指令来代替使用这个对象  
exception对象：用来处理异常的  
config对象：一样的我们在页面中是使用很少的，一般会在servlet中使用这个

### 12.执行完以下代码 int\[\] x = new int\[25\];String\[\] arr = new String\[25\]后x\[24\]=?,arr\[24\]=? ###

解答：  
x\[24\] = 0,arr\[24\] = null

### 13.下面这段代码片段的运行结果是： ###

int i = 1;
    switch (i){ 
    	Case 0:
    	System.out.print("zero");
    	break;
    	Case 1：
    	System.out.print("one")
    	Case 2:
    	System.out.print("two")
    	default:
    	System.out.print("default");
    }

A.one  
B.default  
C.onetwodefault  
D.编译错误  
PS:switch语句可以包含一个default分支，该分支一般是switch的最后一个分支。default在没有case语句的值和变量值相等的时候执行。default分支不需要break语句

### 14.下列代码哪行会报错： ###

(1) public void modify(){ 
     (2)    int i,j,k;
     (3)     i = 100;
     (4)     while(i > 0){ 
     (5)       j = i * 2;
     (6)       System.out.println("The value of j is" + j);
     (7)       k = k + 1;
     (8)       i--;
     (9)      };
     (10)   }

A.4  
B.6  
C.7  
D.5  
错误原因：变量可能没有被初始化

### 15.Java关键字和保留字（then不是关键字） ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 5]

### 16.下面关于MVC的说法不正确的是（）。 ###

A . M表示Model层，是存储数据的地方  
B . View表示视图层，负责向用户显示外观  
C . Controller是控制层，负责控制流程  
D . 在MVC架构中jsp通常做控制层

### 17.java中的类修饰符、成员变量修饰符、方法修饰符 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 6]

### 18.下列定义变量的语句哪些是正确的（） ###

A. int $a = 10;  
B. float f = 1.01;  
C.long \_int = 120  
D.String\[\] str = \{“a”,“b”,“c”\};  
原因：因为Java里带有小数点的数默认是double类型，所以1.01在这里是double类型，把他赋值给比他小的float类型就会出错。你想通过编译的话有3种方法改：  
double f=1.01;  
或者  
float f=1.01f;  
或者  
float f=(float)1.01;

### 19.面向对象的特征有哪些方面？ ###

1.抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么

2.继承 ：继承是从已有类得到继承信息创建新类的过程，提供继承信息的类被称为父类，得到继承信息的类被称为子类

3.封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口  
4.多态：多态性是指允许不同子类型的对象对同一消息做出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情 。  
多态存在的三个必要条件：  
继承，重写，父类引用指向子类对象  
比如：Parent p = new Child();  
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。  
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。  
以下是一个多态实例的演示，详细说明请看注释：

public class Test { 
        public static void main(String[] args) { 
          show(new Cat());  // 以 Cat 对象调用 show 方法
          show(new Dog());  // 以 Dog 对象调用 show 方法
                    
          Animal a = new Cat();  // 向上转型 
          a.eat();               // 调用的是 Cat 的 eat
          Cat c = (Cat)a;        // 向下转型 
          c.work();        // 调用的是 Cat 的 work
      }  
                
        public static void show(Animal a)  { 
          a.eat();  
            // 类型判断
            if (a instanceof Cat)  {   // 猫做的事情 
                Cat c = (Cat)a;  
                c.work();  
            } else if (a instanceof Dog) {  // 狗做的事情 
                Dog c = (Dog)a;  
                c.work();  
            }  
        }  
    }
     
    abstract class Animal {   
        abstract void eat();  
    }  
      
    class Cat extends Animal {   
        public void eat() {   
            System.out.println("吃鱼");  
        }  
        public void work() {   
            System.out.println("抓老鼠");  
        }  
    }  
      
    class Dog extends Animal {   
        public void eat() {   
            System.out.println("吃骨头");  
        }  
        public void work() {   
            System.out.println("看家");  
        }  
    }

结果：

吃鱼
    抓老鼠
    吃骨头
    看家
    吃鱼
    抓老鼠

### 20.String是基本的数据类型吗？ ###

解答：不是  
Java中的基本数据类型只有8个  
byte,short,int,long,float,double,char,boolean

### 21.float f = 3.4是否正确？ ###

解答：不正确  
3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换float f =(float)3.4; 或者写成float f =3.4F;

### 22.short s1 = 1; s1 = s1 + 1 有错吗? short s1 = 1; s1 += 1 有错吗？ ###

对于short s1 = 1; s1 = s1 + 1;由于1是int类型，因此s1+1运算结果也是int 型，需要强制转换类型才能赋值给short型。而short s1 = 1; s1 += 1;可以正确编译，因为s1+= 1;相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换

### 23.int和Integer有什么区别？ ###

为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。 Java 为每个原始类型提供了包装类型：

*  原始类型: boolean，char，byte，short，int，long，float，double
 *  包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

class AutoUnboxingTest { 
        public static void main(String[] args) { 
            Integer a = new Integer(3);
            Integer b = 3;                  // 将3自动装箱成Integer类型
            int c = 3;
            System.out.println(a == b);     // false 两个引用没有引用同一对象
            System.out.println(a == c);     // true a自动拆箱成int类型再和c比较
        }
    }

public class Test03 { 
        public static void main(String[] args) { 
            Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
            System.out.println(f1 == f2);   //true
            System.out.println(f3 == f4);   //false
        }
    }

注意：如果整型字面量的值在-128 到127之间，那么不会new新的Integer对象，而是直接用引用常量池中的Integer对象

### 24.Math.round(11.5) 等于多少？Math.round(-11.5)等于多少？ ###

解答：  
Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加0.5然后进行下取整

### 25.数组有没有length()方法？String有没有length()方法？ ###

解答：  
数组没有length()方法，有length的属性。String有length()方法

### 26.是否可以继承String类？ ###

解答：  
String类是final类，不可以被继承

### 27.String和StringBuilder,StringBuffer的区别？ ###

解答：

*  String是只读字符串，也就意味着String引用的字符串内容是不能被改变
 *  StringBuffer和StringBuilder类表示的字符串对象可以直接进行修改

### 28.阐述final,finally,finalize的区别？ ###

final:修饰符（关键字）有三种用法：

*  如果一个类被声明为final,意味着它不能再派生出新的子类，即不能被继承
 *  如果一个变量为final,可以保证他们在使用中不被改变，被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取不可修改。
 *  被声明为final的方法也同样只能使用，不能在子类中被重写

finally:通常放在try…catch…的后面构造总是执行代码块，无论正常执行还是发生异常这里的代码只要JVM不关闭都能执行

finalize:Object类中定义的方法，Java中允许使用finalize（）方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用的，通过重写finalize（）方法可以整理系统资源或者执行其他清理工作

### 29.Collection和Collections的区别？ ###

解答：

*  Collection是一个接口，它是Set,List等容器的父接口
 *  Collections是一个工具类，提供一系列的静态方法来辅助容器操作，这些方法包括对容器的搜索，排序，线程安全化等等

### 30.List,Map,Set三个接口存取元素时，各有什么特点？ ###

解答：

*  List以特定索引来存取元素，可以有重复元素
 *  Set不能存放重复元素
 *  Map保存键值对映射，映射关系可以是一对一或者多对一

### 31.TreeMap和TreeSet在排序时如何比较元素？Collections工具类中的sort()方法如何比较元素？ ###

解答：  
TreeSet要求存放的对象所属的类必须实现Comparable接口，该接口提供了比较元素的compareTo()方法，当插入元素时会回调该方法比较元素的大小。  
TreeMap要求存放的键值对映射的键必须实现Comparable接口从而根据键对元素进行排序。  
Collections工具类的sort方法有两种重载的形式

*  第一种要求传入的待排序容器中存放的对象必须实现Comparable接口以实现元素的比较
 *  第二种不强制性的要求容器中的元素必须可比较，但是要求传入第二个参数，参数是Comparator接口的子类型（需要重写compare方法实现元素的比较）

### 32.Thread类的sleep()方法和对象的wait()方法都可以让线程暂停执行，它们有什么区别? ###

解答：  
sleep()方法是线程类的静态方法，调用此方法会让当前线程暂停执行指定的时间，将执行机会让给其他线程，因此休眠时间结束后会自动恢复  
wait()是Object类的方法，调用对象的wait（）方法导致当前线程放弃对象的锁，进入对象的等待池，只有调用对象的notify方法时才能唤醒等待池中的线程进入等锁池，如果线程重新获得对象的锁就可以进入就绪状态

### 33.请说出与线程同步以及线程调度相关的方法 ###

解答:  
wait()：使一个线程处于等待（阻塞）状态，并且释放锁持有的对象的锁  
sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要处理InterruptedException异常  
notify()：唤醒一个处于等待状态的线程，当然在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是有Jvm确定唤醒哪个线程，而且与优先级无关  
notityAll()：唤醒所有处于等待状态的线程，该方法并不是将对象的锁给所有线程，而是让他们竞争，只有获得锁的线程才能进入就绪状态

### 34.写一个方法，输入一个文件名和一个字符串，统计这个字符串在这个文件中出现的次数 ###

public final class FileUtil{ 
     /** * @param filename 文件名 * @param word 字符串 */
     public static int countWordFile(String filename,String word){ 
      try(FileReader fr = new FileReader(filename)){ 
    	try(BufferedReader br = new BufferedReader(fr)){ 
         String line = null;
         while((line = br.readLine()) != null){ 
    		int index = -1;
    		while(line.length() >= wword.length() && (index = line.indexOf(word)) >= 0){ 
    			counter++;
    			line = line.substring(index + word.length());
              }
    	   }
         }
      } catch (Exceptino ex){ 
    	ex.printStackTrace();
       }
      }
       return counter;
      }
     }

### 35.简述一下你常用的设计模式 ###

*  工厂模式：工厂类可以根据条件生成不同的子类实例，这些子类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作（多态方法）。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。
 *  代理模式：给一个对象提供一个代理对象，并由代理对象控制原对象的引用。实际开发中，按照使用目的的不同，代理可以分为：远程代理、虚拟代理、保护代理、Cache代理、防火墙代理、同步化代理、智能引用代理。
 *  适配器模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起使用的类能够一起工作。
 *  模板方法模式：提供一个抽象类，将部分逻辑以具体方法或构造器的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法（多态实现），从而实现不同的业务逻辑。 除此之外，还可以讲讲上面提到的门面模式、桥梁模式、单例模式、装潢模式（Collections工具类和I/O系统中都使用装潢模式）等，反正基本原则就是拣自己最熟悉的、用得最多的作答，以免言多必失。

### 36.Java实现冒泡排序 ###

public class BubbleSort{ 
    	public static void sortMethods(int[] arr){ 
    		int temp; //定义一个临时变量
    		for(int i= 0 ;i < arr.length-1;i++){ 
    			for(int j= 0;j < arr.length-1-i;j++){ 
    			if(arr[j+1] < arr[j]){ 
    				temp = arr[j];
    				arr[j] = arr[j+1];
    				arr[j+1] = temp;
    			  }
    			 }
    			}
           }
         public static void main(String[] args) { 
    	      int arr[] = new int[]{ 1,6,2,2,5};
    	      BubbleSort.sortMethods(arr);
    	      System.out.println(Arrays.toString(arr));
      }
    }

### 37.Struts2面试题 ###

1.  Struts2工作流程

举例说明：  
![图1][1]

![图2][2]

1.  Struts2 优点：  
    (1)基于MVC架构，框架结构清晰  
    (2)使用OGNL，可以快速的访问值栈中的数据，调用值栈中对象的方法  
    (3)Struts2中有很多特性都是通过拦截器实现的，例如异常处理，验证。使用拦截器时会配置与重用  
    (4)多种表现层技术，JSP，FreeMarker等
2.  Struts2拦截器和过滤器的区别  
    (1)过滤器依赖于Servlet容器，而拦截器不依赖于Servlet容器  
    (2)Struts2拦截器只能对Action请求起作用，而过滤器则可以几乎对所有的请求起作用  
    (3)拦截器可以访问Action上下文（ActionContext），而过滤器不行  
    (4)在Action的生命周期中，拦截器可以多次调用，而过滤器只能在容器初始化时被调用一次
3.  ValueStack  
    (1) ValueStack是多实例的，因为Action是多实例的（Servlet是单例的）每一个Action都有一个对应的值栈，Action对象默认保存在栈顶  
    (2) ValueStack贯穿整个Action的生命周期，保存在request域中，所以ValueStack和request的生命周期时一样的
4.  标签（Struts2项目大多用到的标签）
    
     *  El表达式
     *  JSP自定义标签
     *  JSTL标签ku
     *  OGNL表达式

### 38. Hibernate常见面试题详解（乐观锁，悲观锁） ###

1.  Hibernate数据三种状态  
    1.1 临时的（刚new出来的数据，内存有，数据库没有）  
    1.2 持久的（从数据库查询的，或者保存到数据库，session没关闭的，数据库有，内存也有）  
    1.3 游离的 （数据库有，内存没有）  
    三种状态之间的转化：![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 7]
2.  Hibernate概述  
    Hibernate是一个开放源代码的ORM（对象关系映射）框架，它对JDBC进行了非常轻量级的对象封装
3.  什么是对象持久化  
    所谓持久化，即把数据保存到持久化设备，既可以永久保存的存储设备中（磁盘，数据库，XML数据文件中）
4.  为什么要持久化  
    4.1 内存不能持久  
    4.2 内存容量有限  
    4.3 业务数据共享的需要  
    4.4 为了使用大规模的检索  
    4.5 数据管理的需要
5.  Hibernate缓存机制  
    5.1 一级缓存：session缓存  
    5.2 二级缓存：sessionFactory缓存，可以跨session访问（通过第三方缓存框架实现，例如：EHcache）
6.  Hibernate的get和load方法的区别  
    6.1 get和load都是利用主键策略查询数据  
    6.2 get默认不使用懒加载机制，load默认要使用懒加载，所谓懒加载就是我们这个数据如果不使用，hibernate就不发送sql到数据库查询数据  
    6.3 当查询数据库中不存在的数据的时候，get方法返回null，load方法抛出空指针异常（原因是因为，load方法采用的动态代理的方式实现的，我们使用load方法的时候，hibernate会创建一个该实体的代理对象，该代理只保存了该对象的ID，当我们访问该实体对象其他属性，hibernate就发送SQL查询数据封装到代理对象，然后在利用代理对象返回给我们实际的数据）

### 39.Mybatis面试题 ###

1.  mybatis概述：  
    1.1 mybatis是一个半ORM(对象关系映射)框架，它内部封装了JDBC,可以之间写原生态sql,可以严格控制sql执行性能，灵活度高  
    1.2 mybatis可以使用XML或注解来配置和映射原生信息  
    1.3 通过XML文件或注解的方式将要执行的各种statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句
2.  mybatis优点：  
    2.1基于sql语句编程  
    2.2与JDBC相比，代码量会减少  
    2.3能够与Spring很好的集成  
    2.4提供映射标签
3.  mybais缺点:  
    3.1 sql语句的编写工作量大  
    3.2 sql语句以来数据库，导致数据库移值性差，不能随意更换数据库

### 40.Springboot面试题 ###

1.  Springboot的概述：用来简化spring应用的初始搭建以及开发过程 使用特定的方式来进行配置（properties或yml文件）,习惯优于配置的方法（@EnableAutoConfiguration)
2.  Spring boot 优点：  
    2.1 独立运行  
    2.2 简化配置  
    2.3 自动配置  
    2.4 无代码生成和XML配置  
    2.5 应用监控（actuator依赖）  
    2.6 上手容易  
    2.7 starters自动依赖与版本控制  
    2.8 大量的自动配置，简化开发，也可修改默认值
3.  Springboot自动配置的原理：在Spring程序main方法中添加@SpringbootApplication或@EnablrAutoConfiguration会自动去maven中读取每个starter中的spring.factories文件，该文件里配置了所有需要被创建spring容器的bean
4.  Spring Boot、Spring MVC 和 Spring 有什么区别？  
    4.1 SpringFramework最重要的特征是依赖注入。所有SpringModules不是依赖注入就是IOC控制反转  
    4.2 SpringMvc提供了一种分离式的方法来开发 web应用。开发web应用比较简单  
    4.3 Spring boot 通过一个自动配置和启动的项目解决这个问题

### 41.Redis 为什么查询速度快？ ###

1.完全基于内存  
2.数据结构简单  
3.采用单线程

### 42.String,StringBuffer和StringBuilder三者的区别 ###

主要区别在于两个方面：运行速度和线程安全方面

*  运行速度：StringBuilder > StringBuffer > String  
    原因：String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 8]
 *  线程安全：StringBuilder线程是不安全的，StringBuffer是线程安全的（StringBuffer中有很多方法带有synchronized关键字，所以说线程是安全的)  
    ps:如果要进行的操作是多线程的，那么就要使用StringBuffer但是在单线程的情况下，还是建议使用速度比较快的StringBuider
 *  总结：
    
    1.  String：适用于少量的字符串操作的情况
    2.  StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
    3.  StringBuffer：适用多线程下在字符缓存区进行大量操作的情况

### 43.Session和Cookie的区别 ###

*  Cookie数据保存在客户端，Session数据保存在服务器端
 *  单个Cookie保存的数据不能超过4k,Session是无限制的
 *  Cookie不是很安全，别人可以分析存放在本地的Cookie并进行Cookie欺骗，考虑到安全应当使用session
 *  Session会在一定时间内保存在服务器上，当访问增多，会比较占用你服务器的性能，考虑到减轻服务器性能方面，应当使用Cookie
 *  可以考虑将登陆信息等重要信息存放在session,其他信息如果需要保留，可以放在cookie中
 *  Cookie可以设置失效时间
 *  Cookie不会占用服务器资源，是存在客户端内存或者一个Cookie的文本文件中，而Session则会占用服务器资源，所以不要使用Session，而使用Cookie

### 44.Java多线程 ###

1.  多线程作用？  
    发挥多核CPU优势，防止阻塞，便于建模
2.  创建多线程的方式？  
    1）继承 Thread类 2）实现Runnable接口
3.  Start() 方法和Run() 方法的区别？  
    1）Start(）方法用来启动线程，真正实现了多线程运行，这时无需等待run()方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的Start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法,这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止  
    2）　run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。  
    3）总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。这两个方法应该都比较熟悉，把需要并行处理的代码放在run()方法中，start()方法启动线程将自动调用 run()方法，这是由jvm的内存机制规定的。并且run()方法必须是public访问权限，返回值类型为void

### 45.Java中数组，链表的优缺点 ###

数组（Array）：

*  长度固定
 *  可以存储基本类型，也可以存储引用类型
 *  存储元素类型一致
 *  数组可以在内存中连续存储多个元素的构造，在内存中的分配也是连续的
 *  数组中的元素通过数组的下标进行访问的，下标从0开始的  
    优点：
 *  按照索引查询元素速度快
 *  按照索引遍历数组方便  
    缺点：
 *  数组的大小固定后就不能扩容了
 *  数组只能存储一种类型的数据
 *  添加，删除的操作慢，因为要移动其他的元素  
    适用场景：  
    频繁查询，对存储空间要求不大，很少增加和删除的情况

链表：

*  通过一个链子把多个结点（元素）连接起来，由数据和地址组成的一个元素，
 *  节点本身必须有一个地址值（就是下一个元素的地址值）  
    优点：
 *  链表是很常用的一种数据结构，不需要初始化容量，
 *  可以任意加减元素；
 *  添加或者删除元素时只需要改变前后两个元素结点的指针域指向地址即可，所以添加，删除很快；  
    缺点：
 *  因为含有大量的指针域，占用空间较大；
 *  查找元素需要遍历链表来查找，
 *  非常耗时。  
    适用场景：  
    数据量较小，需要频繁增加，删除操作的场景

### 46.Java 堆和栈的区别 ###

1.栈内存用来存储局部变量和方法调用，内存用来存储Java中的对象(数组和对象)，无论是成员变量和局部变量，类变量，它们指向的对象都存储在堆内存中  
2.栈内存属于单个线程，每个线程都会有一个栈内存，其存储变量只能在其所属线程中可见，栈内存可以理解成线程的私有内存。堆内存中的对象对所有线程可见，堆内存中的对象可以被所有线程访问  
3.异常错误: 栈内存没有可用空间存储方法调用和局部变量，JVM会抛出java.lang.StackOverFlowError。堆内存没有可用空间存储生成的对象，JVM会抛出java.lang.OutMemoryError

### 47.Java Object类 ###

1.Object类是所有类的父类，如果没有用extends明确指出继承与某个类，它的默认继承Object类  
2.Object类中三个常用的方法：toString,equals，hashCode

## 二.数据库基础知识 ##

### 1.简述或举例说明什么是数据库的事务特性(ACID)？ ###

（1）.原子性：  
一个事物内所有操作共同组成一个原子包，要么全部成功，要么全部失败，这是最基本的特性，保证了因为一些其他因素导致数据库异常，或者宕机  
（2）.一致性：  
一致性是指事物必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事物执行之前和执行之后都必须处于一致性状态  
举例：拿转账来说，假设用户A和用户B两者的钱加起来一共是5000，那么不管A和B之间如何转账，转几次帐，事物结束后两个用户的钱相加起来应该还得是5000，这就是事物的一致性  
（3）.隔离性：（不考虑事务隔离性，会发生脏读，不可重复读，虚读）  
当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启事物，不能被其他事物的操作所干扰，多个并发事物之间要相互隔离。  
即要达到这么一种效果：对于任意两个并发的事务T1和T2,在事务T1看来，T2要么在T1开始之前就已经结束，要么在T1结束之后才开始，这样每个事务都感觉不到其他事物在并发地执行  
（4）.持久性:  
持久性是指一个事物一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作

### 2.以如下两张表为基础，按照要求编写sql: ###

![在这里插入图片描述][20190527164115959.png]  
要求：查询每个部门员工总薪资是多少？  
1.``SELECT SUM(a.salary),b.department from emp a,dept b where a.`name` = b.`name` GROUP BY b.department``

2.``SELECT SUM(a.salary),b.department from emp a INNER JOIN dept b on a.`name` = b.`name` GROUP BY b.department``

### 3.oracel常用函数及示例 ###

一.单行函数：

*  字符函数：
    
     *  concat(str1,str2) 字符串拼接函数
     *  initcap(str) 将每个单词首字母大写，其他字母小写
     *  instr(x,find\_string\[,start\]\[,occurrence\]) 返回指定字符在某字符串中的位置，可以指定搜索的开始位置和返回第几次搜索出来的结果  
        `select instr('Hello World!','o',1,2) from dual;--从1位置开始搜索，返回第二次出现o的位置，结果为8`
     *  length(str) 返回表达式中的字符数
     *  lengthb(str) 返回表达式中的字节数
     *  lower(str) 将字符串转换为小写
     *  upper(str) 将字符串转为大写  
        …

二.聚焦函数

*  常用函数：
    
     *  avg(x)：返回x的平均值
     *  count(x)：返回统计的行数
     *  max(x)：返回x的最大值
     *  min(x)：返回x的最小值
     *  sum(x)：返回x的总计值

### 4.SQL语句中修改表结构的命令是\_\_\_\_\_\_。 ###

A．MODIFY TABLE  
B．MODIFY STRUCTURE  
C．ALTER TABLE  
D．ALTER STRUCTURE

### 5.ORACLE中的比较运算符 ###

在ORACLE中有以下9种比较运算符：  
（1）等于 =  
（2）不等于 <> 或者！=  
（3）大于 >  
（4）小于 <  
（5）大于或等于 >=  
（6）小于或等于 <=  
（7）ANY（使用ANY将一个值与某个列表中的任何值进行比较，此时必须在ANY之前添加一个（1）-（6）比较运算符中的一个）  
例如：SELECT customers WHERE customer\_id > ANY(1,2,3)  
（8）SOME（等同于ANY操作符，可以使用ANY代替SOME比较操作符）  
（9）ALL（使用ALL操作符将一个值与某个列表中的所有的值进行比较，此时必须在All之前添加一个（1）-（6）比较运算符中的一个）  
例如：SELECT customers WHERE customer\_id > ALL(1,2,3)

### 6.权限表的设计 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 9]

## 三.逻辑面试题 ##

1.中国女排在雅典奥运会夺冠的事实，使我们明白许多道理。例如，在失败还未成为最后的事实时。决不能轻易接受失败!在胜利尚存一丝微弱的希望时，仍要拼尽全力去争取胜利!否则，就不是真正的强者。从上述题干可以推出下面哪个选项（）

A．真正的强者决不接受失败

B．只有在失败成为不可改变的事实时，真正的强者才会去接受失败

C．失败者会轻易地接受失败

D．正如女排队员爱唱的那首歌说的，阳光总在风雨后

2.某镇有八个村，其中赵村所有的人都是在白天祭祀祖先，李庄所有的人都是在晚上才祭祀祖先。现在我们知道李明是晚上祭祀祖先的人。 由此，可以推断\_\_\_\_\_\_

A．李明一定是赵村的人  
B．李明一定不是赵村的人  
C．李明一定是李庄的人  
D．李明一定不是李庄的人

3.媒体上最近充斥着有关某名人的八卦新闻，这使该名人陷入一种尴尬的境地：如果她不出面做澄清和反驳，那些谣言就会被大众信以为真；如果她出面做澄清和反驳，反而会引起更多人的关注，使那些八卦新闻传播得更快更广。这也许就是当名人不得不付出的代价吧。如果题干中的陈述为真，则下面哪一项必定为真？

A．该名人实际上无法阻止那些八卦新闻对她个人声誉的损害。

B．一位名人的声誉不会受媒体上八卦新闻的影响。

C．在面对八卦新闻时，该名人所能采取的最好策略就是澄清真相。

D．该名人的一些朋友出面夸奖她，反而会起反效果。

4.赵、钱、孙、李、吴、郑、王七名保安每周轮流值夜班。就值班时间而言，现 已知赵比孙晚一天；李比吴晚两天；钱比王早三天；郑在钱、孙之间，并且是在星期四。 根据上述题干，下面哪一个关于值夜班的选项是真的\_\_\_\_\_\_\_\_\_\_\_。

A．吴在星期日  
B．李在星期二  
C．钱在星期二  
D．孙在星期五

5.过度工作和压力不可避免地导致失眠症。森达公司的所有管理人员都有压力。尽管医生已经提出警告，但大多数的管理人员每周工作仍然超过60小时，而其余的管理人员每周仅仅工作40小时。只有每周工作超过40小时的员工才能得到一定的奖金。  
以上的陈述最能支持下面哪项结论？（）

A.大多数得到一定奖金的森达公司管理人员患有失眠症  
B.森达公司员工的大部分奖金给了管理人员  
C.每周工作40小时的管理人员工作没有过度  
D.森达公司管理人员比任何别的员工组更易患失眠症

[20190527093446814.png]: /images/20220126/7e9b0deb77e74b61b23eb0da2c095359.png
[20190527112435730.png]: /images/20220126/f212e1ec613a45bcb30bc5f938e2cc04.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70]: /images/20220126/a0649917d6844147ac2ebe2555eb38de.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 1]: /images/20220126/63f7ea6559c64cafaaa44aa8542fe4a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 2]: /images/20220126/51a20bbf827a45b69d34524bf81843da.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 3]: /images/20220126/0724f70b5b8840e8bb8c845d1e6cf0a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 4]: /images/20220126/5f6dbed716c148cd98879cc3f2d4c7da.png
[https_blog.csdn.net_shujuelin_article_details_82423852]: https://blog.csdn.net/shujuelin/article/details/82423852
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 5]: /images/20220126/fed1d6a8b93f4250b73836d714e2a16b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 6]: /images/20220126/f85450211fec41a0aee55742fa742efa.png
[1]: /images/20220126/ca6873d8d9984320bbd3c20ec66c64f4.png
[2]: /images/20220126/bef367dc1b7e4d15bd8234572da6ac48.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 7]: /images/20220126/01decbc3f7694b36927dc41f49b56f6e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 8]: /images/20220126/622f0ba328c54fc0b5080605907e1820.png
[20190527164115959.png]: /images/20220126/5430a6b209f1451ebc9ef4cdca004235.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW40NDk3NTc1MjA_size_16_color_FFFFFF_t_70 9]: /images/20220126/7df056f8a4b84edb9e9770cb282947de.png