2021年全面JAVA面试经历总结.docx

JAVA面试经验问题
0、对SSH理解： 
SSH即：Struts（表达层）+Spring（业务层）+Hibernate（持久层） 
Struts： 
Struts是一种表达层框架，重要作用是界面展示，接受祈求，分发祈求。 
在MVC框架中，Struts属于VC层次，负责界面体现，负责MVC关系分发。
（View：沿用JSP，HTTP，Form，Tag，Resourse；Controller：ActionServlet，struts-config.xml，Action） Hibernate： 

Hibernate是一种持久层框架，它只负责与关系数据库操作。 
Spring： 
Spring是一种业务层框架，是一种整合框架，可以较好地黏合表达层与持久层。 
1、 对Spring有关理解
Spring框架目是为了让模块与模块（对象与对象）之间关联不是通过代码来关联而是通过配备来关联。
Spring核心是IOC与AOP。
IOC（Inversion of Control）控制反转是关于一种对象如何获取她所依赖对象引用，这个责任反转。控制反转可以理解为生产和管理Bean容器，本来需要在调用类中New东西，当前均有IOC容器产生。
IOC三种注入方式：inject
1、 依照属性注入也就是Set办法注入
2、 依照构造办法注入
3、 依照注解注入
IOC最大好处是什么？由于把对象生成放在了XML里定义，因此当咱们需要换一种实现子类将会变成很简朴（普通这样对象都是实现于某种接口），只要修改XML就可以了，这样咱们甚至可以实现对象热插拔（有点像USB接口和SCSI硬盘了）。

DI依赖注入：Dependency injection
依赖注入是一种IOC特殊实现，依赖注入是指一种对象应用此外一种对象来提供一种特殊能力，例如：把一种数据库连接以参数形式传到一种对象构造办法里面而不是在那个对象内部自行创立一种连接。控制反转和依赖注入基本思想就是把类依赖从类内部转化到外部以减少依赖。

AOP(Aspect Oriented Programming)：针对一种切面来编程。 AOP面向切面编程 将程序中交叉业务逻辑（例如安全，日记，事务等），封装成一种切面，然后注入到目的对象（详细业务逻辑）中去。 面向切面编程通过预编译方式和运营期动态代理实现程序功能统一维护一种技术.
AOP可以理解为实现调用某个办法之前或者之后，自动执行一系列自定义语句（例如：每做一次数据库操作都要生成一句日记）。
实现AOP功能采用是代理技术，客户端程序不再调用目的，而调用代理类，代理类与目的类对外具备相似办法声明，有两种方式可以实现相似办法声明，一是实现相似接口，二是作为目的子类在， JDK 中采用 Prox类产生动态代理方式为某个接口生成实现类,如果要为某个类生成子类,则可以用CGLB。

AOP重要作用是：日记记录，性能记录，安全控制，事务解决，异常解决等等

AOP与OOP区别：
OOP（面向对象编程）针对业务解决过程实体及其属性和行为进行抽象封装，以获得更加清晰高效逻辑单元划分。
举个简朴例子，对于“雇员”这样一种业务实体进行封装，自然是OOP/OOD任务，咱们可觉得其建立一种“Employee”类，并将“雇员”有关属性和行为封装其中。而用AOP设计思想对“雇员”进行封装将无从谈起。
同样，对于“权限检查”这一动作片断进行划分，则是AOP目的领域。而通过OOD/OOP对一种动作进行封装，则有点不伦不类。
换而言之，OOD/OOP面向名词领域，AOP面向动词领域。

1.1.Spring惯用注解
1、@Controller
用于标注控制层组件（如struts中action），负责注册一种bean 到spring 上下文中，bean ID 默以为类名称开头字母小写。
 例如：
@Controller
 public class UserAction extends BaseAction{}

 • 或者
@Controller("userAction")
使用@Controller注解标记UserAction之后，就表达要把UserAction交给Spring容器管理，在Spring容器中会存在一种名字为"userAction"action，这个名字是依照UserAction类名来取。

2、@Service
@Service相应是业务层Bean，例如：
@Service("userService")
public class UserServiceImpl implements UserService { ……… }
3、@Repository
用于标注数据访问组件，即DAO组件。例如：
@Repository(value="userDao")
public class UserDaoImpl extends BaseDaoImpl<User> {……… }
4、@RequestMapping
在类前面定义，则将url和类绑定。
在办法前面定义，则将url和类办法绑定

5、@RequestParam

@Scope用于指定scope作用域（用在类上）
@Resource默认按名称装配，当找不到与名称匹配bean才会按类型装配。
@Autowired 默认按类型装配，如果咱们想使用按名称装配，可以结合@Qualifier注解一起使用。如下：
@Autowired @Qualifier("personDaoBean") 存在各种实例配合使用
@PostConstruct 初始化注解
@PreDestroy 摧毁注解 默认 单例  启动就加载

1.4、Spring事务管理机制
事务就是对一系列数据库操作（例如插入多条数据）进行统一提交或回滚操作，如果插入成功，那么一起成功，如果中间有一条浮现异常，那么回滚之前所有操作。这样可以防止浮现脏数据，防止数据库数据浮现问题。开发中为了避免这种状况普通都会进行事务管理。
spring提供了几种关于事务解决类： 
TransactionDefinition //事务属性定义 
TranscationStatus //代表了当前事务，可以提交，回滚。 
PlatformTransactionManager这个是spring提供用于管理事务基本接口，其下有一种实现抽象类AbstractPlatformTransactionManager,咱们使用事务管理类例如DataSourceTransactionManager等都是这个类子类。
普通事务定义环节如下： 
TransactionDefinition td = new TransactionDefinition();  
TransactionStatusts = transactionManager.getTransaction(td); 
try 
{ //do sth 
transactionMmit(ts);  
}catch(Exception e){
transactionManager.rollback(ts);
} 

spring提供事务管理可以分为两类：编程式和声明式。
编程式，比较灵活，但是代码量大，存在重复代码比较多；声明式比编
程式更灵活。 

编程式重要使用transactionTemplate。省略了某些提交，回滚，一系列事务对象定义，需注入事务管理对象 

声明式：使用TransactionProxyFactoryBean: 
环绕Poxy动态代理可以自动提交和回滚事务 
org.springframework.transaction.interceptor.TransactionProxyFactoryBean   
PROPAGATION_REQUIRED–支持当前事务，如果当前没有事务，就新建一种事务。这是最常用选取。  
PROPAGATION_SUPPORTS–支持当前事务，如果当前没有事务，就以非事务方式执行。

1.5、spring中核心类有那些，各有什么作用?   
BeanFactory：产生一种新实例，可以实现单例模式 
BeanWrapper：提供统一get及set办法 
ApplicationContext:提供框架实现，涉及BeanFactory所有功能。

2、Spring MVC

SpringMVC框架重要由DispatcherServlet、解决器映射、解决器(控制器)、视图解析器、视图构成。MVC作为WEB项目开发核心环节，正如三个单词分解那样，C（控制器）将V（视图、顾客客户端）与M（模块，业务）分开构成了MVC.
Spring MVC属于SpringFrameWork后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序全功能 MVC 模块。使用 Spring 可插入 MVC 架构，从而在使用Spring进行WEB开发时，可以选取使用SpringSpringMVC框架或集成其她MVC开发框架，如Struts1，Struts2等。

2.1.SpringMVC工作原理operating principle 
1.spring mvc请所有祈求都提交给DispatcherServlet,它会委托应用系统其她模块负责负责对祈求进行真正解决工作。 
2.DispatcherServlet查询一种或各种HandlerMapping,找到解决祈求Controller.  
3.DispatcherServlet请祈求提交到目的Controller  
4.Controller进行业务逻辑解决后，会返回一种ModelAndView 
5.Dispathcher查询一种或各种ViewResolver视图解析器,找到ModelAndView对象指定视图对象 
6.视图对象负责渲染返回给客户端。 

DispatcherServlet是整个Spring MVC核心。它负责接受HTTP祈求组织协调Spring MVC各个构成某些。其重要工作有如下三项：
1、截获符合特定格式URL祈求。
2、初始化DispatcherServlet上下文相应WebApplicationContext，并将其与业务层、持久化层WebApplicationContext建立关联。
3、初始化Spring MVC各个构成组件，并装配到DispatcherServlet中。

2.2、SpringMVC接口解释
1、DispatcherServlet接口：
Spring提供前端控制器，所有祈求均有通过它来统一分发。在DispatcherServlet将祈求分发给Spring Controller之前，需要借助于Spring提供HandlerMapping定位到详细Controller。
2、HandlerMapping接口：
可以完毕客户祈求到Controller映射。
3、Controller接口：
需要为并发顾客解决上述祈求，因而实现Controller接口时，必要保证线程安全并且可重用。
Controller将解决顾客祈求，这和Struts Action扮演角色是一致。一旦Controller解决完顾客祈求，则返回ModelAndView对象给DispatcherServlet前端控制器，ModelAndView中包括了模型（Model）和视图（View）。
从宏观角度考虑，DispatcherServlet是整个Web应用控制器；从微观考虑，Controller是单个Http祈求解决过程中控制器，而ModelAndView是Http祈求过程中返回模型（Model）和视图（View）。

4、ViewResolver接口：
Spring提供视图解析器（ViewResolver）在Web应用中查找View对象，从而将相应成果渲染给客户。

2、 Hibernate
Hibernate是JDBC轻量级对象封装(encapsulation)，它是一种独立对象持久persistence层框架。 hibernate要做事，就是让对象投影到关系数据库中，然后实行化。它把数据层和业务层实现解耦，这样能较好转化想要数据库，

2.1、hibernate核心接口：
session：负责被持久化对象CRUD操作
sessionFactory:负责初始化hibernate，创立session对象
configuration:负责配备并启动hibernate，创立SessionFactory
Transaction:负责事物有关操作
Query和Criteria接口：负责执行各种数据库查询

2.2、hibernate工作原理：

1.通过Configuration config = new Configuration().configure();
//读取并解析hibernate.cfg.xml配备文献

2.由hibernate.cfg.xml中<mapping resource="com/xx/User.hbm.xml"/>读取并解析映射信息
3.通过SessionFactory sf = config.buildSessionFactory();//创立SessionFactory
4.Session session = sf.openSession();//打开Sesssion
5.Transaction tx = session.beginTransaction();//创立并启动事务Transation
6.persistent operate操作数据，持久化操作
mit();//提交事务
8.关闭Session
9.关闭SesstionFactory

2.3、Hibernate好处
1、 对JDBC访问数据库代码做了封装，大大简化了数据访问层繁琐重复性代码。
2、 hibernate性能非常好，由于它是个轻量级框架。映射灵活性很出众。它支持各种关系数据库，从一对一到多对多各种复杂关系。
3、 很大限度简化DAO层编码工作

2.4、Hibernate中如何实现类之间关系?(如：一对多、多对多关系)
类与类之间关系重要体当前表与表之间关系进行操作，它们都市对对象进行操作，咱们程序中把所有表与类都映射在一起，它们通过配备文献中many-to-one、one-to-many、many-to-many。

2.5、说下Hibernate缓存机制：
Hibernate缓存涉及两大类：Hibernate一级缓存和Hibernate二级缓存
Hibernate一级缓存又称为“Session缓存”，它是内置，意思就是说，只要你使用hibernate就必要使用session缓存。由于Session对象生命周期普通相应一种数据库事务或者一种应用事务，因而它缓存是事务范畴缓存。在第一级缓存中，持久化类每个实例都具备唯一OID。
Hibernate二级缓存又称为“SessionFactory缓存”，由于SessionFactory对象生命周期和应用程序整个过程相应，因而Hibernate二级缓存是进程范畴或者集群范畴缓存，有也许浮现并发问题，因而需要采用恰当并发访问方略，该方略为被缓存数据提供了事务隔离级别。第二级缓存是可选，是一种可配备插件，在默认状况下，SessionFactory不会启用这个插件。

什么样数据适合存储到第二级缓存中？ 　　
1 很少被修改数据 　　
2 不是很重要数据，容许浮现偶尔并发数据 　　
3 不会被并发访问数据 　　
4 常量数据 　　
不适合存储到第二级缓存数据？ 　　
1经常被修改数据 　　
2 .绝对不容许浮现并发访问数据，如财务数据，绝对不容许浮现并发 　　
3 与其她应用共享数据。

2.6、如何优化Hibernate？
1.使用双向一对多关联，不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一，用多对一取代
4.配备对象缓存，不使用集合缓存

2.7.、get和load区别
1、get()办法直接返回实体类,如果查不到数据则返回null，不会报错。load()会返回一种实体代理对象（当前这个对象可以自动转化为实体对象），但当代理对象被调用时，如果没有数据不存在，就会抛出org.hibernate.ObjectNotFoundException异常
2、 load先到缓存(session缓存/二级缓存)中去查，如果没有则返回一种代理对象（不立即到DB中去找），等背面使用这个代理对象操作时候，才到DB中查询,这就是咱们常说 load在默认状况下支持延迟加载（lazy）
3、 get先到缓存(session缓存/二级缓存)中去查，如果没有就到DB中去查（即立即发出sql）。总之，如果你拟定DB中有这个对象就用load(),不拟定就用get()（这样效率高）

3、 Struts框架
3.1、struts2理解
struts一方面是MVC框架，MVC是一种设计模式。它将应用程序提成了视图、模型、控制器三某些，使代码逻辑清晰，同步提高移植性。
M与V之间--观测者模式
V与C之间--方略模式

3.2.Struts2工作原理
Struts2有两方面技术优势，
一是所有Struts2应用程序都是基于client/server HTTP互换合同，The JavaServlet API揭示了Java Servlet只是Java API一种很小子集，这样咱们可以在业务逻辑某些使用功能强大Java语言进行程序设计。
  二是提供了对MVC一种清晰实现，这一实现包括了诸多参加对因此祈求进行解决核心组件，如：拦截器、OGNL表达式语言、堆栈。

一种祈求在Struts2框架中解决大概分为如下几种环节：
1、客户端初始化一种指向Servlet容器（例如Tomcat）祈求
2、这个祈求通过一系列过滤器（Filter）（这些过滤器中有一种叫做ActionContextCleanUp可选过滤器，这个过滤器对于Struts2和其她框架集成很有协助，例如：SiteMesh Plugin） 
3、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请与否需要调用某个Action。 
       FilterDispatcher是控制器核心，就是mvc中c控制层核心。
 4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把祈求解决交给ActionProxy 
 5、ActionProxy通过ConfigurationManager询问框架配备文献，找到需要调用Action类 ,这里，咱们普通是从struts.xml配备中读取。
6、ActionProxy创立一种ActionInvocation实例。
7、ActionInvocation实例使用命名模式来调用，在调用Action过程先后，涉及到有关拦截器（Intercepter）调用。
 8、一旦Action执行完毕，ActionInvocation负责依照struts.xml中配备找到相应返回成果。返回成果普通是（但不总是，也也许是此外一种Action链）一种需要被表达JSP或者FreeMarker模版。在表达过程中可以使用Struts2 框架中继承标签。在这个过程中需要涉及到ActionMapper

3.1.3.servlet生命周期

web容器加载servlet，生命周期开始。通过调用servletinit()办法进行servlet初始化。通过调用service()办法实现，依照祈求不同调用不同do***()办法。结束服务，web容器调用servletdestroy()办法。

4、 JAVA集合
6.2、LIST集合
List集合，其重要实现类有LinkedList、ArrayList。
ArrayList 和Vector采用是数组形式来存储数据，这种方式将数据放在持续位置中，因此最大缺陷就是插入删除时非常麻烦。Vector使用了synchronized办法（线程安全），普通比ArrayList性能差。
LinkedList 采用将对象存储在独立空间中，并且在每个空间中还保存下一种链接索引，但是缺陷就是查找非常麻烦 要丛第一种索引开始。

List特点是可以以线性方式储蓄对象，并容许存储重复对象。List可以运用Collections类静态办法sort排序。sort(List list)自然排序;sort(List listm,Comparator comparator)客户化排序。

6.3、Map集合
Map集合Map用于存储键值对，不容许键重复，值可以重复。其重要实现类有HashMap、TreeMap。Map对值没有唯一性规定，对健规定唯一，如果加入已有健，原有值对象将被覆盖。

6.3.1、Hashtable与HashMap区别
1、执行效率不同;Hashtable 中办法是同步，而HashMap中办法在缺省状况下是非同步。在多线程并发环境下，可以直接使用Hashtable，但是要使用HashMap话就要自己增长同步解决了。HashMap是非线程安全，HashTable是线程安全。Hashtable 效率较低.
2、继承不同，HashMap继承AbstractMap,Hashtable继承Dictionary
public class Hashtable extends Dictionary implements Map
public class HashMap extends AbstractMap implements Map
3、HashMap去掉了Hashtablecontains办法，保存了containsValue和containsKey办法。

TreeMap：
TreeMap可以把它保存记录依照键排序，默认是按升序排序，也可以指定排序比较器。当用Iteraor遍历TreeMap时，得到记录是排过序。

遍历Map四种办法:map是接口，不能用new出对象，hashmap是继承map接口实现类，可以new出对象。
public static void main(String[] args) { 
  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);
  }
 }

6.3.2、如何保证Map中Key唯一性？

答案:重写HashCode办法和重写Equals办法。

重写Equals办法需要注意是：
一、在重写equals办法时，要注意满足离散数学上特性
1自反性：对任意引用值X，x.equals(x)返回值一定为true.
2对称性：对于任何引用值x,y,当且仅当y.equals(x)返回值为true时，x.equals(y)返回值一定为true;
3传递性：如果x.equals(y)=true，y.equals(z)=true,则x.equals(z)=true
4一致性：如果参加比较对象没任何变化，则对象比较成果也不应当有任何变化
5非空性：任何非空引用值X，x.equals(null)返回值一定为false

8.2、多线程
多线程（英语：multithreading）是异步方式，是指从软件或者硬件上实现各种线程并发执行技术。人们也许在同一时间修改同一种数据或者对象，为了数据安全需要把这个解决为同步。
Java里面实现线程，有2个办法：继承Thread类、实现Runnable接口
1、继承Thread类实现多线程
继承Thread类办法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口一种实例，它代表一种线程实例，并且，启动线程唯一办法就是通过Thread类start()实例办法。start()办法是一种native办法，它将启动一种新线程，并执行run()办法。这种方式实现多线程很简朴，通过自己类直接extend Thread，并复写run()办法，就可以启动新线程并执行自己定义run()办法。
classMyThread extends Thread{ 
Public void run(){
//这里写上线程
内容 }
Public static void main(String[] args){
//使用这个办法启动一种线程
(newMyThread()).start();
} }

8.3、实现线程同步几种办法：
1、使用synchronized同步锁.synchronized是java语言核心字，当它用来修饰一种办法或者一种代码块时候，可以保证在同一时刻最多只有一种线程执行该段代码。
1.1、同步办法 ，虽然用synchronized核心字修饰办法。由于java每个对象均有一种内置锁，当用此核心字修饰办法时，内置锁会保护整个办法。在调用该办法前，需要获得内置锁，否则就处在阻塞状态。
1.2、同步代码块 ，虽然用synchronized核心字修饰语句块。被该核心字修饰语句块会自动被加上内置锁，从而实现同步

8.6、线程与进程区别
进程（Process）是计算机中程序关于某数据集合上一次运营活动，是系统进行资源分派和调度基本单位，是操作系统构造基本。
进程特性：独立性，并发性，动态性，异步性。
进程由程序、数据和进程控制块三某些构成。
进程状态：就绪状态（Ready）：运营状态(Running)：阻塞状态(Blocked).

1、进程是一种“执行中程序”。普通在一种进程中可以包括若干个线程，它们可以运用进程所拥有资源。
2、线程执行开销小，但不利于资源管理和保护；而进程正相反
3、进程有独立地址空间，一种进程崩溃后，在保护模式下不会对其他进程产生影响，而线程只是一种进程中不同执行途径。线程有自己堆栈和局部变量，但线程之间没有单独地址空间，一种线程死掉就等于整个进程死掉，因此多进程程序要比多线程程序健壮，但在进程切换时，耗费资源较大，效率要差某些
4、线程只能归属于一种进程并且它只能访问该进程所拥有资源
**设计4个线程，其中两个线程每次对j增长1，此外两个线程对j每次减少1。写出程序。如下程序使用内部类实现线程，对j增减时候没有考虑顺序问题。
public class ThreadTest1{
  private int j;
  public static void main(String args[]){
ThreadTest1 tt=new ThreadTest1();
Inc inc=tt.new Inc();
Dec dec=tt.new Dec();
for(int i=0;i<2;i++){
Thread t=new Thread(inc);
t.start();
t=new Thread(dec);
t.start();}}
  private synchronized void inc(){
j++;
System.out.println(Thread.currentThread().getName()+"-inc:"+j);
  }
  private synchronized void dec(){
j--;
System.out.println(Thread.currentThread().getName()+"-dec:"+j);
  }
class Inc implements Runnable{
public void run(){
for(int i=0;i<100;i++){
inc();}}}
class Dec implements Runnable{
public void run(){
for(int i=0;i<100;i++){
dec();}} }
}

9、JAVA设计模式
9.1、单例模式:
单例模式可以保证系统中一种类只有一种实例并且该实例易于外界访问，从而以便对实例个数控制并节约系统资源。
保证一种类仅有一种实例，并提供一种访问它全局访问点。
单例模式，类构造函数为private，即外部程序不能通过new核心字创立对象实例。
定义一种类，它构造函数为private，它有一种staticprivate该类变量，在类初始化时实例话，通过一种publicgetInstance办法获取对它引用,继而调用其中办法。
Public Class Singleton {
Private static Singleton instance = new Singleton ();
Private Singleton （）{}
Public static Singleton getInstance(){
Return instance;
}
}

public class Singleton {
    private static Singleton uniqueInstance = null;

    private Singleton() { }

    public static Singleton getInstance() {
       if (uniqueInstance == null) {
           uniqueInstance = new Singleton();
       }
       return uniqueInstance;
    }
    // Other methods...
}
9.2、工厂模式
工厂模式是咱们最惯用实例化对象模式了，是用工厂办法代替new操作一种模式。
长处：工厂模式，提供一种“封装机制”可以减少功能调用程序和“多系列详细对象创立工作”耦合性。

简朴工厂和抽象工厂区别：
1、 工厂模式定义一种用于创立对象接口，让子类决定实例化哪一种类；抽象工厂模式为创立一组有关或互相依赖对象提供一种接口，并且无需指定她们详细类
2、 简朴工厂用来生产同一级别构造中任意产品。（对于增长新产品，无能为力）；用来生产不同产品族所有产品。（对于增长新产品，无能为力；支持增长产品族）；工厂办法 ：用来生产同一级别构造中固定产品。（支持增长任意产品）。

9.3、代理设计模式
代理设计模式指由一种代理主题来操作真实主题，真实主题执行详细业务操作，而代理主题负责其她有关业务解决。例如生活中通过代理访问网络，客户通过网络代理连接网络（详细业务），由代理服务器完毕顾客权限和访问限制等与上网有关其她操作（有关业务）。

10.5.java反射机制提供了什么功能？
a、在运营时可以判断任意一种对象所属类
B、在运营时构造任意一种类对象
C、在运营时判断任意一种类所具备成员变量和办法
D、在运营时调用任一对象办法
E、在运营时创立新类对象

10、JAVA定期任务实现原理timed task
JAVA实现定期任务三种办法：

1、 普通Thread实现
创立一种Thread，然后让它始终在While里运营，通过Sleep办法来达到定期任务效果。

2、 用Timer和TimerTask
第一种实现非常简朴，但是也缺少某些功能。用Timer和TimerTask话有如下好处：
A) 可以控制启动和和取消任务
B) 第一次执行任务时可以指定你想要Delay时间
在实现时，Timer类可以调度任务，TimerTask则是通过在RUN办法里实现详细任务。

Java所有流类位于java.io包中，都分别继承字如下四种抽象流类型。

字节流
字符流
输入流
InputStream
Reader
输出流
OutputStream
Writer

1. 继承自InputStream/OutputStream流都是用于向程序中输入/输出数据，且数据单位都是字节(byte=8bit)。
2. 继承自Reader/Writer流都是用于向程序中输入/输出数据，且数据单位都是字符(2byte=16bit)，如图，深色为节点流，浅色为解决流。

节点流：节点流从一种特定数据源读写数据。即节点流是直接操作文献，网络等流，她们直接从文献中读取或往文献中写入字节流。节点流类型常用有：
对文献操作字符流有FileReader/FileWriter，字节流有FileInputStream/FileOutputStream。

解决流：“连接”在已存在流（节点流或解决流）之上通过对数据解决为程序提供更为强大读写功能。过滤流是使用一种已经存在输入流或输出流连接创立，过滤流就是对节点流进行一系列包装。例如BufferedInputStream和BufferedOutputStream，使用已经存在节点流来构造，提供带缓冲读写，提高了读写效率。