关于Java 部分的160道面试题（三）

101、Tread 和 Threadlocal 的作用及区别？
【参考答案】
答：threadlocal 是 线程局部变量（thread local variable），为每一个使用该线程
的线程都提供一个变量值的副本，使每一个线程都可以独立地改变自己的副本，而不会和其
他线程的副本产生冲突。
102、TCP 和 UDP 的区别？
【参考答案】
TCP/IP 的运输层有两个不同的协议：①用户数据报协议 UDP ②传输控制协议 TCP
二者最大区别:TCP 是面向连接的,而 UDP 是无连接的.区别大致如下:
1）UDP 传送的数据单位协议是 UDP 报文或用户数据报,TCP 传送的数据单位协议
是 TCP 报文段。
2）UDP 发送数据之前不需要建立连接,因此减少了开销和发送之前的时延。TCP 提
供面向连接的服务,不提供广播或多播服务。
3）对方的运输层在收到 UDP 报文后,不需要给出任何确认。TCP 则需要确认。
4）UDP 没有拥塞控制,因此网络出现的拥塞不会使源主机的发送速率降低,也不保证
可靠交付,因此主机不需要维持具有许多参数的、复杂的连接状态表。TCP 要提供可靠的、
面向连接的运输服务,因此不可避免地增加了许多的开销,这不仅使协议数据单元的首部
增大很多,还要占用许多的处理机资源。
5）UDP 用户数据报只有 8 个字节的首部开销,比 TCP 的 20 个字节的首部要短。
103、启动一个线程用什么方法？【北京永中软件面试题】
【参考】
使用 Thread 类的 start()方法来启动一个线程，使线程进入就绪状态。如果自定义的
类是 Thread 类的子类的话，可以直接使用 Start()来启，如果是实现的 Runnable 接口的话，
还要将该类的实例作为参数传入到 Thread 对象中来启动。
104、作用域 public 等写不写的区别？【北京永中软件面试题】
【参考】
作用域不写将采用默认的作用域,默认作用域的访问权限是包的权限，也就是除本包中的
所有类能访问，不同包只有子类能访问。
105、同步和异步有何异同
【参考答案】
同步(synchronized)和异步(asynchronized)是对于多线程(multi-threading)而言的
同步可防止并发 主要出于数据安全的考虑
如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数
据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
异步允许并发
ajax 技术通常都是异步实现的，异步主要使用在当应用程序在对象上调用了一个需要
花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，
在很多情况下采用异步途径往往更有效率。
106、Static 方法和 static 字段有什么用处？可以被重载吗？
【参考答案】
用 static 修饰的方法叫类方法，被所有实例共享；static 修饰的字段为类变量，被所有实
例共享，在使用类变量时，一般会结合 final 一起使用定义类常量，不允许被其它的类实例
修改。
可以被重载，重载只是参数类型、顺序和个数不同。
107、JDK6 的新特性？
【参考答案】
1、在 JDK6 中 AWT 新增加了两个类:Desktop 和 SystemTray。前者可以用来打开系统默认
浏览器浏览指定的 URL,打开系统默认邮件客户端给指定的邮箱发邮件,用默认应用程序打
开或编辑文件(比如,用记事本打开以 txt 为后缀名的文件),用系统默认的打印机打印文档;后
者可以用来在系统托盘区创建一个托盘程序。
2、轻量级 Http Server。
JDK6 提供了一个简单的 Http Server API,据此我们可以构建自己的嵌入式 Http Server,它支持
Http 和 Https 协议,提供了 HTTP1.1 的部分实现，没有被实现的那部分可以通过扩展已有的
Http Server API 来实现,程序员必须自己实现 HttpHandler 接口。
3、嵌入式数据库 Derby 。Derby 并不是一个新的数据库产品,它是由 IBM 捐献给 Apache 的
DB 项目的一个纯 Java 数据库,JDK6.0 里面带的这个 Derby 的版本是 10.2.1.7,支持存储过程和触发器;有两种运行模式,一种是作为嵌入式数据库,另一种是作为网络数据库,前者的数据
库服务器和客户端都在同一个 JVM 里面运行。
4、使用 Compiler API。动态编译 Java 源文件，Compiler API 结合反射功能就可以实现动态
的产生 Java 代码并编译执行这些代码，有点动态语言的特征。这个特性对于某些需要用到
动态编译的应用程序相当有用， 比如 JSP Web Server，当我们手动修改 JSP 后，是不希望
需要重启 Web Server 才可以看到效果的，这时候我们就可以用 Compiler API 来实现动态编
译 JSP 文件，当然，现在的 JSP Web Server 也是支持 JSP 热部署的，现在的 JSP Web Server
通过在运行期间通过 Runtime.exec 或 ProcessBuilder 来调用 javac 来编译代码，这种方式需
要我们产生另一个进程去做编译工作，不够优雅而且容易使代码依赖与特定的操作系统；
Compiler API 通过一套易用的标准的 API 提供了更加丰富的方式去做动态编译,而且是跨平
台的。
其它略…像还有用 Console 开发控制台程序、JTable 的排序和过滤、插入式注解等。。。。
108、 请问？X=x+1;x+=1;x++三个执行效率哪个最高，为什么？
x=x+1 最低,因为它的执行过程如下：

1. 读取右 x 的地址;
2. x+1;
3. 读取左 x 的地址;
4. 将右值传给左边的 x(编译器并不认为左右 x 的地址相同). x+=1 其次,它的执行过程如下：
5. 读取右 x 的地址;
6. x=1;
7. 将得到的值传给 x(因为 x 的地址已经读出). x++最高,它的执行如下：
8. 读取右 x 的地址;
9. x 自增 1. 109、Java 字符串反转有几种方式实现？请将【hello TRS】字符串反转输出。
   1.String 类型写方法
   2.StringBuffer 对象直接调用 reverse()方法
   StringBuffer sb=new StringBuffer(“hello TRS”);
   sb.reverse();
   System.out.println(sb.toString());
   110、Java 堆栈的区别，各自存储什么类型的数据。
   堆与栈都是用于程序中的数据在 RAM(内存)上的存储区域。并且 Java 会自动地管理堆和栈，
   不能人为去直接设置。
   1.存储数据类型：栈内存中存放局部变量（基本数据类型和对象引用)，而堆内存用于存放
   对象（实体）。
   2.存储速度：就存储速度而言，栈内存的存储分配与清理速度更快于堆，并且栈内存的存储
   速度仅次于直接位于处理器当中的寄存器。
   3.灵活性：就灵活性而言，由于栈内存与堆内存存储机制的不同，堆内存灵活性更优于栈内存。
10. GC 线程是否为守护线程？（）
    答案：是守护线程
11. volatile 关键字是否能保证线程安全？（）
    volatile 不是保护线程安全的。 它保护的是变量安全。主要的功能是保护变量不被主函
    数和中断函数反复修改造成读写错误
12. 存在使 i+1<i 的数吗？
    答案：存在
    解析：如果 i 为 int 型，那么当 i 为 int 能表示的最大整数时，i+1 就溢出变成负数了，
    此时不就<i 了吗。
13. 不通过构造函数也能创造对象吗？（）
    Java 创建对象的几种方式
    (1) 用 new 语句创建对象，这是最常见的创建对象的方法。
    (2) 运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()
    实例方法。
    (3) 调用对象的 clone()方法。
    (4) 运用反序列化手段，调用 java.io.ObjectInputStream 对象的 readObject()方法。
14. Java 中的 final 关键字有哪些用法？
    final 可以修饰类、方法、变量。那么分别是什么作用呢？
    (1)修饰类：表示类不可被继承
    (2)修饰方法：表示方法不可被覆盖
    (3)修饰变量：表示变量一旦被赋值就不可以更改它的值。java 中规定 final 修饰成员变
    量必须由程序员显示指定变量的值
15. Java 中应该是用什么数据类型来代表价格
    BigDecimal 或 long
16. 怎么将 byte 转换为 String
    byte[1024] arr=new byte[1024];
    String str=new String(arr,0,arr.length);
17. Java 中怎么将 byte 转换为 long 类型
    //测试 long 转 byte 数组
    long long1 = 2223;
    byte[] bytesLong = longToBytes(long1);
    System.out.println(“bytes=” + bytesLong);//bytes=[B@c17164
    //测试 byte 数组 转 long
    long long2 = bytesToLong(bytesLong);
    System.out.println(“long2=” + long2);//long2=2223
18. 我们能将 int 强制转换为 byte 类型的变量吗？如果该值大于 byte 类型的范围将会出现
    什么现象
    是的，我们可以做强制转换，但是 Java 中 int 是 32 位的，而 byte 是 8 位的，所
    以，如果强制转化是，int 类型的高 24 位将会被丢弃，byte 类型的范围是从 -128 到 127
19. 存在两个类，B 继承 A， C 继承 B 我们能将 B 转换为 C 吗？
    不能
20. 哪个类包含 clone 方法？是 Cloneable 还是 Object？
    java.lang.Cloneable 是一个标示性接口，不包含任何方法，
    clone 方法在 object 类中定义。并且需要知道 clone() 方法是一个本地方法，这意味
    着它是由 c 或 c++ 或 其他本地语言实现的
21. a=a+b 与 a+=b 的区别？
    += 隐式的将加操作的结果类型强制转换为持有结果的类型。如果两这个整型相加，如
    byte、short 或者 int，首先会将它们提升到 int 类型，然后在执行加法操作。
22. 3*0.1==0.3 将会返回什么？TRUE 还是 FALSE？
    false，因为有些浮点数不能完全精确的表示出来
23. int 和 integer 哪个会占用更多的内存
    Integer 对象会占用更多的内存。Integer 是一个对象，需要存储对象的元数据。但是 int
    是一个原始类型的数据，所以占用的空间更少
24. 为什么 Java 中的 string 是不可变的
    在 Java 中， String 类是不可变的。那么到底什么是不可变的对象呢？
    可以这样认为：如果一个对象，在它创建完成之后，不能再改变它的状态，
    那么这个对象就是不可变的。不能改变状态的意思是，不能改变对象内的成员变量，
    包括 基本数据类型的值不能改变，引用类型的变量不能指向其他的对象，
    引用类型指向的对象的状态也不能改变
25. Java 构造器：什么是构造器？它的作用是什么？
    jvm 创建 Java 对象时候需要调用构造器，默认是不带参数的。在构造器中，你可以让 jvm
    帮你初始化一些参数或者执行一系列的动作，他是对象创建中执行的函数，即第一个被执行
    的方法。
26. abstract 的 method 是 否 可 同 时 是 static ， 是 否 可 同 时 native ， 是 否 可 同 时 是
    synchronized？
    都不可以，因为 abstract 申明的方法是要求子类去实现的，abstract 只是告诉你有这样
    一个接口，你要去实现，至于你的具体实现可以是 native 和 synchronized，也可以不是，抽
    象方法是不关心这些事的，所以写这两个是没有意义的。然后，static 方法是不会被覆盖的，
    而 abstract 方法正是要子类去覆盖它，所以也是没有意义的。所以，总的来说，就是 java 语
    法不允许你这样做，事实上，也没有意义这样做
27. 内部类可以引用它的包含类的成员吗？有没有什么限制？
    完全可以。
    如果不是静态内部类，那没有什么限制！
    如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通
    成员变量，而只能访问外部类中的静态成员
28. 举例说明 JDK7 中的新特性以及其在何种场景中使用？在实际工作中用过哪些？
    1.在 JDK1.7 中，摒弃了 Java 集合接口的实现类，如：ArrayList、HashSet 和 HashMap。
    而是直接采用[]、{}的形式存入对象，采用[]的形式按照索引、键值来获取集合中的对象，如
    下：
    List list=[“item”]; //向 List 集合中添加元素
    String item=list[0]; //从 List 集合中获取元素
    Set set={“item”}; //向 Set 集合对象中添加元素
    Map<String,Integer> map={“key”:1}; //向 Map 集合中添加对象
    int value=map[“key”]; //从 Map 集合中获取对象
    2.在 Switch 中可用 String
    在之前的版本中是不支持在 Switch 语句块中用 String 类型的数据的，这个功能在 C#语
    言中早已被支持，好在 JDK1.7 中加入了。
    String s = “test”;
    switch (s) {
    case “test” :
    System.out.println(“test”);
    case “test1” :
    System.out.println(“test1”);
    break ;
    default :
    System.out.println(“break”);
    break ;
    }
    3.数值可加下划线
    例如：int one_million = 1_000_000;
    4.支持二进制文字
    例如：int binary = 0b1001_1001;
    5.简化了可变参数方法的调用
    当程序员试图使用一个不可具体化的可变参数并调用一个varargs （可变）方法时，
    编辑器会生成一个“非安全操作”的警告。
    6、在 try catch 异常扑捉中，一个 catch 可以写多个异常类型，用"|"隔开
29. 创建一个对象的方式有哪些。
    一.最基本的：类名 对象名 Person person = new Person（）；
    二.匿名对象:new 类名（） new Person（）；
    三.通过反射： Class c = Class.forName（“类的全路径”）； Person person = （Person）
    c.newInstance();
30. Java 里的传引用和传值的区别是什么？
    解答：
    基本数据类型赋值属于值传递；引用类型之间赋值属于引用传递。
    值传递传递的是实实在在的变量值；引用传递传递的是对象的引用地址。
    值传递后，两个变量改变的是各自的值；引用传递后，两个引用改变的是同一个对象的
    状态。
31. 请阐述一下你对 JAVA 多线程中“锁”的概念的理解。
    解答：
    对象锁 用 synchronized 关键字。对象锁用于程序片段或者 method 上。
    所有想要进入该对象的 synchronized 的方法或者代码段的线程都必须获取对象的锁，如果
    没有，则必须等其他线程释放该锁。
32. Collections 和 Collection 的区别
    Collections 是个 java.util 下的类，它包含有各种有关集合操作的静态方法
    Collection 是个 java.util 下的接口，它是各种集合结构的父接口
33. Collection 框架中实现比较要实现什么接口
    Comparable,Comparator 接口
34. 为什么 list 里面是 integer，但放进去和拿出来全部是 int？
    其实拿出来是是 integer，可以用 int，基本数据类型的自动装箱、拆箱
35. 如何在外面有多线程调用时，保证这个唯一的 list 的正确性？
    synchronized 线程锁和 volatile 用 volatile 修饰的变量，线程在每次使用变量的时候，都
    会读取变量修改后的最的值。volatile 很容易被误用，用来进行原子性操作。
36. java 在多个线程环境下，为什么要为每个线程维护一个独立的程序计数器?
    程序计数器指向下一条指令（CPU 指令的地址），线程是 CPU 的执行和调度单元，不
    同的线程的执行路径（执行的指令）、和执行时序不一样，所以每个线程有自己私有的
    程序计数器和堆栈。
37. 运行时异常与一般异常有何异同?
    runtime exception ，也称运行时异常，我们可以不处理。当出现这样的异常时，总是
    由虚拟机 接管
    Error ：表示由 JVM 所侦测到的无法预期的错误，由于这是属于 JVM 层次的严重错
    误 ，导致 JVM 无法继续执行，因此，这是不可捕捉到的，无法采取任何恢复的操作，
    顶多只能显示错误信息。
    Exception ：表示可恢复的例外，这是可捕捉到的。
38. 说出 ArrayList,Vector,LinkedList 的存储性能和特性
    ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以
    最大的缺点就是插入删除时非常麻烦
    LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的
    索引 但是缺点就是查找非常麻烦 要丛第一个索引开始
    ArrayList 和 Vector 都是用数组方式存储数据,此数组元素数要大于实际的存储空间以便
    进行元素增加和插入操作,他们都允许直接用序号索引元素,但是插入数据元素涉及到元
    素移动等内存操作,所以索引数据快而插入数据慢. Vector 使用了 sychronized 方法(线程安全),所以在性能上比 ArrayList 要差些. LinkedList 使用双向链表方式存储数据,按序号索引数据需要前向或后向遍历数据，所以
    索引数据慢,是插入数据时只需要记录前后项即可,所以插入的速度快. 140. final,finally,finalize 的区别。
    final—修饰符（关键字）如果一个类被声明为 final，意味着它不能再派生出新的子类，
    不能作为父类被继承。因此一个类不能既被声明为 abstract 的，又被声明为 final 的。
    将变量或方法声明为 final，可以保证它们在使用中不被改变。被声明为 final 的变量必
    须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为 final 的方法
    也同样只能使用，不能重载。
    finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么
    相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。
    finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除
    出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对
    这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖
    finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器
    删除对象之前对这个对象调用的。
39. JAVA 中常用的数据结构有哪些？
    数据结构：
    ①数组 (Array)
    在程序设计中，为了处理方便， 把具有相同类型的若干变量按有序的形式组
    织起来。这些按序排列的同类数
    据元素的集合称为数组。在 C 语言中， 数组属于构造数据类型。一个数组可
    以分解为多个数组元素，这些数组
    元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同，数组又
    可分为数值数组、字符数组、指
    针数组、结构数组等各种类别。
    ②栈 (Stack)
    栈是只能在某一端插入和删除的特殊线性表。它按照先进后出的原则存储数
    据，先进入的数据被压入栈底，最后
    的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一
    个读出来）。
    ③队列 (Queue) 一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后
    端（rear）进行插入操作。进行
    插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称
    为空队列。
    ④链表 (Linked List) 一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过
    链表中的指针链接次序实现的。
    链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动
    态生成。每个结点包括两个部分：
    一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
    ⑤树 (Tree)
    树是包含 n（n>0）个结点的有穷集合 K，且在 K 中定义了一个关系 N，N 满
    足 以下条件：
    （1）有且仅有一个结点 k0，他对于关系 N 来说没有前驱，称 K0 为树的根结
    点。简称为根（root）
    （2）除 K0 外，k 中的每个结点，对于关系 N 来说有且仅有一个前驱。
    （3）K 中各结点，对关系 N 来说可以有 m 个后继（m>=0）。
    ⑥堆 (Heap)
    在计算机科学中，堆是一种特殊的树形数据结构，每个结点都有一个值。通常
    我们所说的堆的数据结构，是指
    二叉堆。堆的特点是根结点的值最小（或最大），且根结点的两个子树也是一
    个堆。
    ⑦图 (Graph)
    图是由结点的有穷集合 V 和边的集合 E 组成。其中，为了与树形结构加以区
    别，在图结构中常常将结点称为顶点，
    边是顶点的有序偶对，若两个顶点之间存在一条边，就表示这两个顶点具有相
    邻关系。
    ⑧散列表 (Hash)
    若结构中存在关键字和 K 相等的记录，则必定在 f(K)的存储位置上。由此，
    不需比较便可直接取得所查记录。称
    这个对应关系 f 为散列函数(Hash function)，按这个思想建立的表为散列表。
40. 什么是基于接口编程
    在系统分析和架构中，分清层次和依赖关系，每个层次不是直接向其上层提供服务（即
    不是直接实例化在上层中），而是通过定义一组接口，仅向上层暴露其接口功能，上层
    对于下层仅仅是接口依赖，而不依赖具体类。
    这样做的好处是显而易见的，首先对系统灵活性大有好处。当下层需要改变时，只要接
    口及接口功能不变，则上层不用做任何修改。甚至可以在不改动上层代码时将下层整个
    替换掉，使用接口的另一个好处就是不同部件或层次的开发人员可以并行开工，只要接
    口一致，设计合理，完全可以并行进行开发，从而提高效率。
    面向对象语言中的“接口”是指具体的一种代码结构，例如 C#中用 interface 关键字定义
    的接口。而“面向接口编程”中的“接口”可以说是一种从软件架构的角度、从一个更抽象
    的层面上指那种用于隐藏具体底层类和实现多态性的结构部件。
    面向接口编程”中的接口是一种思想层面的用于实现多态性、提高软件灵活性和可维护
    性的架构部件，而具体语言中的“接口”是将这种思想中的部件具体实施到代码里的手
    段。如果单从具体代码来看，对这两个概念很容易模糊，甚至觉得接口就是多余的，因
    为单从具体功能来看，除多重继承外（C#，Java 中），抽象类似乎完全能取代接口。但
    是，抽象类和接口的区别在于使用动机。使用抽象类是为了代码的复用，而使用接口的
    动机是为了实现多态性。
41. 用 JAVA 实现一种排序算法
    /**

• 冒泡排序
• 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最
  后的元素应该会是最大的数。
• 针对所有的元素重复以上的步骤，除了最后一个。
• 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
• @param numbers 需要排序的整型数组
  */
  public static void bubbleSort(int[] numbers)
  {
  int temp = 0;
  int size = numbers.length;
  for(int i = 0 ; i < size-1; i ++)
  {
  for(int j = 0 ;j < size-1-i ; j++)
  {
  if(numbers[j] > numbers[j+1]) //交换两数位置 {
  temp = numbers[j];
  numbers[j] = numbers[j+1];
  numbers[j+1] = temp;
  }
  }
  }
  }

144. 静态变量在什么时候加载？编译期还是运行期？静态代码块加载的时机呢？
     全局变量（成员变量）是在创建对象的时候分配内存的创建对象过程为 1 分配空间 2
     递归的创建父类对象（无父类这步可省略）3 初始化成员变量 4 调用构造方法创建一个
     对象
     静态变量是在类加载的时候分配空间的，静态变量和对象没有关系是在 JVM 第一次读
     到一个类的时候加载信息的过程中分配空间的类加载过程为 1 加载父类（如果父类已经
     加载过，则不在加载）2 初始化静态属性 3 按顺序的初始化静态代码块
     初始化的前提就是分配空间
     而且静态变量在以后的创建对象的时候不在初始化所以一般用静态来保存共享信息
145. JAVA 中解析 XML 有几种方法？
     1、JDOM 生成和解析 XML
     为减少 DOM、SAX 的编码量,出现了 JDOM
     优点:20-80 原则,极大减少了代码量。
     使用场合:要实现的功能简单,如解析、创建等,但在底层,JDOM 还是使用 SAX(最常用)、
     DOM、Xanan 文档。
     2、SAX 生成和解析 XML 文档
     为解决 DOM 的问题,出现了 SAX,SAX 事件驱动。当解析器发现元素开始、元素结束、
     文本、文档的开始或结束等时发送事件,程序员编写响应这些事件的代码,保存数据。
     优点:不用事先调入整个文档,占用资源少。SAX 解析器代码比 DOM 解析器代码小,适于
     Applet 下载。
     缺点:不是持久的,事件过后若没保存数据,那么数据就丢了。无状态性,从事件中只能得到
     文本,但不知该文本属于哪个元素。
     使用场合:Applet。只需 XML 文档的少量内容,很少回头访问,机器内存少。
     3、DOM 生成和解析 XML 文档
     为 XML 文档的已解析版本定义了一组接口。解析器读入整个文档,然后构建一个驻留内
     存的树结构,然后代码就可以使用 DOM 接口来操作这个树结构。
     优点:整个文档树在内存中,便于操作,支持删除、修改、重新排列等多种功能。
     缺点:将整个文档调入内存(包括无用的节点),浪费时间和空间。
     使用场合:一旦解析了文档还需多次访问这些数据,硬件资源充足(内存、CPU)。
     4、DOM4J 生成和解析 XML 文档
     DOM4J 是一个非常非常优秀的 Java XML API,具有性能优异、功能强大和极端易用使
     用的特点,同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都
     在使用 DOM4J 来读写 XML,特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。
146. 有 4 个女人要过一座桥.她们都站在桥的某一边,要让她们在 17 分钟内全部通过这座桥. 这时是晚上.她们只有一个手电筒.最多只能让两个人同时过桥.不管是谁过桥,不管是一
     个人还是两个人,必须要带着手电筒.手电筒必须要传来传去,不能扔过去.每个女人过桥
     的速度不同,两个人的速度必须以较慢的那个人的速度过桥. 第一个女人：过桥需要 1 分钟；
     第二个女人：过桥需要 2 分钟；
     第三个女人：过桥需要 5 分钟；
     第四个女人：过桥需要 10 分钟. 怎样让这 4 个女人在 17 分钟内过桥? 一、二过，用 2 分钟，
     一回来用 1 分钟，二留下
     三、四过,用 10 分钟，
     让留下的二回来，用 2 分钟；
     最后一、二过，用 2 分钟，共用 17 分钟
147. 面向对象的四个基本特征是什么
     面向对象的编程方法具有四个基本特征：
     1.抽象：
     抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目
     标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分
     细节。比如，我们要设计一个学生成绩管理系统，考察学生这个对象时，我们只关心他
     的班级、学号、成绩等，而不用去关心他的身高、体重这些信息。抽象包括两个方面，
     一是过程抽象，二是数据抽象。过程抽象是指任何一个明确定义功能的操作都可被使用
     者看作单个的实体看待，尽管这个操作实际上可能由一系列更低级的操作来完成。数据
     抽象定义了数据类型和施加于该类型对象上的操作，并限定了对象的值只能通过使用这
     些操作修改和观察。
     2.继承： 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种
     明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。
     新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基
     类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加
     新的方法使之更适合特殊的需要。这也体现了大自然中一般与特殊的关系。继承性很好
     的解决了软件的可重用性问题。比如说，所有的 Windows 应用程序都有一个窗口，它
     们可以看作都是从一个窗口类派生出来的。但是有的应用程序用于文字处理，有的应用
     程序用于绘图，这是由于派生出了不同的子类，各个子类添加了不同的特性。
     3.封装：
     封装是面向对象的特征之一，是对象和类概念的主要特性。封装是把过程和数据包
     围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现
     实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访
     问其他对象。一旦定义了一个对象的特性，则有必要决定这些特性的可见性，即哪些特
     性对外部世界是可见的，哪些特性用于表示内部状态。在这个阶段定义对象的接口。通
     常，应禁止直接访问一个对象的实际表示，而应通过操作接口访问对象，这称为信息隐
     藏。事实上，信息隐藏是用户对封装性的认识，封装则为信息隐藏提供支持。封装保证
     了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的
     内部，因而可以将应用程序修改带来的影响减少到最低限度。
148. 多态性：
     多态性是指允许不同类的对象对同一消息作出响应。比如同样的加法，把两个时间
     加在一起和把两个整数加在一起肯定完全不同。又比如，同样的选择编辑-粘贴操作，
     在字处理程序和绘图程序中有不同的效果。多态性包括参数化多态性和包含多态性。多
     态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同
     名问题。
     面向对象程序设计具有许多优点：
     1、开发时间短，效率高，可靠性高，所开发的程序更强壮。由于面向对象编程的可重
     用性，可以在应用程序中大量采用成熟的类库，从而缩短了开发时间。
     2、应用程序更易于维护、更新和升级。继承和封装使得应用程序的修改带来的影响更
     加局部化。
149. String 是最基本的数据类型吗？String 类可以被继承吗？String 类为什么是 final 的？
     不是数据类型，
     基本数据类型包括：byte,short,int,long,float,double,boolean,char. 而 String 是类代表字符串，属于引用类型，所谓引用类型包括：类，接口，数组. 不可以被继承，因为 String 类有 final 修饰符，而 final 修饰的类是不能被继承的，实现
     细节不允许改变。
     public final class String implements java.io.Serializable, Comparable, CharSequence
     String 类为什么是 final 的
     主要是为了“效率” 和 “安全性” 的缘故。若 String 允许被继承, 由于它的高度被使用
     率, 可能会降低程序的性能，所以 String 被定义成 final。
150. JAVA 的基本数据类型是什么？基本类型对应的封装类是什么？
     数据类型 默认值 封装类(都在 java.lang 包下)
     byte (byte)0 Byte
     short (short)0 Short
     int 0 Integer
     long 0L Long
     float 0.0f Float
     double 0.0d Double
     char \u0000 Character
     boolean false Boolean
151. 在 JAVA 中怎样强迫立即执行垃圾回收?
     直接调用 system.gc()会立即停止所有线程并执行 full gc
     垃圾收集器在一个 Java 程序中的执行是自动的，不能强制执行，即使程序员能明确地
     判断出有一块内存已经无用了，是应该回收的，程序员也不能强制垃圾收集器回收该内
     存块。程序员唯一能做的就是通过调用 System. gc 方法来"建议"执行垃圾收集器，但其
     是否可以执行，什么时候执行却都是不可知的。这也是垃圾收集器的最主要的缺点。当
     然相对于它给程序员带来的巨大方便性而言，这个缺点是瑕不掩瑜的。
152. 简述 PATH 和 CLASSPATH 的作用？
     path 是路径变量，它的作用是告诉系统在当前目录找不到所需文件时，就按 path 指定
     的路径查找
     classpath 是 java 编译器专用的变量，用于告诉 java 编译器去哪儿找类文件
153. 一个类中的静态块在什么时候被执行？
     静态代码块是在构造之前执行的
154. JAVA 中的元注解有哪些？
     四个元注解分别是：@Target,@Retention,@Documented,@Inherited ，再次强调下元注
     解是 java API 提供，是专门用来定义注解的注解，其作用分别如下：
     @Target 表示该注解用于什么地方，可能的值在枚举类 ElemenetType 中，包括：
     ElemenetType.CONSTRUCTOR----------------------------构造器声明
     ElemenetType.FIELD --------------------------------------域声明（包括 enum 实例）
     ElemenetType.LOCAL_VARIABLE------------------------- 局部变量声明
     ElemenetType.METHOD ----------------------------------方法声明
     ElemenetType.PACKAGE --------------------------------- 包声明
     ElemenetType.PARAMETER ------------------------------参数声明
     ElemenetType.TYPE--------------------------------------- 类，接口（包括注解类型）或 enum
     声明
     @Retention 表示在什么级别保存该注解信息。可选的参数值在枚举类型 RetentionPolicy
     中，包括：
     RetentionPolicy.SOURCE ---------------------------------注解将被编译器丢弃
     RetentionPolicy.CLASS -----------------------------------注解在 class 文件中可用，但会被
     VM 丢弃
     RetentionPolicy.RUNTIME VM-------将在运行期也保留注释，因此可以通过反射机制读
     取注解的信息。
     @Documented 将此注解包含在 javadoc 中 ，它代表着此注解会被 javadoc 工具提取成
     文档。在 doc 文档中的内容会因为此注解的信息内容不同而不同。相当与@see,@param 等。
     @Inherited 允许子类继承父类中的注解。
155. JAVA 虚拟机中堆内存的两大区域分别是什么？
     在 Java 中，堆被划分成两个不同的区域：新生代 ( Young )、老年代 ( Old )。
156. 设计一算法从一个互不相同的整数数组（奇数个数）中找到最中间大小的那个数，如从
     数组 8,5,6,3,1,7,2,中找出数字 5。另外考虑能否找到更高效率的算法（使用 C/C++,Java
     或者 JavaScript 实现）。
157. 有两个变量 A,B,写一段程序，把 A 和 B 的值调换一下，例如 A=10，B=20，程序执行
     完毕，A=20，B=10，（注意：不能使用中间变量）
     int a = 10, b = 20;
     a = a + b;// a 保存两数之和
     b = a - b;// 两数之和-b，即为 a
     a = a - b;// 两数之和-b，此时的 b 已经变成了 a，所以相当于 sum-a=b??
     System.out.println(“a=” + a + “,b=” + b);
158. 数组排序。有一个一维数组 A,写一段程序使数组的值从小到大排序，例如 A 的值为
     （3,7,2,6,4,8,9），程序执行完毕，A 的值为（2,3,4,6,7,8,9）
     int[] arr = {3,7,2,6,4,8,9};
     java.util.Arrays.sort(arr);
159. 面向对象中的抽象和封装分别是什么？
     抽象
     抽象是通过特定的实例抽取共同特征以后形成概念的过程。它强调主要特征，忽略次要
     特征。一个对象是现实世界中一个实体的抽象，一个类足一组对象的抽象，抽象是一种
     单一化的描述，它强调给出与应用相关的特性，抛弃不相关的特性。
     封装
     封装是将相关的概念组成一个单元，然后通过一个名称来引用它。面向对象封装是将数
     据和基于数据的操作封装成一个整体对象，对数据的访问或修改只能通过对象对外提供
     的接口进行。
160. JDBC 调用数据库的基本步骤
     1,加载驱动
     2,创建连接
     3,获取语句对象
     4,执行 sql 语句
     5,如果是查询,还可以使用结果集
     6,关闭连接
     7,捕捉和处理异常