面试知识点整理

                                                          1.基础知识
1.类中的方法:默认访问权限:default,package,类的默认访问权限:包级别的
2.override 与overrload的区别
   1.overrload是一个类中可以有多个命名相同的方法,但这些方法的参数列表是不同的(参数个数,参数类型),
   2.override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同,达到覆盖父类的方法。
3.sleep()与wait()的区别
   1.sleep()监控状态保持,会自动恢复,不释放对象锁,sleep是thread类的方法
   2.wait是object的方法,要用notify 或notifyAll唤醒
4.arrraylist与vector的区别
   1.都实现list接口,都是有序集合 vector线程安全
5.hashmap 与hashtable的区别
   1.都实现map接口,hashmap允许null key 或 null value，hashmap非线程安全
6.abstract class和interface有什么区别?
  1.含有abstract修饰符的class即为抽象类，abstract 类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，
  abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，
  不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。
  接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，
  接口中的成员变量类型默认为public static final。
  2.抽象类跟普通类的唯一区别:不能创建实例对象,和允许abstract方法.
7.两个对象值相同(equals),可能有不同的hashcode,如果对象保存在hashset或hashmap,如果他们的equals相同,则他们的hashcode值相等.
8.java中实现多态的机制是什么？
  1.多态：:“一个接口，多种实现”，就是同一种事物表现出的多种形态。
  2.靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定.
9.String 和StringBuffer,StringBuilder的区别
    1.String是final类型的，表示内容不可以改变的字符串,String实现了equals,hashcode方法,StringBuffer表示内容可以改变的字符串,
    2.StringBuilder线程不安全,允许效率高
10.下面这条语句一共创建了多少个对象：String s="a"+"b"+"c"+"d";
   1.1个对象，jvm编译的时候对字符串常量相加进行优化相当于s="abcd";
11.简述synchronized和java.util.concurrent.locks.Lock的异同 ？
   1.主要相同点：Lock能完成synchronized所实现的所有功能
     主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。
     Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁。
12.什么是java序列化，如何实现java序列化？或者请解释Serializable接口的作用。
  1.系列化的使用场景：要将java对象存储到硬盘或者传送给网络上的其他计算机，在web开发中,如果对象被保存在了Session中,
   如果对象要经过分布式系统进行网络传输对象，这个对象必须系列化。
  2.实现serializable接口

                          1.重点知识
1.数据库(oracle,mysql)
   1.oracle
     1.常用函数:to_char(rq,'yyyy-MM-dd'),to_date();,dual(虚拟表),decode(fx,'0','收' ,'1','付') ,
     2.NVL(eExpression1, eExpression2),如果 eExpression1 的计算结果为 null 值，则 NVL( ) 返回 eExpression2。
       如果 eExpression1 的计算结果不是 null 值，则返回 eExpression1,如果都为空就返回null;
     3.rowid(行号),rownum 伪列,序列(用于分页，从1开始),loop(oracle循环)
     4.用rownum分页(select * from (selet rownum as rn，t1.* from a where ... where rn >10)
     5.但它们的存在方式是不一样的，rowid 可以说是物理存在的，表示记录在表空间中的唯一位置ID，在DB中唯一。只要记录没被搬动过，
       rowid是不变的。rowid 相对于表来说又像表中的一般列，所以以 rowid 为条件就不会有 rownum那些情况发生。
       另外还要注意：rownum不能以任何基表的名称作为前缀
     6.case when then 的用法 :
         select case when a> b then a else b end as a  , case when b> c then b else c end as b from test
A          B                                                          
      ------- ----------                                                          
2          3                                                          
3          2                                                          
4          5      
     7.oracle 存储过程(procedure)
        create or replace procedure p_aa( v_a  int, v_b  int)
     as
        v_c int;
        v_name varchar2(100);
        v_code varchar2(30);
      begin 
       v_c := v_a/v_b;
      exception
       when others then
         --dbms_output.put_line('errcode: ' || SQLCODE());
         -- dbms_output.put_line('errmessage: ' ||SQLERRM());
         v_name:='errmessage: ' ||SQLERRM();
        v_code:='errcode: ' || SQLCODE();
         insert into logFile values(bbb.nextval,v_code,v_name);
         commit;
   end;

  oracle 存储过程(procedure2)
  create or replace procedure invoke_proc_sysdate
             as
               li_date date;
             begin
              get_proc_sysdate(li_date);
               dbms_output.put_line(to_char(li_date,'yyyy-MM-dd hh24:mi:ss'));
             end;

       8.oracle 函数(function)
           create or replace function get_sysdate
      return date
      as
         li_date date;
      begin
         select sysdate into li_date from dual;
        return li_date;
      end;
         oracle(function2)
   create or replace procedure get_proc_sysdate(li_date out date)
      as
       begin
        select sysdate into li_date from dual;
      end;

      9.oracle游标(Cursor)
        游标的作用:
1.游标就是你对一个已经查询的结果做一次for循环 从第一条读到最后一条，行话叫 遍历,是对查询结果的一种标记，可以对结果进行操作或者选择性输出
2.从某一结果集中逐一地读取一条记录,游标实际上是一种能从包括多条数据记录的结果集中每次提取一条记录的机制
      create or replace procedure proc_emp_sal(aa int)
     as
           cursor cur_emp(li_value int) is select * from emp  where deptno=li_value; --声明,只能用is,
           lr_emp emp%rowtype;
           li_empno emp.empno%type;
           li_deptno emp.deptno%type;
           li_crement number(4,2);
      begin
          open cur_emp(aa); --打开
          fetch cur_emp into lr_emp; --提出数据
          while cur_emp%found
              loop
                 li_empno :=lr_emp.empno;
                li_deptno:=lr_emp.deptno;
                  if li_deptno=10 then
                      li_crement:=0.1;
                      dbms_output.put_line(li_crement);
                 elsif li_deptno=20 then
                       li_crement:=0.2;
                 elsif li_deptno=30 then
                      li_crement:=0.3;
                else
                      li_crement:=0.4;
                end if;
                update emp set sal =sal +sal*li_crement where empno=li_empno;
                fetch cur_emp into lr_emp; --提出数据,游标指针向下移动
             end loop;
           close cur_emp; --关闭
         commit;
    end;
    10.数据库分页
       1.oracle:rownum,mysql:limit,sqlserver:top(in,not in)
    11.数据库优化以及sql优化
      1.关键字段建立索引(合适建立索引)。
      2.使用存储过程(procedure),效率高
      3.备份数据库和清除垃圾数据。
      4.SQL语句的优化
         1.( WHERE子句中的连接顺序)oracle执行顺序是从右往左执行,表之间的连接必须写在其他WHERE条件之前,
    那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾.
2.SELECT子句中避免使用 *：
3.减少访问数据库的次数,可以利用缓存，从缓存里面读取
4.使用别名(as),内部函数,使用索引提高查询效率语句
6.oracle里面sql写成大写(oracle会把小写字母转换成大写再执行)
2.structs,structs2,hibernate,spring框架及原理
   1.structs原理
      1.web容器启动的时候会加载并初始化ActionServlet,容器在加载Struts应用程序时，
      会先加载web.xml中与Struts相关的一些配置参数，找到struts-config.xml文件,
      并初始化相关对象.
      2.用户向服务器提交一个请求,structs会根据url里面的action名字到配置文件(struct xml)
        中查找与名字对应的action,填充FormBean,转发请求 ,处理业务 责执行相应的业务逻辑。执行完毕后返回一个ActionForward对象，
控制器通过该ActionForward对象进行转发工作。 返回响应,再跳到相应的页面。

   2.structs2原理
        1.客户端发出请求，
2.请求经过一系列的过滤器（Filter）
3.接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action
4.FilterDispatcher把请求的处理交给ActionProxy
5.ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类
6.ActionProxy创建一个ActionInvocation的实例
7.ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。
8.一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果ActionMapper(jsp,freeMarker)

1.数据库三范式是什么?
第一范式（1NF）：字段具有原子性,不可再分。所有关系型数据库系统都满足第一范式）
数据库表中的字段都是单一属性的，不可再分。例如，姓名字段，其中的姓和名必须作为一
个整体，无法区分哪部分是姓，哪部分是名，如果要区分出姓和名，必须设计成两个独立的
字段。

  第二范式（2NF）：
第二范式（2NF）是在第一范式（1NF）的基础上建立起来的，即满足第二范式（2NF）必须先满足第一范式（1NF）。
要求数据库表中的每个实例或行必须可以被惟一地区分。通常需要为表加上一个列，以存储各个实例的惟一标识。这个惟一属性列被称为主关键字或主键。

第二范式（2NF）要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主
关键字一部分的属性，如果存在，那么这个属性和主关键字的这一部分应该分离出来形成一
个新的实体，新实体与原实体之间是一对多的关系。为实现区分通常需要为表加上一个列，
以存储各个实例的惟一标识。简而言之，第二范式就是非主属性非部分依赖于主关键字。

第三范式的要求如下：
满足第三范式（3NF）必须先满足第二范式（2NF）。简而言之，第三范式（3NF）要求一个
数据库表中不包含已在其它表中已包含的非主关键字信息。 所以第三范式具有如下特征：
1，每一列只有一个值 2，每一行都能区分。
3，每一个表都不包含其他表已经包含的非主关键字信息。
例如，帖子表中只能出现发帖人的id，而不能出现发帖人的id，还同时出现发帖人姓名，否
则，只要出现同一发帖人id的所有记录，它们中的姓名部分都必须严格保持一致，这就是数
据冗余。

2.多线程有几种实现方法?同步有几种实现方法?
多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，
而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

3、Collection框架中实现比较要实现什么接口
comparable/comparator
3、ArrayList和Vector的区别
答：
这两个类都实现了List接口（List接口继承了Collection接口），他们都是有序集合，即存储在这两个集合中的元素的位置都是有顺序的，相当于一种动态的数组，我们以后可以按位置索引号取出某个元素，，并且其中的数据是允许重复的，这是HashSet之类的集合的最大不同处，HashSet之类的集合不可以按索引号去检索其中的元素，也不允许有重复的元素（本来题目问的与hashset没有任何关系，但为了说清楚ArrayList与Vector的功能，我们使用对比方式，更有利于说明问题）。

接着才说ArrayList与Vector的区别，这主要包括两个方面：.
（1）同步性：
Vector是线程安全的，也就是说是它的方法之间是线程同步的，而ArrayList是线程序不安全的，它的方法之间是线程不同步的。如果只有一个线程会访问到集合，那最好是使用ArrayList，因为它不考虑线程安全，效率会高些；如果有多个线程会访问到集合，那最好是使用Vector，因为不需要我们自己再去考虑和编写线程安全的代码。

备注：对于Vector&ArrayList、Hashtable&HashMap，要记住线程安全的问题，记住Vector与Hashtable是旧的，是java一诞生就提供了的，它们是线程安全的，ArrayList与HashMap是java2时才提供的，它们是线程不安全的。所以，我们讲课时先讲老的。
（2）数据增长：
ArrayList与Vector都有一个初始的容量大小，当存储进它们里面的元素的个数超过了容量时，就需要增加ArrayList与Vector的存储空间，每次要增加存储空间时，不是只增加一个存储单元，而是增加多个存储单元，每次增加的存储单元的个数在内存空间利用与程序效率之间要取得一定的平衡。Vector默认增长为原来两倍，而ArrayList的增长策略在文档中没有明确规定（从源代码看到的是增长为原来的1.5倍）。ArrayList与Vector都可以设置初始的空间大小，Vector还可以设置增长的空间大小，而ArrayList没有提供设置增长空间的方法。
    总结：即Vector增长原来的一倍，ArrayList增加原来的0.5倍。
4、HashMap和Hashtable的区别
（条理上还需要整理，也是先说相同点，再说不同点）
HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，在只有一个线程访问的情况下，效率要高于Hashtable。
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。
Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

就HashMap与HashTable主要从三方面来说。
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value
5、List 和 Map 区别?
一个是存储单列数据的集合，另一个是存储键和值这样的双列数据的集合，List中存储的数据是有顺序，并且允许重复；Map中存储的数据是没有顺序的，其键是不能重复的，它的值是可以有重复的。
35、List, Set, Map是否继承自Collection接口?
   List，Set是，Map不是

109、List、Map、Set三个接口，存取元素时，各有什么特点？
这样的题属于随意发挥题：这样的题比较考水平，两个方面的水平：一是要真正明白这些内容，二是要有较强的总结和表述能力。如果你明白，但表述不清楚，在别人那里则等同于不明白。

首先，List与Set具有相似性，它们都是单列元素的集合，所以，它们有一个功共同的父接口，叫Collection。Set里面不允许有重复的元素，所谓重复，即不能有两个相等（注意，不是仅仅是相同）的对象 ，即假设Set集合中有了一个A对象，现在我要向Set集合再存入一个B对象，但B对象与A对象equals相等，则B对象存储不进去，所以，Set集合的add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true，当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。Set取元素时，没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。
List表示有先后顺序的集合， 注意，不是那种按年龄、按大小、按价格之类的排序。当我们多次调用add(Obj e)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用add(int index,Obj e)方法，就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进List中，每调用一次add方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被add多次时，即相当于集合中有多个索引指向了这个对象，如图x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(index i)来明确说明取第几个。
Map与List和Set不同，它是双列的集合，其中有put方法，定义如下：put(obj key,obj value)，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。取则可以根据key获得相应的value，即get(Object key)返回值为key 所对应的value。另外，也可以获得所有的key的结合，还可以获得所有的value的结合，还可以获得key和value组合成的Map.Entry对象的集合。

List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。


HashSet按照hashcode值的某种运算方式进行存储，而不是直接按hashCode值的大小进行存储。例如，"abc" ---> 78，"def" ---> 62，"xyz" ---> 65在hashSet中的存储顺序不是62,65,78，这些问题感谢以前一个叫崔健的学员提出，最后通过查看源代码给他解释清楚，看本次培训学员当中有多少能看懂源码。LinkedHashSet按插入的顺序存储，那被存储对象的hashcode方法还有什么作用呢？学员想想!hashset集合比较两个对象是否相等，首先看hashcode方法是否相等，然后看equals方法是否相等。new 两个Student插入到HashSet中，看HashSet的size，实现hashcode和equals方法后再看size。

同一个对象可以在Vector中加入多次。往集合里面加元素，相当于集合里用一根绳子连接到了目标对象。往HashSet中却加不了多次的。

7、说出ArrayList,Vector, LinkedList的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

LinkedList也是线程不安全的，LinkedList提供了一些方法，使得LinkedList可以被当作堆栈和队列来使用。
4、去掉一个Vector集合中重复的元素
Vector newVector = new Vector();
For (int i=0;i<vector.size();i++)
{
Object obj = vector.get(i);
if(!newVector.contains(obj);
newVector.add(obj);
}
还有一种简单的方式，HashSet set = new HashSet(vector);
9、Collection 和 Collections的区别。
　　Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

10、你所知道的集合类都有哪些？主要方法？
最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。
Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作"键"和"值"），其中每个键映射到一个值。

ArrayList/VectorList
                    Collection
HashSet/TreeSetSet

PropetiesHashTable
Map
Treemap/HashMap

我记的不是方法名，而是思想，我知道它们都有增删改查的方法，但这些方法的具体名称，我记得不是很清楚，对于set，大概的方法是add,remove, contains；对于map，大概的方法就是put,remove，contains等，因为，我只要在eclispe下按点操作符，很自然的这些方法就出来了。我记住的一些思想就是List类会有get(int index)这样的方法，因为它可以按顺序取元素，而set类中没有get(int index)这样的方法。List和set都可以迭代出所有元素，迭代时先要得到一个iterator对象，所以，set和list类都有一个iterator方法，用于返回那个iterator对象。map可以返回三个集合，一个是返回所有的key的集合，另外一个返回的是所有value的集合，再一个返回的key和value组合成的EntrySet对象的集合，map也有get方法，参数是key，返回值是key对应的value。

1、说一说Servlet的生命周期?
答:servlet有良好的生存期的定义，包括加载和实例化、初始化、处理请求以及服务结束。这个生存期由javax.servlet.Servlet接口的init,service和destroy方法表达。

Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候调用其destroy方法。
web容器加载servlet，生命周期开始。通过调用servlet的init()方法进行servlet的初始化。通过调用service()方法实现，根据请求的不同调用不同的do***()方法。结束服务，web容器调用servlet的destroy()方法。


11.说出数据连接池的工作机制是什么?
J2EE服务器启动时会建立一定数量的池连接，并一直维持不少于此数目的池连接。客户端程序需要连接时，池驱动程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空闲连接，池驱动程序就新建一定数量的连接，新建连接的数量有配置参数决定。当使用的池连接调用完成后，池驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。
实现方式，返回的Connection是原始Connection的代理，代理Connection的close方法不是真正关连接，而是把它代理的Connection对象还回到连接池中。



   3.struts1与struts2的区别
      1.struts1的前端控制器是一个Servlet，名称为ActionServlet，struts2的前端控制器是一个filter
      2.action:.struts1的action需要继承Action类，struts2的action可以不继承任何类
      3.线程安全:struts1对同一个路径的所有请求共享一个Action实例,structs2对同一路径的请求创建新的实列。
      4.在struts1中使用formbean封装请求参数，在struts2中直接使用action的属性来封装请求参数
  2.Hibernate的原理
    1.Hibernate中get和load方法的区别
       1.如果未能发现符合条件的记录，Hibernate get方法返回null，
        而load方法会抛出一个ObjectNotFoundException。
2.hibernate对于load方法认为该数据在数据库中一定存在，可以放心的使用代理来延迟加载，
如果在使用过程中发现了问题，只能抛异常；而对于get方法，hibernate一定要获取到真实的数据，
否则返回null。
1.hibernate一级缓存和二级缓存的比较
  第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存由hibernate管理的，
  一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，
  它是属于进程范围或群集范围的缓存。这一级别的缓存可以进行配置和更改，并且可以动态加载和卸载。
   3.Spring原理及理解
     1.IOC也称为DI（Depency Injection）叫依赖注入
         注入：为成员属性注入值；
         依赖：注入值的类型必须要与成员属性的类型一致;如果不一致，必须能转换为该类型
     内部最核心的就是IOC了，
      动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射
      反射其实就是在运行时动态的去创建
       静态代理：为某一种类型都要做一个代理类;
       动态代理：为任何类型都产生一个代理类;
     2.AOP称为面向切面编程
       1.就是系统中有很多各不相干的类的方法，在这些众多方法中要加入某种系统功能的代码，
       例如，加入日志，加入权限判断，加入异常处理，这种应用称为AOP。实现AOP功能采用的是代理技术，
       客户端程序不再调用目标，而调用代理类
   3.常见的设计模式
     1.mvc模式,工厂模式,模版模式,单列模式,组合模式
     总共23种，分为三大类：创建型，结构型，行为型
我只记得其中常用的6、7种，分别是：
创建型（工厂、工厂方法、抽象工厂、单例）
结构型（包装、适配器，组合，代理）
行为（观察者，模版，策略）
装饰模式: bufferReader(增强，可以一次读一行) fileReader(一次读一个)
装饰设计模式:装饰者模式动态的将责任附加到对象上，若要扩展功能，装饰者模式比继承提供了更有弹性的替代方案。装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。
2.装饰者模式在JDK中的代表
java.io包：
InputStream---抽象组件
FileInputStream, StringBufferInputStream,ByteArrayInputStream.FilterInputStream---这些类继承于 InputStream类，是可以被装饰者包起来的具体组件，其中FilterInputStream是一个抽象装饰者。
PushBackInputStream,BufferedInputStream,DataInputStream---具体的装饰者，装饰 FilterInputStream
  享元模式 flyweight() 有很多个小的对象,他们有很多属性相同,把他们变成一个对象,不同的属性把他们变成方法的参数,称之为外部状态，相同的属性称之为内部状态
  4.多线程
    1.sleep()跟wait()的区别
    2.多个线程对同一个数据进行操作(加synchronized()),要线程同步，静态方法只有跟字节码关联,类的字节码是万能的，字节码只有一份
   2.java5线程的新特性：
1.ExecutorService threadPool = Executors.newFixedThreadPool(3);
2.private static Lock lock = new ReentrantLock();
3.private static Condition subThreadCondition = lock.newCondition();
4.要同步互斥的几段代码最好是分别放在几个独立的方法中，这些方法再放在同一个类中，这样比较容易实现它们之间的同步互斥和通信
5.ExecutorService threadPool = Executors.newSingleThreadExecutor(); threadPool 线程池
6.线程池：创建一些线程，它们的集合称为线程池，当服务器接受到一个客户请求后，就从线程池中取出一个空闲的线程为之服务，
服务完后不关闭该线程，而是将该线程还回到线程池中。
   3.lock跟synchronized的区别
    1.synchronized 修饰方法时 表示同一个对象在不同的线程中 表现为同步队列,如果实例化不同的对象 那么synchronized就不会出现同步效果了
    2.同时 lock性能上高于synchronized,只是lock需要手动关闭
    3.主要相同点:Lock能完成synchronized所实现的所有功能
    主要不同点:Lock有比synchronized更精确的线程语义和更好的性能.synchronized会自动释放锁,而Lock一定要求程序员手工释放,并且必须在finally从句中释放.

    5.Tcp/ip,socket,uml,Io
      1.Tip
        1.Tcp/Ip是用于因特网(Internet)的通信协议TCP (传输控制协议) 应用程序之间通信
          UDP (用户数据包协议) 应用程序之间的简单通信
  HTTP 协议是最常用的因特网协议
  UDP:
1.将数据与源的目的封装在数据包中,不需要建立连接
2.每个数据包的大小限制在64k内
3.不需要建立连接,速度快
4.因无连接,是不可靠协议
TCP:
1.建立连接形成传输数据的通道
2.在连接中进行大数据传输
3.通过三次完成连接，是可靠协议
4.必须建立连接,效率低
  Socket:
1.Socket是为网络服务的一种机制
2.通信的两端都有Socket
3.网络通信就是Socket通信
4.数据在两个Socket间通过IO传输
Socket编程:
    建立服务端需要监听一个端口
ServerSocket ss = new ServerSocket(9999);
Socket s = ss.accept ();
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
int num = in.read(buf);
String str = new String(buf,0,num);
System.out.println(s.getInetAddress().toString()+”:”+str);
s.close();
ss.close();
  io:
    1.字节流的抽象基类：
InputStream,OutputStream 子类FileInputStream
字符流的基类：
Reader,Writer   子类FileReader
处理文本文件用字符流 FileReader, FileWriter
图片属于二进制数据用 InputStream ,OutputStream
    //编写一个程序，将d:\java目录下的所有.java文件复制到d:\jad目录下，并将原来文件的扩展名从.java改为.jad。
      public class Jad2Java {

public static void main(String[] args) throws Exception {
File srcDir = new File("java");
if(!(srcDir.exists() && srcDir.isDirectory()))
throw new Exception("目录不存在");
File[] files = srcDir.listFiles(
new FilenameFilter(){

public boolean accept(File dir, String name) {
return name.endsWith(".java");
}

}
);

System.out.println(files.length);
File destDir = new File("jad");
if(!destDir.exists()) destDir.mkdir();
for(File f :files){
FileInputStream  fis = new FileInputStream(f);
String destFileName = f.getName().replaceAll("\\.java$", ".jad");
FileOutputStream fos = new FileOutputStream(new File(destDir,destFileName));
copy(fis,fos);
fis.close();
fos.close();
}
}

private static void copy(InputStream ips,OutputStream ops) throws Exception{
int len = 0;
byte[] buf = new byte[1024];
while((len = ips.read(buf)) != -1){
ops.write(buf,0,len);
}
}
}
   5.webservice 的作用及什么情况下使用
      1.
  
   5.Uml(标准建模语言)
   标准建模语言UML。用例图,静态图(包括类图、对象图和包图),行为图,交互图(顺序图,合作图),实现图。
   UML最适于数据建模，业务建模，对象建模，组件建模。
   1.第一类是用例图，从用户角度描述系统功能，并指出各功能的操作者。
   2.第二类是静态图 (Static diagram)，包括类图、对象图和包图。
   3.第三类是行为图（Behavior diagram），描述系统的动态模型和组成对象间的交互关系
   4.第四类是交互图（Interactive diagram），描述对象间的交互关系
   5.是实现图 ( Implementation diagram )。其中构件图描述代码部件的物理结构及各部件之间的依赖关系
   总之，UML是一个通用的标准建模语言，可以对任何具有静态结构和动态行为的系统进行建模。

   6.Liunx常用命令
      1.
ls 显示文件和目录列表 　
-l 列出文件的详细信息
mkdir 创建目录 　
-p 父目录不存在情况下先生成父目录
cd 切换目录
touch 生成一个空文件
echo 生成一个带内容文件
cat、tac 显示文本文件内容
cp 复制文件或目录
rm 删除文件
-r 同时删除该目录下的所有文件
-f 强制删除文件或目录
start_x 进入图形界面
shutdown -h now 立刻关机
shutdown -r now 立刻重启
        logout 注销
vi必编辑器(列表,数组)
userdel 用户名(删除用户)
userdeel -r xiaoming(删除用户以及用户主目录)
etc:存放配置相关文件
var:存放经常变化的文件
sbin:存放有一定权限的文件
usr:文件默认安装的文件
显示当前在哪个目录下:pwd
        ls 显示当前目录
        ls -l 详细列表
cd 改变目录
ls  -a 显示隐藏文件
ls -i 显示长列表格式
ls -ai
mkdir 建立目录
rmdir 删除空目录
more 显示文件内容，带分页
less 显示文件内容带分页
grep 在文本中查询内容
| 管道命令
查看linux中所有组信息；
vi /etc/group
cat /etc /group
创建用户，并同时制定将该用户分配到哪个组
useradd -g 组名 用户名
查看linux 中所有用户信息
vi /etc/passwd
cat /etc/passwd
gzip命令
命令格式：
gzip [选项] 压缩（解压缩）的文件名
        参数：
-d 将压缩文件解压。
-l 对每个压缩文件，显示压缩文件的大小，未压缩文件的大小，压缩比，未压缩文件的名字
-v 对每一个压缩和解压的文件，显示文件名和压缩比。
-num 用指定的数字num调整压缩的速度，-1或--fast表示最快压缩方法（低压缩比），-9或--best表示
最慢压缩方法（高压缩比）。系统缺省值为6

bzip2命令
命令格式：
bzip2 [-cdz] 档名
参数：
-d ：解压缩的参数
-z ：压缩的参数
-num 用指定的数字num调整压缩的速度，-1或--fast表示最快压缩方法（低压缩比），-9或--best表示
最慢压缩方法（高压缩比）。系统缺省值为6
更改操作权限
chmod 【u 属主 g 所属组用户 o 其他用户 a 所有用户】 【+ 加权限 – 减权限 =加权限同时将原有
权限删除】 【rwx】 文件或目录名
-R 下面的子目录做相同权限操作
也可以用数字来表示权限如 chmod 777 file
   7.Android项目(多线程下载)(通过Http协议实现断点续传下载)
      10 byte 2条线程 [0,1,2,....9]
       1.实现原理：
         1.取得要下载文件的长度(HttpUrlConnection.getContentLength获取),在本地创建同样大小的文件,
         2.根据要下载文件的长度，计算出每条线程要下载数量,计算出每一条线程从文件什么位置开始下载，下载到文件的什么位置结束.
         3.使用Http的Range头字段指定每条线程从文件的什么位置开始下载，下载到什么位置为止
如：指定从文件的2M位置开始下载，下载到位置(4M-1byte)为止，代码如下：
          HttpURLConnection.setRequestProperty("Range", "bytes=2097152-4194303");
  4.保存文件，使用RandomAccessFile类指定每条线程从本地文件的什么位置开始写入数据。
    RandomAccessFile threadfile = new RandomAccessFile("QQWubiSetup.exe ","rwd");
    threadfile.seek(2097152);//从文件的什么位置开始写入数据
  8.购物车(session的处理)
     session的作用,生命周期
session的原理
session使用细节,多浏览器共享session
重启浏览,关闭cookie的话无解
禁用cookie了--->解决方案 重写URL --->response.encodeURL("day07/servlet/SessionDemo1");
response.encodeRedirectURL("day07/servlet/SessionDemo1");
javascript:void(0) //去掉超链接默认行为
//手工以cooie形式发sessionid,以解决关闭浏览器后，上次买的东西还在(cooike未禁用)
客户端防表单重复提交和服务器端session防表单重复提交(服务器有延迟)
Session将信息保存在服务器上，而Cookie保存在客户端上
Session比Cookie更安全，Session比Cookie更占资源
开发原则：Session要尽量少用--尽量少向Session中保存信息
session使用了Cookie的机制，如果Cookie被禁用，则Session也无法使用,因为客户端的session ID以cookie形式,保存在了客户端的内存当中,这个时候我们可以通过url重写,来保证session的有效性.
重写url的方法如下
resp.encodeURL(request.getRequestURL().toString());