Java面试宝典_初

hashMap的底层实现原理

答：HashMap基于hashing原理，我们通过put()和get()方法存储和获取对象。当我们将键值对传递给put（）方法时，它调用键对象的hashCode()方法来计算hashcode，让后找到bucket位置来存键值对象，通过键对象的equals()方法找打正确的键值对，然后返回值对象。HashMap使用链表来解决碰撞问题，当发生碰撞了，对象将会存储在链表的下一个节点中。HashMap在每个链表节点中存储键值对对象。

HashMap底层是哈希表数据结构

JDK1.7及之前：数组+链表
JDK1.8：数组+链表+红黑树
立即调用key ("tom ")的hashCode方法计算key的hash值，然后这个值会再次经过运算得到最终的哈希值，根据哈希值计算出在Node数组的存储下标；
1如果该下标位置没有存储值，那么key-value直接存入
2如果该下标位置有值(-个单向链表，可能有多个Node节点),调用key的equals方法和链表中每个节点的key判断
如果都返回false,那么key- value存入，如果返回了true用将要存入的value替換之前已经存入的value

sleep和wait的区别

1.sleep不会释放对象锁，wait会释放对象锁
2.sleep是Thread类的方法，wait是Object类的方法
3.sleep休眠的线程到达指定时间会唤醒，而wait等待的线程必须notify或者notifyAll唤醒

==和equals的区别
1）==为运算符，equals数据类型的比较
2）两者的范围不同，一个是堆，一个是栈

java反射

定义：java反射机制是在运行状态中，对于任意一个类，都能获取所有属性和方法；
【对于任意一个对象，都能调用它的任意方法和属性；这种动态获取信息及动态调用对象方法的功能称为java语言的反射机制；】
（动态获取类的属性、方法、构造方法；动态调用类的属性 方法构造方法；）

用途：在开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候可以利用java的反射机制通过反射来获取私有成员或方法。

反射机制相关的类

Class类 代表类的实体，在运行java应用程序中表示类和接口
Fiele类 代表类的成员变量（成员变量也称为类的属性）
Method类 代表类的方法
Constructor类 代表构造方法

创建class的三种方式

1：get.Class()方法：
任何一个类如果没有声明继承那个父类，默认继承Object类；
返回Object运行时的类，返回值是Class类，此类就是反射的源头；
public final Class<?> getClass()
2：getName()方法：
public String getName()
以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称；
3：传统方式和反射方式：
传统方式：
引入“包.类”的名称 ----- 通过new实例化 ------ 创建实例化对象
反射方式：
实例化对象 ----- getClass() ---- 得到完整的“包.类”名称

四种线程池：

1.newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序（FIFO,LIFO 优先级）执行
2.newFixedThreadPool 创建一个长线程池，可控制线程最大并发数，超出的线程会在队列中等待
3.newScheduledThreadPool 创建一个可定期或延时执行任务的定长线程池，支持定时及周期性任务执行
4.newCachedThreadPoo 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
总括 （单线程线程池、固定长线程池、可延时线程池、可缓存线程池、）

静态变量和实例变量的区别：

1.存储区域不同：静态变量存储静态存储区，普通变量存储在堆中；
2.静态变量与类相关，普通变量与实例相关；
3.内存分配方式不同
4.生命周期不同
静态变量属于类，不能实例化就已经存在，所有的实例共享同一个静态变量，可以通过类名和实例名访问。实例变量属于实例，每个实例都有自己的这个量，只能通过实例来访问。

饿汉式与懒汉式区别：

饿汉模式是线程安全的，在类创建的同时就已经创建一个静态的对象供系统使用，以后不再改变，懒汉模式如果创建实例对象时不加上synchronized则会导致对象的访问不是线程安全的
从实现方法来讲他们最大的区别就是懒汉模式是延时加载，它是在需要的时候才会建立，而饿汉模式在虚拟机启动时候就会创建。
饿汉模式无序关注多线程问题、写法简明了，能用则用。但是它是加载类时创建实例；所以如果是一个工厂模式、缓存了很多实例、那么就得考虑效率问题，因为这个类一加载则把所有实例不管用，还是不用，都会进行创建。
懒汉模式的优点是延时加载，缺点是应该用同步，其实也可以不用同步，看自己的需求，多建立一两个对象也无关紧要。

//new Date()获取当前的系统时间
y(年）；M（月）；d（天）；H（小时制）; mm（分）； ss（秒）

1.懒汉式与饿汉式
区别：饿汉式更安全；饿汉式不管用不用都会创建；
懒汉模式的优点是延时加载，缺点是应该用同步，其实也可以不用同步，看自己的需求，多建立一两个对象也无关紧要。

2.switch支持的数据类型：short byte char int String 枚举

3.方法重载的规则：

方法名称必须相同。
参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
方法的返回类型可以相同也可以不相同。
仅仅返回类型不同不足以成为方法的重载。

重写与重载的区别：重载发生在同一个类中，重写发生在子类与父类之间。

方法重写的规则

1）方法名相同
2）参数列表相同
3）访问修饰符不能严于父类
4）返回值类型一样

6.字节流？
IP地址：网络地址+主机地址
127.0.0.1 （localhost）本机地址
有效端口：0_{65535，其中0}1024系统使用或保留端口
IP地址找的是整个地址；查看本机IP地址单词：ipconfig
查看对方地址：ping +www.baidu.com(地址）
TCP：安全协议， UDP:不安全协议
字节流
所有以stream结尾的流
处理数据的单位 字节
万能的流 可以读取任何数据
字符流
所有以Reader或者Writer结尾的流都是字符流
处理数据的单位 字符
只能读取普通文本 比如 记事本

获取class对象
1 Class. forName ()
2类型. class
3对象. getClass()

冒泡排序
public static void bS(int arr[ ]){
for(int i=0; i<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+i];
arr[j+1]=temp;
}
}
}
}

6.15 运行时异常：（需要些英文）

空指针异常、 NullPointer Exception
数组下标越界异常、 Array Index Out Of Bounds Exception
类型转化异常、 Class Cast Exception
输入不匹配异常、 Input Mismatch Exception
数组格式化异常 Num ber Format Exception

检查异常：
io流异常、 IO Exception
sql异常、 SQL Exception
文件结束异常 EOF Exception
类找不到异常、 Class NotFound Exception
文件找不到异常 File NotFound Exception

sleep和wait区别

1 sleep方法当休眠时间到达转换成就绪状态 wait必须要notify或者notifyAll唤醒
2 sleep不会释放对象锁wait会释放对象锁
3 sleep是Thread，wait是0bject

单例(懒汉式）作用：节省内存

public class A{
private static A a;
private A() {} //构造方法名必须与类名一致
public static A getA() { //方法需要括号才能调用
if (a==null) { //进行判断
a=new A();
}
return a;
}

懒汉式同步
public class A{
private static A a;
private A() {} //构造方法名必须与类名一致
public Synchronize static A getA() { //方法需要括号才能调用
if (a==null) { //进行判断
a=new A();
}
return a;
}

单例（饿汉式)
public class B{
private static B s = new B();
private B(){}
public B getB(){
return s;
}
}

hashcode() int 基于对象的内存地址计算的整数值，这个整数值称之为哈希值

1 ob1. equals(obj2) true ob1. hashCode () ==ob2. hashCode ()必须相等
2 ob1. hashCode ()==ob2. hashCode() fasle
ob1. equals (obj2)必须false .
(ob1. equals(obj2) false ob1. hashCode () ==ob2. hashCode()可能相等)

什么是java反射机制？
这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

arraylist linkedlist
数组 双向链表
查询快 查询慢
增删慢 增删快

arraylist特点
数组 初始长度 10 扩容机制 1.5
数组 初始长度 16 扩容机制 2

synchronized和Lock锁两者区别:

1.首先synchronized是java内置关键字，Lock是个java接口;
2. synchronized会自动释放对象锁(a线程执行完同步代码会释放锁; b线程执行过程中发生异常会释放锁)，Lock需在finally中手动释放锁(unlock()方法释放锁)，否则容易造成线程死锁;
3.用synchronized关键字的两个线程1和线程2， 如果当前线程1获得锁，线程2线程会一直等待。而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了;
4. synchronized锁适合少量代码的同步问题，Lock锁适合大量代码的同步问题。

hashCode() int

根据对象的内存地址计算出来的整数 称为哈希值
如果2个对象内存地址相等，那么2个对象hashCode ()的值必须相等
如果2个对象内存地址不相等，那么2个对象hashCode ()的值可能相等
如果2个对象的hashCode的值不相等，那么2个对象的内存地址不一定相等

String重写了Object的hashCode
根据字符串内容计算整数值 如果2个字符串内容相等 哈希值相等
jdk1.7开始 字符串常量池从方法区移动到堆内存
只有“”的字符串，在字符串常量池中

单项链表：由一条链子将多个节点连接的数据
每个节点
数据+地址
特点：查询慢，（每次查询数据都是从头开始）
增删快（）
1）hashtable和hashmap的区别
答： 1.HashTable的方法是同步的，HashMap的方法是不同步。
2.hashtable键和值都不允许为空，hashMap键和值允许为空
3.hashtable线程安全，效率低；hashMap线程不安全，但效率高
4.hashmap和hashta继承的父类不同

2）什么是多线程
线程是程序执行流的最小单元，相对独立、可调度的执行单元，是系统独立调度和分派CPU的基本单位；
在单个程序中同时运行多个线程完成不同的工作，称为多线程；

6.18
static关键字用法
1.修饰成员变量
2.修饰成员方法
3.静态块
4.静态导包

throw和throws
1.throw抛出单个异常，throws抛出多个异常
2.throw代表一定抛出异常，throws代表当前方法可能发生异常

6.18
数据库：磁盘上的物理文件
xxx.dbf 表和表的数据
xxx.ctl 控制文件
xxx.log 日志文件 日志的作用在于记录程序的运行过程

数据库实例：一组后台进程组成（读和写）
内存结构

多线程的几种方式
1.继承Thread
2.实现Runnable
3.线程池

同步的三种方式：同步方法、同步代码块、lock锁

字符型：
char 固定长度字符串,如果数据不够，就补入空格
varchar2:可变长度 是多少，就写多少
例如：身份证是18位，所以 是char(18)

数值类型
number(5,2) 第一个参数代表最大位数，第二参数代表必须多少位小数位 例如：999.99
number(4) 最大位数 9999
number :表示任意值

6.19
java.lang.String toString()
Class c=Class.forName(“java.lang.String”);
Method toStirng=c.getMethod(“toString”);
String str=(String) c.newInstance();
toString.invoke(str);

final关键字的用法
属性 不能被赋值
方法 不能重写
类 不能被继承

守护线程：垃圾回收进程

写出验证Email的正则表达式
public static boolean checkEmail(String email) {
if(email == null || “”.equals(email)) {
return false;
}
boolean temp = email.matches("\w+([-+.]\w+)@\w+([-.]\w+)\.\w+([-.]\w+)*");
return temp;
}

两数交换，不借助第三方
i=i+j;
i=i-j;
i=i-j;

Object是所有类的父类，任何类都默认继承Object。
Object类到底实现了哪些方法？
1．clone方法 保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
2．getClass方法 final方法，获得运行时类型。
3．toString方法 该方法用得比较多，一般子类都有覆盖。
4．finalize方法 该方法用于释放资源，因为无法确定该方法什么时候被调用，很少使用。
5．equals方法 该方法是非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。
6．hashCode方法 该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。
7．wait方法 wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。

多表连接分为：内连接、外连接、自连接、交叉连接
内连接分为：等值连接、不等值连接、自连接
外连接：左连接、右连接、全连接
内连接：只有两个元素表相匹配的才能在结果集中显示
左连接：左边为驱动表，驱动表的数据全部显示，匹配表的不匹配的不会显示
右连接：右边为驱动表，驱动表的数据全部显示，匹配表的不匹配的不会显示。
外连接：连接的表中不匹配的数据全部会显示出来。
交叉连接：笛卡尔效应，显示的结果是链接表数的乘积
内连接与外连接的区别：内连接需要两张表的记录满足连接条件，两张表的记录才能合并返回结果集； 外连接以一张表为主表，返回主表的所有记录，关联表如果没有记录，返回null。

栈和堆的区别：

1. 堆空间的内存是动态分配的，一般存放对象，并且需要手动释放内存。
   2）栈空间的内存是由系统自动分配，一般存放局部变量
   3）栈空间比较小，堆空间比较大
   4）栈空间中一般存储基本数据类型，对象的地址，堆空间一般存放对象本身，block的copy等；

5的阶层用递归做
public int result(int num){
if(num==1){
return num;
return num*result(num-1);
}

多表连接：两两相连
连接条件的个数=表的个数-1；

选择排序1，正常
public static void Ss(int[] arr){
for (int i = 0; i < nums.length - 1; i++) {
int min = i;
for (int j = i + 1; j < nums.length; j++) {
if (nums[min] > arr[j]) {
min = j;
}
}
if (min != i) {
int tmp = nums[min];
arr[min] = nums[i];
arr[i] = tmp;
}
}
}
选择排序2，查找缺失数组
public class ErFenChaZhaoQueShi {
public static void main(String[] args) {
int [] nums={1,2,3,4,6,7};
int result=result(nums);
System.out.println(result);
}
public static int result(int [] nums){
----------------------开始背**********************
int min=0;
int max=nums.length-1;
while(true){
if(min==max-1){
return nums[min]+1;
}
int mid=(min+max)/2;
if(nums[mid]-nums[min]>mid-min){
max=mid;
continue;
}else if(nums[max]-nums[mid]>max-mid){
min=mid;
continue;
}else {
return -1;
}
}
}
}
分页 teacher 每页6条 第7页
select * from
select t1. * , rownum rn from
(select * from 表名 order BY 列名 desc) t1 where ROWNUM<=42) t2
Where rn>36 （当前页面-1）*每页记录数；，也就是（7-1）*6=36

6.24
//二分查找
public static int search(int[] nums, int value) {
int min = 0; //一个最小值等于0
int max = nums.length - 1;//一个最大值，nums.length-1;
int mid = (min + max) / 2;
while (nums[mid] != value) {
if (value < nums[mid]) {
max = mid - 1;
} else {
min = mid + 1;
}
if (min > max) {
return -1;
}
mid = (min + max) / 2;
}
return mid;
}
}

反射
public class Fanshe{
public static void(String[] args) throws Exception{
Student stu1=new Student();
Class stuClass=stu1.getClass();
System.out.println(stuClass.getName());

递归查询所有文件
public class GetFileList {
private static List fileList = new ArrayList<>();
//遍历查找出所有的文件装到集合中去
public static List getFileList(String dirName){
File dir = new File(dirName);
//将文件夹下所有的文件装入到数组中
File[] files = dir.listFiles();
if (files != null){
for (int i = 0; i < files.length; i++){
//判断如果是文件夹就继续递归往下查
if (files[i].isDirectory()){
getFileList(files[i].getAbsolutePath());
}else {
fileList.add(files[i]);
}
}
}
return fileList;
}

索引：索引是对数据库表中一列或多列的值进行排序的一种结构，使用索引可快速访问数据库表中的特定信息，类似书中的目录
创建索引的原则：
频繁搜索的列
经常排序、分组的列
经常连接的列
指定单独的表空间

常见的不走索引的情况:
(1)Like使用前百分号进行模糊查询不走索引
如:列like’ %xx’ 不走索引
(2)使用is null 或is not null_ 不走索引
(3)Where子句中使用函数不走索引
(4)使用O不等、not不走索引

不适合建立索引的原则：
数量小
仅包含几个不同值的列
数据表操作特别频繁、业务性能要求高
数据库的三大范式：
第一范式：确保每列的原子性，【不可分割】
第二范式：确保表中的每列，都和主键相关
第三范式：确保每列都和主键直接相关，而不是间接相关

jdbc：java数据库连接技术，能实现java程序对各种数据库的访问；
jdbc访问数据库的步骤
1）class.forName()加载驱动
2）DriverManager获取Connection连接
3）创建Statement执行SQL语句
4）返回ResultSet查询结果
5）释放资源

什么是触发器：数据库触发器是一个与表相关联的、存储的PL/SQL程序。

触发器作用？
1）安全检查
2）数据确认
3）数据备份
4）跟踪审计

oracle和Mysql的区别：
1）库函数不同
2）分页语句不同，MySQL用limit；oracle用rownum
3）Mysql主键支持自增长，oracle通过序列实现
4）oracle是用表空间来管理，MySQL不是

线程5个状态创建、就绪、运行、阻塞、死亡
1）新建状态（New）：new一个线程对象。
2）就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权
3）运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
4）阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。
5）死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

行转列
1）使用decode函数
select name,
sum(decode(course, ‘语文’, score, 0)) as 语文,
sum(decode(course, ‘数学’, score, 0)) as 数学,
sum(decode(course, ‘英语’, score, 0)) as 英语
from grade group by name;

列转行
select name, ‘语文’ as course, cn_score as score from SC_GRADE
union all
select name, ‘数学’ as course, math_score as score from SC_GRADE
union all
select name, ‘英语’ as course, en_score as score from SC_GRADE
order by name;

7.2
dao
接口 表名Dao
实现类 表名DaoImpl
service
接口表名Service
实现类表名ServiceImp1
web .
暂时没有命名规则自定义见名知意
servlet:
xxxServlet|

web项目基本结构
项目名
1.html
2.js
1.css
WEB_INF
classes class java编译以后的class文件
web.xml 配置文件
lib 需要的jar包

JDBC五个步骤
Class.forName(“oracle.jdbc.driver.OracleDriver”);
Connection conn = DriverManager.getConnection(“jdbc:oracle:thin:@127.0.0.1:1521:orcl”,“用户名”,“密码”);
String sql = “select * from teacher”;
ResultSet rs = statement.executeQuery();
while (rs.next()){
int tno = rs.getInt(“tno”);
String tname=rs.getString(“tname”);
String gender=rs.getString(“gender”);
Date birthdate=rs.getTimestamp(“birthdate”);
System.out.println(tno+">"+tname+">"+gender+"==>"+birthdate);
}
rs.close();
statement.close();
conn.close();
}
}

final, finally, finalize的区别。
final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
内部类要访问局部变量，局部变量必须定义成final类型。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用；

GET和post的区别
1）get请求不安全；post更安全
2）get只支持url编码格式，而post支持多种格式
3）get传送的参数有长度限制，而post没有长度限制
4）Get能被缓存，而post不能被缓存

常用的状态码如下:
200 :请求成功。
302 :请求重定向。
304 : 请求资源没有改变,访问本地缓存。
404 :请求资源不存在。通常是用户路径编写错误。也可能是服务器资源已删除。
500 : 服务器内部错误。通常程序抛异常。

转发与重定向的区别
1）转发是服务器行为，重定向是客户端行为；
2）转发请求，地址栏不会发生变化；重定向请求，地址栏会发生变化；
3）转发只能访问内部资源，重定向既可以访问内部资源，也能访问外部资源
4）转发性能优于重定向

会话：是客户端和服务器的一次通话；客户端第一次请求服务器，会话开始，当浏览器关闭，会话结束。在一次会话包含多次请求
为什么需要会话技术？
http协议是无状态协议，每个请求都是独立的，下一次请求无法记住上一次请求的信息。所以了为了在多次请求中共享一些信息，需要使用会话跟踪技术 cookie session(重点）

Cookie规范
●Cookie 大小上限为4KB;
●一个服务器最多在客户端浏览器上保存20个Cookie;
●一个浏览器最多保存300个Cookie;

comparable和comparator接口的用途？列出他们的区别？
Comparable是排序接口，在java.lang包下面。里面有一个compareTo(T)接口方法。当一个类需要比较的时候，需自行实现Comparable接口的CompareTo方法。当调用集合排序方法的时候，就会调用对象的compareTo()方法来实现对象的比较。
Comparator比较器接口，在java.util包下面。Comparator是一个比较器接口，一般单独定义一个比较器实现该接口中的比较方法compare();在集合sort方法中传入对应的比较器实现类。一般使用匿名内部类来实现比较器。
1.Comparator相对于Comparable来说更加的灵活，耦合度低。
2. Comparable相当于“内比较器”，而Comparator相当于“外比较器”

什么是Cookie的生命？
cookie.setMaxAge(-1)：cookie的maxAge属性的默认值就是-1，表示只在浏览器内存中存活。一旦关闭浏览器窗口，那么cookie就会消失；
cookie.setMaxAge(60*60)：表示cookie对象可存活1小时。当生命大于0时，浏览器会把Cookie保存到硬盘上，就算关闭浏览器，就算重启客户端电脑，也会存活1小时；
cookie.setMaxAge(0)：cookie生命等于0是一个特殊的值，它表示cookie被作废！也就是说，如果原来浏览器已经保存了这个Cookie，那么可以通过Cookie的setMaxAge(0)来删除这个Cookie。无论是在浏览器内存中，还是在客户端硬盘上都会删除这个Cookie。

java web 3个域对象
request HTTPServletRequest 使用范围 一次请求 不管转发多少次 都属于一次请求 所以可以在转发2个jsp之间共享request数据
一次请求一个新的request

session HttpSession 使用范围 一次会话 可以在一次会话的多次请求中共享session数据 一次会话只有一个session对象
setAttribute(String ,Object)
getAttribute(String)
removerAttribute(String)

只要浏览器不关，session的数据一直存在；只要服务器不关，ServletContext就一直存在
session的实现原理：
session是依赖Cookie实现的
session是服务器端对象，
当用户第一次使用session时（表示第一次请求服务器），服务器会创建session，并创建一个Cookie，在Cookie中保存了session的id，发送给客户端。这样客户端就有了自己session的id了。但这个Cookie只在浏览器内存中存在。
当用户第二次访问服务器时，会在请求中把保存了sessionId的Cookie发送给服务器，服务器通过sessionId查找session对象，然后给使用。也就是说，只要浏览器容器不关闭，无论访问服务器多少次，使用的都是同一个session对象。这样也就可以让多个请求共享同一个session了。

session和cookie的区别
1 session数据安全 ，cookie数据不安全
2 session数据存在服务器 cookie存在客户端浏览器
3 session可以存任意大小的数据，cookie大小有限制 ，一个cookie最大4kb

servlet生命周期

4）servlet首先实例化（构造），然后初始化执行init()方法，init()方法至始至终执行一次，servlet对象是单实例
5）根据请求的方式是get或post，在service()方法中调用doget()或dopost()方法，完成此次请求
6）当服务器停止，会调用destroy()方法，销毁实例

java web 3大域对象

request HttpServletRequest
session HttpSession
application ServletContext

jsp页面 4大域对象
pageContext PageContext 当前页面
request HttpServletRequest 一次请求
session HttpSession 一次会话
application ServletContext 整个服务器范围

变量的使用范围在声明它的一组大括号之间，并且声明变量的语句后面

用流复制文件
FileInputStream fis=new FileInputStream(”d:/1. txt") ;
FileOutputStream fos=new FileOutputStream( " d:/2. txt" ) ;
byte[] b=new byte[3];
int temp;
while((temp=fis. read(b)) !=-1){
fos. write(b, 0, temp);
}
fis. close();
fos. close() ;

标签
作用:创建文档的内联框架
属性
| src(需引入的文档路径)
| width/height ( 设定框架的宽与高)
| scrolling (是否显示滚动条，auto | yes | no)
| frameborder( 是否要边框，1显示，0不显示)
Iname(内联框架的名称)

静态包含和动态包含的区别？

include 指令是在编译级别完成的包含，即把当前jsp和被包含的jsp合并成一个jsp，然后再编译成一个servlet。（静态）
include 动态标签是运动级别完成包含，即当前jsp和被包含的jsp都会各自生成servlet，然后再执行当前jsp的servlet时调用另一个jsp的servlet。（动态）

*jsp九大内置对象(前6个常用，后面三个不常用）
*
1.out: 等同于response.getWriter()，用来向客户端发送文本数据
2.request： 即HttpServletRequest类的对象
3.session: 即HttpSession类的对象，不是每个JSP页面中都可以使用，如果在某个JSP页面中设置<%@page session=”false”%>，说明这个页面不能使用session。
4.response: 即HttpServletResponse类的对象
5.application: 即ServletContext类的对象
6.pageContext: 页面上下文对象，代表paget域

7.config: 对应Servlet中的ServletConfig
8.page: 当前JSP页面的“this”，即当前对象
9.exception: 只有在错误页面中可以使用这个对象

什么是MVC设计模式

m model 模型 service和dao
v view 视图 jsp
c controller 控制器 servlet
当用户发送请求，由控制器接收请求，并且将请求传递给模型，模型处理完请求返回处理结果，控制器接收到模型的处理结果，选择视图展示；

servlet如何解决乱码 请求 响应
请求中文乱码的处理：
–post
　　request.setCharacterEncoding(“UTF-8”);
–get
　　String name=new String(“中国”.getBytes（“iso-8859-1”）,“UTF-8”)
响应中文乱码的处理:
–①字节流:
　　 设置浏览器默认打开的编码:
　　　　resposne.setHeader(“Content-Type”,”text/html;charset=UTF-8”);
　　设置中文字节取出的时候编码.
　　　　 “中文”.getBytes(“UTF-8”);
–② 字符流:
　　 设置浏览器打开的时候的编码
　　　　resposne.setHeader(“Content-Type”,”text/html;charset=UTF-8”);
　　设置response的缓冲区的编码
　　　　response.setCharacterEncoding(“UTF-8”);

邮箱正则：/^\w+@\w+(\ .\w+) {1,2}$/

如果想把浏览器直接打开图片，改成让浏览器下载图片服务器怎么做
response. setHeader (”Content- Type” , applicaton. getMimeType(" a. jpg"));
rsponse. setHeader (”Content -Disposition" , ’ 'at tachment;filename=b. jpg" ) ;

7.21事务
什么事务：一组sql语句，事务可以确保sql语句要么全部成功，要不全部失败

1）事务的四大特性（ACID）
事务的四大特性是：
原子性（Atomicity）： 事务中所有操作是不可再分割的原子单位。事务中所有操作要么全部执行成功，要么全部执行失败。
一致性（Consistency）：事务执行后，数据库状态与其它业务规则保持一致。如转账业务，无论事务执行成功与否，参与转账的两个账号余额之和应该是不变的。
隔离性（Isolation）： 隔离性是指在并发操作中，不同事务之间应该隔离开来，使每个并发中的事务不会相互干扰。
持久性（Durability）： 一旦事务提交成功，事务中所有的数据操作都必须被持久化到数据库中，即使提交事务后，数据库马上崩溃，在数据库重启时，也必须能保证通过某种机制恢复数据

事务的并发读问题(三个）
脏读：一个事务读取到另外一个事务的未提交数据，也就是读到了脏读数据；（读未提交）

不可重复读：由于在一个事务的运行过程中，另外一个事务更新了记录，所以第一个事务对同一记录的两次查询结果不一致，产生了不可重复读；

幻读：由于在一个事务的运行过程中，另外一个事务插入了新的记录，所有第一个事务对表的查询结果不一致；（读已提交）

事务四大隔离级别（重要）
串行化
1、不会出现任何问题，因为它是对同一数据的访问是串行的，非并发访问的
性能最差；

2、可重复读（MySQL）
解决脏读和不可重复读，不能解决幻读问题；
性能比串行化好

3、读已提交数据（Oracle）
只能解决脏读，不能解决重复读，幻读；
性能比可重复读好

4、读未提交数据
不能解决任何问题
性能最好

JDBC连接数据库的顺序是
1)导入驱动包2)加载驱动3)建立与数据库的连接
4)发送并处理SQL语句5)关闭连接

jdbc如何控制事务(第一个模板）
Connection conn = DriverManager.getConnection(“连接URL”, “用户名”, “密码”);
conn.setAutoCommit(false);
try{
conn.setAutoCommit(false);
stmt = conn.createStatement();
stmt.executeUpdate(“sql语句”);
conn.commit();
}catch(Exception e)
{
e.printStackTrace();
conn.rollback();
}
　　
-----------------------（3）关闭连接，如下：（不重要）
finally{
if(stmt != null)
stmt.close();
if(conn != null)
conn.close();
}

jdbc如何控制事务(第二个模板）
Connection conn=DriverManager.getConnection(“连接URL”, “用户名”, “密码”);
try{
conn.setAutoCommit(false);//手动开启一个事务
sql-1
sql-2
conn.commit();
}catch(Exception ex){
conn.rollback();
}

arrayList扩容机制：初始长度10，每次1.5倍

String的常用方法
charAt(0)
contain()
subString(开始下标，结束下标)

maven的作用：依赖管理，一键构建（编译、测试、运行、打包、安装、部署）

运行后面的生命周期命令，一定要从前面的生命周期运行到指定生命周期。
分页流程：当前页面、总记录数、每页记录数、总页数、分页数据

hibername和mybatis
hibername数据库无关性好 切换了数据库 只需要更换方言
mybatis切换了数据库，需要准备多套sql语句

get和load的区别

1.get是立即加载，load是延时加载。
2.get会先查一级缓存，再查二级缓存，然后查数据库，load会先查一级缓存，若没找到，就创建代理对象，等需要的时候去查二级缓存和数据库（load延时加载特性）。
3.get如果没有找到会返回null，load如果没有找到会抛出异常。

文件上传
jsp
form enctype=“multipart/form-data”
method=“post”
input type=“file”

hibernate的三种状态
1）瞬时状态
2）游离状态
3）持久状态
对象刚刚new出来属于瞬时状态，当调用session的save()时，将对象存入数据库，这个时候对象由瞬时状态换成持久状态。
当调用session的dose（）方法时，对象最终转换成游离状态

悲观锁
当一个事务获取数据时，总是悲观的认为其他事务会操作同一条记录，所以这个事务会对记录锁定，只有当这个事务提交时，其他事务才允许对记录进行操作
乐观锁
在表中增加version列，在类中增加version属性，在映射文件通过version标签将version列和version属性对应,当查询数据时，将数据版本号version一起查询，当事务提交时，将自己的version和数据库中的version做匹配，匹配成功，将事务提交,数据库的version自动加1，匹配失败，抛出异常

hibernate 缓存机制
*一级缓存sglsession级别缓存
同一个sqlsession下，2次执行相同的sql语句，第二次不再查询数据库
直接从一级缓存拿数据
二级缓存mapper级别的缓存
同一个mapper下的多个sqlsession共享一个二级缓存
查询顺序：先查二级缓存，再查一级缓存，再查数据库。
5.11.mybatis与hibernate不同
（1.hibernate精通门槛高，mybatis简单易学；
　2.hibernate数据库无关性好，如果换了数据库，只需要切换方言；mybatis 数据库无关性差，如果换了）
Mybatis和hibernate不同，它不完全是一个ORM框架，因为1 MyBatis需要程序员自己编写Sql语句。mybatis可以通过XML或注解方式灵活配置要运行的sql语句，并将java对象和sql语句映射生成最终执行的sql，最后将sql执行的结果再映射生成java对象。

Mybatis学习门槛低，简单易学，程序员直接编写原生态sql，可严格控制sql执行性能，灵活度高，非常适合对关系数据模型要求不高的软件开发，例如互联网软件、企业运营类软件等，因为这类软件需求变化频繁，一但需求变化要求成果输出迅速。但是灵活的前提是2 mybatis无法做到数据库无关性，如果需要实现支持多种数据库的软件则需要自定义多套sql映射文件，工作量大。

Hibernate对象/关系映射能力强，数据库无关性好，对于关系模型要求高的软件（例如需求固定的定制化软件）如果用hibernate开发可以节省很多代码，提高效率。但是Hibernate的学习门槛高，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡，以及怎样用好Hibernate需要具有很强的经验和能力才行。
总之，按照用户的需求在有限的资源环境下只要能做出维护性、扩展性良好的软件架构都是好架构，所以框架只有适合才是最好。

${}和#{}的区别？
#{}表示一个占位符号，(相当于？占位符 如果接受简单数据类型，里面变量名可以自定义)通过#{}可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换。#{}可以有效防止sql注入。 #{}可以接收简单类型值或pojo属性值。 如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。
$表示拼接sql串，（相当于使用+号连接，如果接受简单数据类型里面变量名必须是value）通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换， $可以接收简单类型值或pojo属性值，如果parameterType传输单个简单类型值，${}括号中只能是value。

什么是存储过程？用什么来调用？
存储过程是一个预编译的SQL语句，优点是允许模块化的设计，就是说只需创建一次，以后在该程序中就可以调用多次。如果某次操作需要执行多次SQL，使用存储过程比单纯SQL语句执行要快。
调用：
1）可以用一个命令对象来调用存储过程。
2）可以供外部程序调用，比如：java程序。

1 导包 ssm所有jar包
2 准备mybatis.xml 加入PageHelper分页插件
3 准备jdbc.properties
4 准备applicationContext.xml
1 加载jdbc.properties
2 创建数据库连接池
3 通过连接池和mybatis.xml文件创建SqlSessionFatoryBean
4 通过MapperScannerConfigurer的basePackage属性批量扫描指定包下的Mapper.java和Mapper.xml文件，为每一个扫描到的java接口动态生成实现类对象，存入spring容器

---------------------mybatis整合结束----------------
5 组件扫描 扫描所有@Service注解修饰的类
<context:component-scan base-package=“com.sc.ssm.service”></context:component-scan>
6 配置aop事务
1 准备目标类 略 第五步已经完成
2 准备事务切面



3 配置事务属性和切入点表达式，将满足切入点的目标方法进行事务增强
--------------------spring整合结束------------------
7 加入springmvc.xml配置文件
1 组件扫描
<context:component-scan base-package=“com.sc.ssm.controller”></context:component-scan>
2 注解驱动
mvc:annotation-driven</mvc:annotation-driven>
3 配置视图解析器


------------------springmvc整合结束-----------------
8 web.xml
1 spring监听器

org.springframework.web.context.ContextLoaderListener

contextConfigLocation classpath:applicationContext.xml

2 springmvc前端控制器
org.springframework.web.servlet.DispatcherServlet

3 字符编码过滤器
org.springframework.web.filter.CharacterEncodingFilter

4 log4j

<context-param>
    <param-name>log4jConfigLocation</param-name>
    <param-value>classpath:log4j.properties</param-value>
</context-param>
<!--配置日志刷新时间间隔 60S-->
<context-param>
    <param-name>log4jRefreshInterval</param-name>
    <param-value>60000</param-value>
</context-param>