J2SE基础常见面试题目

</pre>本系列文章收录了一些网友及自己在面试过程中遇到的常见J2SE问题，希望能对参加面试的朋友有所帮助，如果大家有好的题目也可以向我提出，本文将不断地维护更新，感谢。    <span style="font-size:14px;"><strong>1.九种基本数据类型的大小，以及他们的封装类。</strong></span></p><p><span style="font-size:14px;"></span></p><p><span style="font-size:14px;">                                             大小                        最小值                       最大值              包装器类型boolean                               -                               -                                 -                          Booleanchar                                   16-bit                       Unicode 0         Unicode 2^16-1       Characterbyte                                    8-bit                        -128                          +127                     Byteshort                                  16-bit                      -2^15                         +2^15+1              Shortint                                       32-bit                     -2^31                         +2^15+1               Integerlong                                   64-bit                      -2^63                        +2^63+1               Longfloat                                   32-bit                      IEEE754                  IEEE754                Floatdouble                              64-bit                      IEEE754                  IEEE754                Double</span></p><p><span style="font-size:14px;">有人说void不算一种基本的数据类型，但是无所谓，我们知道怎么用，能写出鲁棒的代码就行了。</span></p><p style="margin-top: 0px; margin-bottom: 2px; padding-top: 0px; padding-bottom: 0px;"><span style="font-size:14px;">在 Java 中基本类型只有八种，详见 Java Language Specification 的 4.2 节：<a target=_blank target="_blank" href="http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2" style="background-image: initial; background-attachment: initial; background-size: initial; background-origin: initial; background-clip: initial; background-position: initial; background-repeat: initial;">http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2</a>另外，在 Java Language Specificaion 的第 14.8 节也提及 void 并不是一种类型：<a target=_blank target="_blank" href="http://java.sun.com/docs/books/jls/third_edition/html/statements.html#5989" style="background-image: initial; background-attachment: initial; background-size: initial; background-origin: initial; background-clip: initial; background-position: initial; background-repeat: initial;">http://java.sun.com/docs/books/jls/third_edition/html/statements.html#5989</a>）</span></p><p style="margin-top: 0px; margin-bottom: 2px; padding-top: 0px; padding-bottom: 0px; line-height: 25.2000007629395px; color: rgb(51, 51, 51); font-family: arial, STHeiti, 'Microsoft YaHei', 宋体; font-size: 14px;"></p><p style="margin-top: 0px; margin-bottom: 2px; padding-top: 0px; padding-bottom: 0px; line-height: 25.2000007629395px; color: rgb(51, 51, 51); font-family: arial, STHeiti, 'Microsoft YaHei', 宋体; text-indent: 21pt; text-align: justify;"><span style="font-size:14px;"><strong>2. Switch能否用string做参数？</strong></span></p><p style="margin-top: 0px; margin-bottom: 2px; padding-top: 0px; padding-bottom: 0px;"><span style="font-size:14px;">Java1.7以前不能。所以以前我们一般用枚举类。举个例子：</span></p><p style="margin-top:0px; margin-bottom:2px; padding-top:0px; padding-bottom:0px; line-height:25.2000007629395px; color:rgb(51,51,51); font-family:arial,STHeiti,'Microsoft YaHei',宋体; font-size:14px; text-indent:21pt; text-align:justify"></p><pre name="code" class="java">/*
     * 定义数据字典枚举类 
     * */  
    public enum DataDictEnum {  
        A,B,C,D;  
    }  
      
    /* 
     * 使用Switch 进行判断，参数为枚举类型 
    * 根据枚举中的A,B,C,D 进行实例化不同的工厂对象 
     * */  
      
        public IDataDict CreateFactory(DataDictEnum type){  
                IDataDict dictFactory=null;  
                  
                switch (type){  
                //实例化分销商工厂类  
                case A:  
                    dictFactory= ClientLevelFactory.getInstance();  
                    break;  
                Case B:  
                    dictFactory= RegionLevelFactory.getInstance();  
                    break;  
                      
                }  
                return dictFactory;  
            }
    //调用  
    //创建枚举类型中“A”  
    DataDictEnum type =DataDictEnum.A;  
    //实例化分销商，调用Switch判断方法  
    DataDictManager clm =DataDicContext.getInstance().CreateFactory(type).CreateType();

JAVA1.7以后是可以的，但其实并不是真的允许使用字符串，而是在编译器层面对其进行处理，对代码进行反编译后，我们就会发现，其实它是通过equals和hashCode()方法来实现的。详情请见：
http://www.deepinmind.com/java/2014/05/08/how-string-in-switch-works-in-java-7.html

3. equals与==的区别。

       

         equals是比较值，只要值相等就返回1，而==是比较地址，地址相同才返回1。

4. Object有哪些公用方法？

Object是所有类的父类，它有很多类对象会用到的方法，例如比较常用的toString 、equals，当你新建xx类时，你可以重写Object已经定义的方法，也可以直接调用Object中的方法，如果你写一个封装的方法，不确定传进来的是什么类型的值，就可以使用Object作为一个笼统类

（1）protected Object clone()
       创建并返回此对象的一个副本。
       （2）boolean equals(Object obj)
       指示某个其他对象是否与此对象“相等”。
       （3）protected void finalize()
       当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
       （4）Class<? extends Object> getClass()
       返回一个对象的运行时类。
       （5）int hashCode()
       返回该对象的哈希码值。
       （6）void notify()
       唤醒在此对象监视器上等待的单个线程。
       （7）void notifyAll()
       唤醒在此对象监视器上等待的所有线程。
      （8）String toString()
       返回该对象的字符串表示。
       （9）void wait()
       导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。
      （10） void wait(long timeout)
       导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。
      （11）void wait(long timeout, int nanos)
      导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。

5. Java的四种引用，强弱软虚，用到的场景。

    （1）强引用

　　本章前文介绍的引用实际上都是强引用，这是使用最普遍的引用。如果一个对象具有强引用，那就 类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空 间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。

　　（2）软引用(SoftReference)

　　如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。

　　软引用可以和一个引用队列(ReferenceQueue)联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

　　（3）弱引用(WeakReference)

　　如果一个对象只具有弱引用，那就类似于可有可物的生活用品。 弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。

　　弱引用可以和一个引用队列(ReferenceQueue)联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

　　（4）虚引用(PhantomReference)

　　"虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。

　　虚 引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列(ReferenceQueue)联合使用。当垃 圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是 否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动

6. Hashcode的作用。

hashcode（）方法返回该对象的哈希码值。

7. ArrayList、LinkedList、Vector的区别。

        ArrayList 是一个可改变大小的数组.当更多的元素加入到ArrayList中时,其大小将会动态地增长.内部的元素可以直接通过get与set方法进行访问,因为ArrayList本质上就是一个数组.
        LinkedList 是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.

        Vector 多数方法都被synchronized修饰的List实现，线程安全；一般在遗留代码中被使用，现在不推荐。

8. String、StringBuffer与StringBuilder的区别。

　           String：字符串常量，如果要操作少量的数据用 String

　　　　StringBuffer：字符串变量，线程非安全的，单线程操作字符串缓冲区下操作大量数据 StringBuilder

　　　　StringBuilder：字符串变量，线程安全的，多线程操作字符串缓冲区下操作大量数据 StringBuffer

（http://www.cnblogs.com/A_ming/archive/2010/04/13/1711395.html）

9. Map、Set、List、Queue、Stack的特点与用法。

Map接口：Map没有继承Collection接口。也就是说Map和Collection是2种不同的集合。Collection可以看作是（value）的集合，而Map可以看作是（key，value）的集合。

Set接口：Set接口是继承自Collection的，它不能包含有重复元素。Set中最多有一个null元素。

List接口：List继承自Collection接口。List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。

    跟Set集合不同的是，List允许有重复元素。对于满足e1.equals(e2)条件的e1与e2对象元素，可以同时存在于List集合中。当然，也有List的实现类不允许重复元素的存在。

    除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素， 还能向前或向后遍历。

    实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

Queue接口:Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接 口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。BlockingQueue 继承了Queue接口。

 

队列是一种数据结构．它有两个基本操作：在队列尾部加人一个元素，和从队列头部移除一个元素就是说，队列以一种先进先出的方式管理数据，如果你试图向一个 已经满了的阻塞队列中添加一个元素或者是从一个空的阻塞队列中移除一个元索，将导致线程阻塞．在多线程进行合作时，阻塞队列是很有用的工具。工作者线程可 以定期地把中间结果存到阻塞队列中而其他工作者线线程把中间结果取出并在将来修改它们。队列会自动平衡负载。如果第一个线程集运行得比第二个慢，则第二个 线程集在等待结果时就会阻塞。如果第一个线程集运行得快，那么它将等待第二个线程集赶上来。

10. HashMap和HashTable的区别。

11. HashMap和ConcurrentHashMap的区别，HashMap的底层源码。

12. TreeMap、HashMap、LindedHashMap的区别。

13. Collection包结构，与Collections的区别。

14. try catch finally，try里有return，finally还执行么？

执行。先把return存一下（放到篮子里），捕获异常后再return。

15. Excption与Error包结构。OOM你遇到过哪些情况，SOF你遇到过哪些情况。

      Exception是所有异常的父类。任何异常都扩展于Exception类，Exception就相当于一个错误类型。

      Exception是程序本身可以处理的异常，这种异常分两大类运行时异常和非运行时异常。程序中应当尽可能去处理这些异常。

      Error是程序无法处理的错误，比如OutOfMemoryError、ThreadDeath等，Java虚拟机抛出一个Error对象，应用程序不捕获或抛 出Errors对象，你可能永远不会遇到需要实例化Error的应用，这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

      OOM:内存溢出，即Out Of Memory。出现情况：创建或解析Bitmap，分配特大的数组等

16. Java面向对象的三个特征与含义。

Java面向对象设计主要有三大特征：封装性、继承性和多态性

封装性

1.1 概念：它是将类的一些敏感信息隐藏在类的类部，不让外界直接访问到，但是可以通过getter/setter方法间接访问。

1.2 目的：我们可以并且有可能在方法中，添加自己的限制，保证数据的有效性；从某种程度上说，封装也提高了代码的健壮性、安全性。

1.3 实现步骤：所有的成员变量全部私有化，格式 ：private 数据类型 变量名 ，提供访问成员变量的getter/setter方法。

继承性

2.1 概念：子类通过一种方式来接受父类所有的公有的，受保护的成员变量和成员方法。

2.2 目的：增强了代码的复用性，提高了代码的质量。

2.3 实现步骤：使用extends关键词，标识子类继承父类 ，格式：public class 子类名 extends 父类名

2.4 注意事项: ⑴子类可以在继承父类方法的基础上，重写父类的方法，在具体执行是执行子类的方法；

⑵子类可以定义自己的属性，方法，这是代码扩展性的一种体现；

⑶Java中所有的类，如果没有显示的定义继承自谁，默认都是从Object继承而来的；

⑷(特别注意)Java中，每个类都只能继承一个类————Java的单继承机制。

多态性

3.1 概念：程序在运行的过程中，同一种类型在不同的条件下表现不同的结果，这种不定状态的表现形式，可以称为多态。

3.2 分类：ⅰ.设计时多态：方法重载实现的多态

⑴方法重载—————定义的所有方法都是声明在【同一个类】中的；

⑵方法重载的实现————相同的方法名称(不同的参数){}，例如：public void person(){ . . . }

和public void person(String name){ ........}

ⅱ .运行时多态：方法【重写】实现的多态

⑴方法重写/覆盖————定义的方法肯定是在子类中覆盖父类的方法，方法出现在两个类中。

⑵方法重写的实现————子类继承父类，然后在子类中重新定衣服类方法的实现。

例如：父类 public class Pet{}

子类 public class Cat{} 子类继承父类 Cat extends Pet

Pet cat = new Cat(); 父类的引用指向子类的对象，表示运行时多态。

17. Override和Overload的含义与区别。

Override：重写

Overload：重载

18. Interface与abstract类的区别。

含有abstract修饰符的class即为抽象类，abstract 类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。
接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。
下面比较一下两者的语法区别：
     （1）抽象类可以有构造方法，接口中不能有构造方法。

(2)抽象类中可以有普通成员变量，接口中没有普通成员变量

(3)抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
       (4)抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
      (5)抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
       (6) 一个类可以实现多个接口，但只能继承一个抽象类。
       下面接着再说说两者在应用上的区别：
接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码

19. Static class 与non static class的区别。

（1）首先是类中的数据，static的
class A {
       static int a;
             }
class B {
        int b;
             }
无论新建几个A对象，这几个对象公用一个int a，一个对象的a改变，另一个也会改变。
而B对象，不同对象之间的int b独立存在，互不影响，可以有多个值。

（2）类中的方法
静态的方法，不需要建立对象就可以访问
如Math.abs()这个方法，我们没有建立Math的对象，就可以通过类名直接使用abs这个方法。
而非静态的方法，必须先建立对象，然后通过对象名，调用这个方法。
如JButton jb = new JButton();
    jb.addActionListener(l);

ps:在静态方法的定义中，不能直接引用本类的其他非静态方法。例如。我们不能在main中直接引用，本类的其他方法。所以我们经常可以看见，在main方法中，先建立本类的一个对象，然后才通过对象调用本类的其他方法。

（3）在初始化过程中，静态的总是先初始化。

20. java多态的实现原理。

java中实现多态的机制是依靠父类或接口的引用指向子类。从而实现了一个对象多种形态的特性。其中父类的引用是在程序运行时动态的指向具体的实例，调用该引用的方法时，不是根据引用变量的类型中定义的方法来运行，而是根据具体的实例的方法。

父类之类之间的多态方式 ： 方法的重写，覆盖父类的方法，是动态绑定的，在运行时确定调用的是哪个方法 。
类内的多态方式：方法的重载 。

21. 实现多线程的两种方法：Thread与Runable。

一是写一个类继承自Thread类,然后重写里面的run方法,用start方法启动线程
  二是写一个类实现Runnable接口,实现里面的run方法,用new Thread(Runnable target).start()方法来启动

22. 线程同步的方法：sychronized、lock、reentrantLock等。

sychronized：当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

lock：

ReentrantLock ：ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，但是添加了类似锁投票、定时锁等候和可中断锁等候的一些特性。此外，它还提供了在激烈争用情况下更佳的性能。（换句话说，当许多线程都想访问共享资源时，JVM 可以花更少的时候来调度线程，把更多时间用在执行线程上。）

23. 锁的等级：方法锁、对象锁、类锁。

24. 写出生产者消费者模式。

     （1）你把信写好——相当于生产者制造数据

    （2）你把信放入邮筒——相当于生产者把数据放入缓冲区

    （3）邮递员把信从邮筒取出——相当于消费者把数据取出缓冲区

    （4）邮递员把信拿去邮局做相应的处理——相当于消费者处理数据

25. ThreadLocal的设计理念与作用。

26. ThreadPool用法与优势。

27. Concurrent包里的其他东西：ArrayBlockingQueue、CountDownLatch等等。

28. wait()和sleep()的区别。

      对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。

      sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。

在调用sleep()方法的过程中，线程不会释放对象锁。

      而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。

29. foreach与正常for循环效率对比。

foreach语句是java5的新特征之一，在遍历数组、集合方面，foreach为开发人员提供了极大的方便。 
foreach语句是for语句的特殊简化版本，但是foreach语句并不能完全取代for语句，然而，任何的foreach语句都可以改写为for语句版本。 
foreach并不是一个关键字，习惯上将这种特殊的for语句格式称之为“foreach”语句。从英文字面意思理解foreach也就是“for 每一个”的意思。实际上也就是这个意思。 
foreach的语句格式： 
for(元素类型t 元素变量x : 遍历对象obj){ 
     引用了x的java语句; 
} 

30. Java IO与NIO。

IO             NIO
面向流            面向缓冲
阻塞IO             非阻塞IO
无                      选择器

31. 反射的作用与原理。（平常编程的时候用得比较少，写框架的时候经常要用到）

Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
简单的来说，反射机制其实就是指程序在运行的时候能够获取自身的信息。如果知道一个类的名称/或者它的一个实例对象， 就能把这个类的所有方法和变量的信息(方法名，变量名，方法，修饰符，类型，方法参数等等所有信息)找出来。如果明确知道这个类里的某个方法名+参数个数 类型，还能通过传递参数来运行那个类里的那个方法，这就是反射。

      尽管Java不是一种动态语言，但它却有一个非常突出的动态机制：Reflection。它使我们可以于运行时加载、探知、使用编译期间完全未知的 classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、 或对其fields设值、或唤起其methods。既一种“看透class”的能力。

32. 泛型常用特点，List<String>能否转为List<Object>。

可以。但是因为这里利用类都继承自Object，所以使用是每次调用里面的函数都要通过强制转换还原回原来的类，这样既不安全，运行速度也慢

33. 解析XML的几种方式的原理与特点：DOM、SAX、PULL。

       (1)DOM解析

　  DOM的全称是Document Object Model，也即文档对象模型。在应用程序中，基于DOM的XML分析器将一个XML文档转换成一个对象模型的集合（通常称DOM树），应用程序正是通过对这个对象模型的操作，来实现对XML文档数据的操作。通过DOM接口，应用程序可以在任何时候访问XML文档中的任何一部分数据，因此，这种利用DOM接口的机制也被称作随机访问机制。
DOM是html和xml的应用程序接口(API)，以层次结构（类似于树型）来组织节点和信息片段，映射XML文档的结构，允许获取
和操作文档的任意部分，是W3C的官方标准
【优点】
①允许应用程序对数据和结构做出更改。
②访问是双向的，可以在任何时候在树中上下导航，获取和操作任意部分的数据。
【缺点】
①通常需要加载整个XML文档来构造层次结构，消耗资源大。
【解析详解】
①构建Document对象：
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = bdf.newDocumentBuilder();
InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(xml文件);
Document doc = bd.parse(is);
②遍历DOM对象
Document： XML文档对象，由解析器获取
NodeList： 节点数组
Node： 节点(包括element、#text)
Element： 元素，可用于获取属性参数

【XmlPull】：XmlPull和Sax类似，是基于流（stream）操作文件，然后根据节点事件回调开发者编写的处理程序。因为是基于流的处理，因此Xmlpull和Sax都比较节约内存资源，不会象Dom那样要把所有节点以对橡树的形式展现在内存中。

但Xmlpull比Sax更简明，而且不需要扫描完整个流。现在XmlPull是一开源项目，并成为了Google android类库的一部分，想了解更多请查看http://www.xmlpull.org。XmlPull的jar以及源文件见附件。

(2)SAX(Simple API for XML)解析
流模型中的"推"模型分析方式。通过事件驱动，每发现一个节点就引发一个事件，事件推给事件处理器，通过回调方法
完成解析工作，解析XML文档的逻辑需要应用程序完成
【优势】
①不需要等待所有数据都被处理，分析就能立即开始。
②只在读取数据时检查数据，不需要保存在内存中。
③可以在某个条件得到满足时停止解析，不必解析整个文档。
④效率和性能较高，能解析大于系统内存的文档。
【缺点】
①需要应用程序自己负责TAG的处理逻辑（例如维护父/子关系等），文档越复杂程序就越复杂。
②单向导航，无法定位文档层次，很难同时访问同一文档的不同部分数据，不支持XPath。
【原理】
简单的说就是对文档进行顺序扫描，当扫描到文档(document)开始与结束、元素(element)开始与结束时通知事件
处理函数(回调函数)，进行相应处理，直到文档结束
【事件处理器类型】
①访问XML DTD：DTDHandler
②低级访问解析错误：ErrorHandler
③访问文档内容：ContextHandler
【DefaultHandler类】
SAX事件处理程序的默认基类，实现了DTDHandler、ErrorHandler、ContextHandler和EntityResolver接口，通常
做法是，继承该基类，重写需要的方法，如startDocument()
【创建SAX解析器】
SAXParserFactory saxf = SAXParserFactory.newInstance();
SAXParser sax = saxf.newSAXParser();
注：关于遍历
①深度优先遍历(Depthi-First Traserval)
②广度优先遍历(Width-First Traserval)

(3)JDOM(Java-based Document Object Model)
Java特定的文档对象模型。自身不包含解析器，使用SAX
【优点】
①使用具体类而不是接口，简化了DOM的API。
②大量使用了Java集合类，方便了Java开发人员。
【缺点】
①没有较好的灵活性。
②性能较差。
(4)DOM4J(Document Object Model for Java)
简单易用，采用Java集合框架，并完全支持DOM、SAX和JAXP
【优点】
①大量使用了Java集合类，方便Java开发人员，同时提供一些提高性能的替代方法。
②支持XPath。
③有很好的性能。
【缺点】
①大量使用了接口，API较为复杂。
(5)StAX(Streaming API for XML)
流模型中的拉模型分析方式。提供基于指针和基于迭代器两种方式的支持,JDK1.6新特性
【和推式解析相比的优点】
①在拉式解析中，事件是由解析应用产生的，因此拉式解析中向客户端提供的是解析规则，而不是解析器。
②同推式解析相比，拉式解析的代码更简单，而且不用那么多库。
③拉式解析客户端能够一次读取多个XML文件。
④拉式解析允许你过滤XML文件和跳过解析事件。
【简介】
StAX API的实现是使用了Java Web服务开发（JWSDP）1.6，并结合了Sun Java流式XML分析器(SJSXP)-它位于
javax.xml.stream包中。XMLStreamReader接口用于分析一个XML文档，而XMLStreamWriter接口用于生成一个
XML文档。XMLEventReader负责使用一个对象事件迭代子分析XML事件-这与XMLStreamReader所使用的光标机制
形成对照。

34. Java与C++对比。

35. Java1.7与1.8新特性。

36. 设计模式：单例、工厂、适配器、责任链、观察者等等。

37. JNI的使用。

Java里有很多很杂的东西，有时候需要你阅读源码，大多数可能书里面讲的不是太清楚，需要你在网上寻找答案。

推荐书籍：《java核心技术卷I》《Thinking in java》《java并发编程》《effictive java》《大话设计模式》