1.面试题基础

Java面试宝典(基础篇)

1.Java中的方法覆盖(Overriding)和方法重载(Overloading)是什么意思？ 重写和重载的区别?

答: Java中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。与此相对，方法覆盖是说子类重新定义了父类的方法。方法覆盖必须有相同的方法名，参数列表和返回类型。覆盖者可能不会限制它所覆盖的方法的访问。
重载(Overloading)
（1） 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载Overloading是一个类中多态性的一种表现。
（2） Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。
（3） 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。
重写（Overriding）
（1） 父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。
（2）若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。（3）子类函数的访问修饰权限不能少于父类的；

2.Java中，什么是构造函数？什么是构造函数重载？什么是复制构造函数？

答: 当新对象被创建的时候，构造函数会被调用。每一个类都有构造函数。在程序员没有给类提供构造函数的情况下，Java编译器会为这个类创建一个默认的构造函数。
Java中构造函数重载和方法重载很相似。可以为一个类创建多个构造函数。每一个构造函数必须有它自己唯一的参数列表。
Java不支持像C++中那样的复制构造函数，这个不同点是因为如果你不自己写构造函数的情况下，Java不会创建默认的复制构造函数。

3.Java支持多继承么？

答: Java中类不支持多继承，只支持单继承（即一个类只有一个父类）。 但是java中的接口支持多继承，，即一个子接口可以有多个父接口。（接口的作用是用来扩展对象的功能，一个子接口继承多个父接口，说明子接口扩展了多个功能，当类实现接口时，类就扩展了相应的功能）。

4.接口和抽象类的区别是什么？

答: 接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final (这里需要说一点,既然一个变量被final修饰了,那么这个变量就是一个常量!!!变量必须初始化成常量!!!)
下面比较一下两者的语法区别：

1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量!!!(注意重点在 普通 即 非静态 和 变量!!!)
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public
abstract类型。
5. 抽象类中可以包含静态方法(static)，接口中不能包含静态方法.
6. 抽象类和接口中都可以包含静态成员变量(static)，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7. 一个类可以实现多个接口，但只能继承一个抽象类。

何时用接口,何时用抽象类?
子类继承抽象类就不能再继承其他类(java的单继承原则),所以有抽象方法时优先使用接口定义.
如果所有方法都没有实现,优先使用接口.
一些方法已经可以实现，而另一些方法无法或不想实现时,且继承(实现)关系很简单时,考虑用抽象类定义，留给后代去实现。jdk8之后,也可以在接口中定义default方法或static方法来实现.

5.什么是值传递和引用传递？

答: 值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量.
引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。 所以对引用对象进行操作会同时改变原对象.
一般认为,java内的传递都是值传递.

6.创建线程有几种不同的方式？你喜欢哪一种？为什么？

答: 有两种方式可以用来创建线程：
继承Thread类
实现Runnable接口
实现Runnable接口这种方式更受欢迎，因为这不需要继承Thread类。在应用设计中已经继承了别的对象的情况下，这需要多继承（而Java不支持多继承），只能实现接口。同时，线程池也是非常高效的，很容易实现和使用。

7.概括的解释下线程的几种可用状态。

答:

1. 新建( new )：新创建了一个线程对象。
2. 可运行( runnable )：线程对象创建后，其他线程(比如 main 线程）调用了该对象 的 start ()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获 取 cpu 的使用权 。
3. 运行( running )：可运行状态( runnable )的线程获得了 cpu 时间片（ timeslice ） ，执行程序代码。
4. 阻塞( block )：阻塞状态是指线程因为某种原因放弃了 cpu 使用权，也即让出了 cpu timeslice ，暂时停止运行。直到线程进入可运行( runnable )状态，才有 机会再次获得 cpu timeslice 转到运行( running )状态。阻塞的情况分三种：
   (一). 等待阻塞：运行( running )的线程执行 o . wait ()方法， JVM 会把该线程放 入等待队列( waitting queue )中。
   (二). 同步阻塞：运行( running )的线程在获取对象的同步锁时，若该同步锁 被别的线程占用，则 JVM 会把该线程放入锁池( lock pool )中。
   (三). 其他阻塞: 运行( running )的线程执行 Thread . sleep ( long ms )或 t . join ()方法，或者发出了 I / O 请求时， JVM 会把该线程置为阻塞状态。当 sleep ()状态超时、 join ()等待线程终止或者超时、或者 I / O 处理完毕时，线程重新转入可运行( runnable )状态。
5. 死亡( dead )：线程 run ()、 main () 方法执行结束，或者因异常退出了 run ()方法，则该线程结束生命周期。死亡的线程不可再次复生。

8.同步方法和同步代码块的区别是什么？

答: 区别：
同步方法默认用this或者当前类class对象作为锁；
同步代码块可以选择以什么来加锁，比同步方法要更细颗粒度，我们可以选择只同步会发生同步问题的部分代码而不是整个方法；

9.什么是死锁(deadlock)？如何确保N个线程可以访问N个资源同时又不导致死锁？

答: 两个线程或两个以上线程都在等待对方执行完毕才能继续往下执行的时候就发生了死锁。结果就是这些线程都陷入了无限的等待中.
使用多线程的时候，一种非常简单的避免死锁的方式就是：指定获取锁的顺序，并强制线程按照指定的顺序获取锁。因此，如果所有的线程都是以同样的顺序加锁和释放锁，就不会出现死锁了。

10.Java集合类框架的基本接口有哪些？

答: 集合类接口指定了一组叫做元素的对象。集合类接口的每一种具体的实现类都可以选择以它自己的方式对元素进行保存和排序。有的集合类允许重复的键，有些不允许。
Java集合类提供了一套设计良好的支持对一组对象进行操作的接口和类。Java集合类里面最基本的接口有：
Collection：代表一组对象，每一个对象都是它的子元素。
Set：不包含重复元素的Collection。
List：有顺序的collection，并且可以包含重复元素。
Map：可以把键(key)映射到值(value)的对象，键不能重复。

11.什么是迭代器(Iterator)？

答: Iterator接口提供了很多对集合元素进行迭代的方法。每一个集合类都包含了可以返回迭代器实例的迭代方法。迭代器可以在迭代的过程中删除底层集合的元素,但是不可以直接调用集合的
remove(Object Obj)删除，可以通过迭代器的remove()方法删除。

12.数组(Array)和列表(ArrayList)有什么区别？什么时候应该使用Array而不是ArrayList？

答: 下面列出了Array和ArrayList的不同点：
Array可以包含基本类型和对象类型，ArrayList只能包含对象类型。
Array大小是固定的，ArrayList的大小是动态变化的。
ArrayList提供了更多的方法和特性，比如：addAll()，removeAll()，iterator()等等。
对于基本类型数据，集合使用自动装箱来减少编码工作量。但是，当处理固定大小的基本数据类型的时候，这种方式相对比较慢

13.ArrayList和LinkedList有什么区别？

答: ArrayList和LinkedList都实现了List接口，他们有以下的不同点：
1、ArrayList和LinkedList从名字分析，它们一个是Array(动态数组)的数据结构，一个是Link(链表)的数据结构，此外，它们两个都是对List接口的实现。

前者是数组队列，相当于动态数组；后者为双向链表结构，也可当作堆栈、队列、双端队列

2、当随机访问List时（get和set操作），ArrayList比LinkedList的效率更高，因为LinkedList是线性的数据存储方式，所以需要移动指针从前往后依次查找。

3、当对数据进行增加和删除的操作时(add和remove操作)，LinkedList比ArrayList的效率更高，因为ArrayList是数组，所以在其中进行增删操作时，会对操作点之后所有数据的下标索引造成影响，需要进行数据的移动。

4、从利用效率来看，ArrayList自由性较低，因为它需要手动的设置固定大小的容量，但是它的使用比较方便，只需要创建，然后添加数据，通过调用下标进行使用；而LinkedList自由性较高，能够动态的随数据量的变化而变化，但是它不便于使用。

5、ArrayList主要控件开销在于需要在lList列表预留一定空间；而LinkList主要控件开销在于需要存储结点信息以及结点指针信息。

14.HashSet和TreeSet有什么区别？

答: HashSet是由一个hash表来实现的，因此，它的元素是无序的。add()，remove()，contains()方法的时间复杂度是O(1)。
另一方面，TreeSet是由一个树形的结构来实现的，它里面的元素是有序的。因此，add()，remove()，contains()方法的时间复杂度是O(logn)。

15.Java中的两种异常类型是什么？他们有什么区别？

答: Java中有两种异常：受检查的(checked)异常和不受检查的(unchecked)异常。不受检查的异常不需要在方法或者是构造函数上声明，就算方法或者是构造函数的执行可能会抛出这样的异常，并且不受检查的异常可以传播到方法或者是构造函数的外面。相反，受检查的异常必须要用throws语句在方法或者是构造函数上声明。

16.Java中Exception和Error有什么区别？

答: ⑴Exception是程序正常运行中，可以预料的意外情况，应该被捕获，进行相应处理。

⑵Exception又分为受检查的(checked)异常和不受检查(unchecked)异常。可检查异常在源代码里必须显式的进行捕获处理，这是编译期检查的一部分。不可检查时异常是指运行时异常，像NullPointerException、ArrayIndexOutOfBoundsException之类，通常是可以编码避免的逻辑错误，具体根据需要来判断是否需要捕获，并不会在编译期强制要求。

⑶Error是指正常情况下，不大可能出现的情况，绝大部分的Error都会导致程序处于非正常的、不可恢复的状态。既然是非正常情况，不便于也不需要捕获。常见的比如OutOfMemoryError之类都是Error的子类。

17.throw和throws有什么区别？

答:
1、throws出现在方法头；而throw出现在函数体。
2、throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常。
3、两者都是消极处理异常的方式，只是抛出或者可能抛出异常，但是不会由函数去处理异常。

18.JDK和JRE的区别是什么？

答: Java运行时环境(JRE)是将要执行Java程序的Java虚拟机。它同时也包含了执行applet需要的浏览器插件。Java开发工具包(JDK)是完整的Java软件开发包，包含了JRE，编译器和其他的工具(比如：JavaDoc，Java调试器)，可以让开发者开发、编译、执行Java应用程序。

19.请说出ArrayList,Vector, LinkedList的存储性能和特性

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

20.Set 和 List的区别?

List：
特点：
1，有序(存储元素的顺序和取出元素的顺序一致)
2，该集合中的元素都有索引，所以可以通过索引(角标)来访问元素。
3，它可以存储重复元素。

|–Vector:jdk1.0就存在了。底层是数组结构的。可变长度数组，
原理：一旦原数组长度不够，会创建新数组，将原数组的元素复制到新数组中，并将新元素添加到新数组中。
Vector是同步的。

• ArrayList:底层是数组结构，也是支持长度可变数组的。是不同步的。替代了Vector.因为效率高。 查询效率很高。 但是增删的效率很低。
• LinkedList:底层是链接列表结构，简称链表结构。是不同步的。这个中结构的好处：对元素的增删非常效率很高。 查询的效率很低。

Set:
其中的方法和Collection一致，只要重点注意它的子类对象即可。取出元素只能使用迭代器。
特点：
1，不包含重复元素。(最大的特点)
2，这个集合存入元素的顺序和取出元素的顺序不一定一致。(具体的容器对象数据结构不同，顺序也有不同)

• HashSet：底层数据结构是哈希表，不保证顺序，是不同步的。
  哈希表：提供数组的查询效率而出现的。
  将要存储的元素先通过哈希算法算出一个哈希值来标识存储的位置，代表着元素。要找元素时，先将该元素通过哈希算法算出哈希值，在通过哈希值到哈希表中去查找。
  特点：
  1，不关系元素的顺序。
  2，提高了查询效率。
  3，不可能出现重复元素，因为哈希值都不同。即使相同，会再次判断两个元素的equals，内容是否相同。
  如果内容也相同，不存，如果内容不同，存储。所以哈希表要保证元素的唯一性，必须要依赖于两个方法。
  1,hashCode 2,equals
• TreeSet：可以给Set集合中的元素进行指定顺序的排序。非同步的。
  默认情况下，是通过元素的自然顺序排的序。
  它保证元素唯一性的依据是看比较方法的返回结果是否是0.是0.就视为元素相同。不存。
  TreeSet排序的方式一：让元素自身具备比较性，需要实现Comparable接口，覆盖compareTo方法。这种比较方式成为自然顺序排序。如果元素自身不具备比较性或者具备的比较性(自然顺序)不是所需要的。
  这时只能用第二种方式 。
  TreeSet排序的方式二：让容器自身具备比较性。容器一初始化就具备了比较功能。因为容器时在对象构造时完成的。通过查阅，有一个构造方法TreeSet(Comparator).在容器初始化时可以指定一个比较器。 需要实现Comparator接口，覆盖compare方法即可。所以这种方式成为比较器排序。
  当存入的的对象有重复时，用List，没有重复元素时，用Set。

21.==操作符与equals的区别?

答: 对于值类型：==比较数值是否相等，值类型没有equals方法
对于引用类型：
如果该类型没有重载equals方法，则“==”和“equals”方法返回的结果一致，即比较两个变量引用的地址是否相等
如果重载了equals方法，则equals方法的行为需要看重载方法的具体定义，==依然比较的是两个变量的引用地址
如果则==返回true则equals应该也会返回true（正确实现了equals），反之则不一定

22.多线程的优缺点是什么?

答: 优点：
(1)多线程技术使程序的响应速度更快 ,因为用户界面可以在进行其它工作的同时一直处于活动状态;
(2)当前没有进行处理的任务时可以将处理器时间让给其它任务;
(3)占用大量处理时间的任务可以定期将处理器时间让给其它任务;
(4)可以随时停止任务;
(5)可以分别设置各个任务的优先级以优化性能。

是否需要创建多个线程取决于各种因素。在以下情况下,最适合采用多线程处理:
(1)耗时或大量占用处理器的任务阻塞用户界面操作;
(2)各个任务必须等待外部资源 (如远程文件或 Internet连接)。

多线程的主要缺点包括:
(1)等候使用共享资源时造成程序的运行速度变慢。这些共享资源主要是独占性的资源 ,如打印机等。
(2)对线程进行管理要求额外的 CPU开销。线程的使用会给系统带来上下文切换的额外负担。当这种负担超过一定程度时,多线程的特点主要表现在其缺点上,比如用独立的线程来更新数组内每个元素。
(3)线程的死锁。即较长时间的等待或资源竞争以及死锁等多线程症状。
(4)对公有变量的同时读或写。当多个线程需要对公有变量进行写操作时,后一个线程往往会修改掉前一个线程存放的数据,从而使前一个线程的参数被修改;另外 ,当公用变量的读写操作是非原子性时,在不同的机器上,中断时间的不确定性,会导致数据在一个线程内的操作产生错误,从而产生莫名其妙的错误,而这种错误是程序员无法预知的。

23.io流 按照流向分 按照处理内容分? 字节流都有哪些方法?

答:【流的分类详细】
[ 输入流—输出流 ]
按照流的流向，可以将流分为输入流和输出流。
输入流：从其中读取数据
输出流：向其种写入数据
注意：划分输入/输出流是从程序运行时的所在的内存的角度来划分的。
输入流常用的基础类：InputStream和Reader
输出流常用的基础类：OutputStream和Writer
注意：这些积累都是抽象类，无法直接实例化。
[ 字节流—字符流 ]
字节流和字符流的内的方法几乎一样，区别仅仅是其操作的数据单元大小不同，
字节流的数据操作单元： 8位的字节
字符流的数据操作单元： 16位的字节
字节流常用的基础类：InputStream和OutputStream
字符流常用的基础类：Reader和Writer

read(),write(),close(),flush()

24.java里final finally finalize区别?

答:
final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally 是异常处理语句结构的一部分，表示总是执行。
finalize 是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等
final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。
finally—在异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。
finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

25.sleep()和wait()的区别?

答: 1、这两个方法来自不同的类分别是Thread和Object
2、最主要是sleep方法没有释放锁，而 wait 方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3、wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用（使用范围）
4、sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

26.简单叙述出collections接口中的三个常用方法

答:

27.什么是多态

答: 多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）多态存在的三个必要条件
一、要有继承；
二、要有重写；
三、父类引用指向子类对象。Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。

28.java中 public/private/protected和default(默认)的区别

答: public：
具有最大的访问权限，可以访问任何一个在classpath下的类、接口、异常等。它往往用于对外的情况，也就是对象或类对外的一种接口的形式。
protected：
主要的作用就是用来保护子类的。它的含义在于子类可以用它修饰的成员，其他的不可以，它相当于传递给子类的一种继承的东西
default：
有时候也称为friendly，它是针对本包访问而设计的，任何处于本包下的类、接口、异常等，都可以相互访问，即使是父类没有用protected修饰的成员也可以。
private：
访问权限仅限于类的内部，是一种封装的体现，例如，大多数成员变量都是修饰符为private的，它们不希望被其他任何外部的类访问。

29.String、StringBuffer、StringBuilder有什么区别？

答:
1. String 字符串常量
2. StringBuffer 字符串变量（线程安全）
3. StringBuilder 字符串变量（非线程安全）

1. String类型是Java内的对象，是个不可变的对象，当每次对String进行改变时都需要生成一个新的String对象，然后将指针指向一个新的对象，如果在一个循环里面，不断的改变一个对象，就要不断的生成新的对象，而且对象多了，Java的垃圾自动回收机制会开始工作，所以效率很低，建议在不断更改String对象的地方不要使用String类型
2. StringBuffer 是个可变的对象，就是每次操作都是对对象本身进行操作，而不用生成新的对象，这样效率肯定就会有有很大的提高，在大部分情况下StringBuffer的效率要比String类型要高
3. StringBuilder 与StringBuffer一样是个可变的字符序列，提供与StringBuffer兼容的API，但是不能保证同步，用在字符串缓冲区被当个线程使用的情况，在单机非多线程的情况下使用StringBuilder会有比较好的效率，因为StringBuilder没有处理同步(Synchronized)问题。StringBuffer则会处理同步问题，如果StringBuilder会在多线程下被操作，则要改用StringBuffer，让对象自行管理同步问题。

注意点：
在使用StringBuffer时指定其容量，会比不指定其容量要快40%到50%左右，甚至比不指定容量的StringBuilder要快。所以在使用时最好指定其容量。这是一个良好的编程习惯，对于性能有很大的提升。

String常用方法:

StringBuilder和StringBuffer方法

1、追加字符串到Stringbuffer StringBuffer append(T t)
//这是Stringbuffer最神奇的地方，你参数不管是啥都转成字符，给你塞到stringbuffer后边 StringBuffer append(char[] str,int offset, int len) //追加一个指定开始位置和长度的字符数组
StringBuffer insert(int offset,T t) //插入和追加差不多，要注意的是在offset位置前插入
StringBuffer insert(int index, char[] str, int offset, int len)
注意：如果我们想把基本类型数组变成StringBuffer，我们应该for循环把元素append进Stringbuffer。

2、求StringBuffer长度 int capacity（）和int length（）是不同的，一个返回StringBuffer这个动态数组的长度，数组长度很可能大于等于字符数量；一个是返回其中包含的字符的数量

3、删除StringBuffer中的子串或字符 StringBuffer delete(int start，int end)
//删除start下标到end-1下标的所有字符 StringBuffer deleteCharAt(int index )
//删除指定下标的字符

4、StringBuffer反转 StringBuffer reverse( )

5、修改替换StringBuffer中的字符或子串 void setCharAt(int index，char ch )
void replace(int start，int end，String str )

6、查找子串位置（和String差不多） public int indexOf(String str) public int indexOf(String str, int fromIndex) public int lastIndexOf(String str） public int lastIndexOf(String str, int fromIndex)

7、提取子串（和String差不多） public String substring(int beginIndex) public String substring(int beginIndex, int endIndex)

30.说出一些常用的类，包，接口，请各举5个

答: 常用的类：
BufferedReader BufferedWriter FileReader FileWirter String Integer
常用的包：
java.lang java.awt java.io java.util java.sql
常用的接口：
Remote List Map Document NodeList

31.什么是线程同步 如何实现线程同步

答: 当使用多个线程来访问同一个数据时，非常容易出现线程安全问题(比如多个线程都在操作同一数据导致数据不一致),所以我们用同步机制来解决这些问题。
实现同步机制有两个方法：
1.同步代码块：
synchronized(同一个数据){} 同一个数据：就是N条线程同时访问一个数据。
2.同步方法：
public synchronized 数据返回类型 方法名(){}
就是使用 synchronized 来修饰某个方法，则该方法称为同步方法。对于同步方法而言，无需显示指定同步监视器，同步方法的同步监视器是 this 也就是该对象的本身（这里指的对象本身有点含糊，其实就是调用该同步方法的对象）通过使用同步方法，可非常方便的将某类变成线程安全的类，具有如下特征：
1，该类的对象可以被多个线程安全的访问。
2，每个线程调用该对象的任意方法之后，都将得到正确的结果。
3，每个线程调用该对象的任意方法之后，该对象状态依然保持合理状态。
注：synchronized关键字可以修饰方法，也可以修饰代码块，但不能修饰构造器，属性等。
实现同步机制注意以下几点： 安全性高，性能低，在多线程用。性能高，安全性低，在单线程用。
1，不要对线程安全类的所有方法都进行同步，只对那些会改变共享资源方法的进行同步。
2，如果可变类有两种运行环境，当线程环境和多线程环境则应该为该可变类提供两种版本：线程安全版本和线程不安全版本(没有同步方法和同步块)。在单线程中环境中，使用线程不安全版本以保证性能，在多线程中使用线程安全版本.

32.解释一下static关键字 被static修饰的方法 调用 静态/非静态函数的方法

答:

1. 静态方法
   通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法
   声明为static的方法有以下几条限制：
   · 它们仅能调用其他的static 方法。
   · 它们只能访问static数据。
   · 它们不能以任何方式引用this 或super。
2. 静态变量
   声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了
3. static代码块
   　　static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

33.堆区和栈区的区别

答: 栈区：先进后出 存放局部变量 连续的存储空间
堆区：存放new出来的对象，不连续的存储空间

34.&和&&的区别

答: &是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）

35.==Java支持的数据类型有哪些？什么是自动拆装箱？ ==

答: Java语言支持的8种基本数据类型是：
byte/short/int/long/float/double/boolean/char
自动装箱是Java编译器在基本数据类型和对应的对象包装类型之间做的一个转化。比如：把int转化成Integer，double转化成Double，等等。反之就是自动拆箱。

36.什么是多态

答: 面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。
多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
多态的作用：消除类型之间的耦合关系。
现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。
下面是多态存在的三个必要条件，要求大家做梦时都能背出来！
多态存在的三个必要条件
一、要有继承；
二、要有重写；
三、父类引用指向子类对象。

37.什么是继承，继承的特点？

子类继承父类的特征和行为，使得子类具有父类的各种属性和方法。或子类从父类继承方法，使得子类具有父类相同的行为。
特点：在继承关系中，父类更通用、子类更具体。父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己特殊的特征和行为。
在继承关系中。父类和子类需要满足is-a的关系。子类是父类。
表示父类和子类的术语：父类和子类、超类和子类、基类和派生类，他们表示的是同一个意思。
为什么需要继承？什么时候应该继承？
使用继承可以有效实现代码复用，避免重复代码的出现。
当两个类具有相同的特征（属性）和行为（方法）时，可以将相同的部分抽取出来放到一个类中作为父类，其它两个类继承这个父类。
继承实现了面向对象的原则：write once,only once（编写一次、且编写一次)
如何实现继承？
在Java语言中，用extends（扩展）关键字来表示一个类继承了另一个类。
在父类中只定义一些通用的属性和方法。
子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法。或子类重新定义父类的属性、重写父类的方法可以获得与父类不同的功能。
:

38.封装有什么好处？

答: 一是用private把类的细节与外界隔离起来，从而实现数据项和方法的隐藏，而要访问这些数据项和方法唯一的途径就是通过类本身，类才有资格调用它所拥有的资源（方法，数据项属性等等）。所以第一个好处就是数据的安全性提高了。
　　二是通过隐藏隔离，只允许外部对类做有限的访问，开发者可以自由的改变类的内部实现，而无需修改使用该类的那些程序。只要那些在类外部就能被调用的方法保持其外部特征不变，内部代码就可以自由改变，各取所需，利于分工。
　　三就是提高了代码的重用性，封装成工具类以后能够减少很多繁琐的步骤。

39.下列 java 程序输出结果为

int i=0;
Integer j = new Integer(0);
System.out.println(i==j);
System.out.println(j.equals(i));
A.true,false B.true,true
C.false,true D.false,false
答: B

40.下列java程序的输出结果为

public class Example{
String str=new String(“hello”);
char[]ch={‘a’,‘b’};
public static void main(String args[]){
Example ex=new Example();
ex.change(ex.str,ex.ch);
System.out.print(ex.str+" and ");
System.out.print(ex.ch);
}
public void change(String str,char ch[]){
str=“test ok”;
ch[0]=‘c’;
}
}
A.hello and ab B.hello and cb
C.hello and a D.test ok and ab
E.test ok and cb F.test ok and c
答: B

41.有关下述Java代码描述正确的选项是

public class TestClass {
private static void testMethod(){
System.out.println(“testMethod”);
}
public static void main(String[] args) {
((TestClass)null).testMethod();
}
}
A.编译不通过
B.编译通过，运行异常，报NullPointerException
C.编译通过，运行异常，报IllegalArgumentException
D.编译通过，运行异常，报NoSuchMethodException
E.编译通过，运行异常，报Exception
F.运行正常，输出testMethod
答: F

42.袋子中分别一叠纸币，其中5元面值的纸币6张，10元面值的纸币5张，20元面值的纸币4张，从袋子中任意取4张纸币，则每种面值至少取到一张的概率为____。

A.8/91 B.25/91 C.48/91
D.53/91 E.60/91 F.63/91
答: C

43. 有一个扔骰子得返现的游戏：你扔一个骰子，扔到多少就可以得到和点数相同的返现。例如你扔到3，可以得到3元返现；扔到1，可以得到1元返现。当你扔完第一次骰子，看到点数后，你需要做出如下选择：

1、拿这个点数对应的返现，放弃扔第二次骰子；
2、再扔一次骰子，但此时你只能拿第二次扔的点数对应的返现。
那么，玩一轮这个游戏的期望收益是____元。
A.3.5 B.3.75 C.4 D.4.25 E.4.5 F.4.75
答: D

44.在 java 中，一个类可同时定义为许多同名的方法，这些方法的形式参数个数，类型或顺序各不相同，传回的值可能个不相同，这种面向对象的特性称为（）

A.隐藏 B.覆盖 C.重载 D.无此特性
答: C

45.下列描述错误的是：（ ）

A.类不可以多重继承而接口可以
B.抽象类自身可以定义成员而接口不可以
C.抽象类和接口都不能被实例化
D.一个类可以有多个基类和多个基接口
答: D

46.对于abstract声明的类，下面说法正确的是

A.可以实例化 B.不可以被继承
C.子类为abstract D.只能被继承
E.可以被抽象类继承
答: E

47.方法通常存储在进程中的哪一区（）

A.堆区 B.栈区 C.全局区 D.代码区
答: 方法区

48.一个以”.java”为后缀的源文件

A.只能包含一个类，类名必须与文件名相同
B.只能包含与文件名相同的类以及其中的内部类
C.只能有一个与文件名相同的类，可以包含其他类
D.可以包含任意类
答: C

49.在 java 中 , 以下 _____ 类的对象以键 - 值的方式存储对象

A.java,util.List
B.java,util.ArrayList
C.java,util.HashMap
D.java,util.LinkedList
答: C

50.以下代码是在执行什么功能?

A.找到最大值 B.找到最小值
C.从大到小的排序 D.从小到大的排序
答: C

51.在运行时，由java解释器自动引入，而不用import语句引入的包是()。

A.java.lang B.java.system
C.java.io D.java.util
答: A

52.下列哪行代码有误

A.Line 3 and Line 4
B.Line 1 only
C.Line 3 only
D.Line 4 only
答: A

53.经过强制类型转换以后，变量a，b的值分别为多少？

short a =128； byte b =(byte) a；
A.128 127 B.128 - 128 C.128 128 D.编译错误
答: B

54.下列选项中关于Java中super关键字的说法正确的是（）

A.super关键字是在子类对象内部指代其父类对象的引用
B.super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C.子类通过super关键字只能调用父类的方法，而不能调用父类的属性
D.子类通过super关键字只能调用父类的属性，而不能调用父类的方法
答: A

55.代码System.out.println(10%3*2);将打印？

A.1 B.2 C.4 D.6
答: B

56.下面有关JVM内存，说法错误的是？

A.程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的
B.Java方法执行内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
C.方法区用于存储JVM加载的类信息、常量、静态变量、即使编译器编译后的代码等数据，是线程隔离的(正确答案为线程之间共享的)
D.原则上讲，所有的对象都在堆区上分配内存，是线程之间共享的
答: C

57.下面程序的输出结果是？

A.出错 B.342 C.34234 D.3423
答: D(先运行catch)

58.关于下面代码片段叙述正确的是（）

byte b1=1,b2=2,b3,b6; 
final byte b4=4,b5=6; 
b6=b4+b5; 
b3=(b1+b2); 
System.out.println(b3+b6); 

A.输出结果：13
B.语句：b6=b4+b5编译出错
C.语句：b3=b1+b2编译出错
D.运行期抛出异常
答: C(,加法计算结果为int,int转byte得强转)

59.给定以下JAVA代码，这段代码运行后输出的结果是（）

A.exception in main finished
B.finally finished
C.exception in main finally
D.finally exception in main finished
答: B

60.下面哪几个函数 public void example(){…} 的重载函数？（）

A.public void example(int m){…}
B.public int example(){…}
C.public void example2(){…}
D.public int example(int m,float f){…}
答: AD

61.有以下程序段， 则下面正确的选项是（）

A.编译失败
B.程序运行可能结果为： One.Theadtwo.Thread
C.程序运行可能结果是： One.two.ThreadThread
D.程序运行结果不稳定
答: BCD

62.已知如下类定义：

A.private void fun( int n ){ //…}
B.void fun ( int n ){ //… }
C.protected void fun ( int n ) { //… }
D.public void fun ( int n ) { //… }
答: D

63.在使用super 和this关键字时，以下描述正确的是（）

A.在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
B.super（）和this（）不一定要放在构造方法内第一行
C.this（）和super（）可以同时出现在一个构造函数中
D.this（）和super（）可以在static环境中使用，包括static方法和static语句块
答: A

64.以下关于集合类 ArrayList 、 LinkedList 、 HashMap 描述错误的是：

A.HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值
B.ArrayList和LinkedList均实现了List接口
C.添加和删除元素时，ArrayList的表现更佳
D.ArrayList的访问速度比LinkedList快
答: C

65.下列代码的执行结果是：（ ）

A.1和1 B.1和1.0
C.1.0和1 D.1.0和1.0
答: B
66.以下程序的输出结果为

A.BD B.DB C.C D.编译错误
答: D
67.A 派生出子类 B ， B 派生出子类 C ，并且在 java 源代码有如下声明：

1. A a0=new A();
2. A a1=new B();
3. A a2=new C();
   问以下哪个说法是正确的？（）
   A.只有第一行能通过编译
   B.第1、2行能通过编译，但第3行编译出错
   C.第1、2、3行能通过编译，但第2、3行运行时出错
   D.第1行，第2行和第3行的声明都是正确的
   答: D
   68.下面关于程序编译说法正确的是（）
   A.java语言是编译型语言，会把java程序编译成二进制机器指令直接运行
   B.java编译出来的目标文件与操作系统
   C.javascript是解释型语言，在运行时才进行翻译指令
   D.java编译出来的目标文件，可以运行在任意jvm上
   答: C
   69.list是一个ArrayList的对象，哪个选项的代码填到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？（）
   A.it.remove(); B.list.remove(obj);
   C.list.remove(index); D.list.remove(obj,index);
   答: A
   70.ArrayList和LinkList的描述，下面说法错误的是？
   A.LinkedeList和ArrayList都实现了List接口
   B.ArrayList是可改变大小的数组，而LinkedList是双向链接串列
   C.LinkedList不支持高效的随机元素访问
   D.在LinkedList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在ArrayList的中间插入或删除一个元素的开销是固定的
   答: D
   71.假设有以下代码String s = “hello”：String t = “hello”；char c [ ] = {‘h’,‘e’,‘l’,‘l’,‘o’}；下列选项中返回false的语句是？
   A.s.equals (t)；
   B.t.equals ©；
   C.s==t；
   D.t.equals (new String (“hello”))；
   答: B
   72.关于异常处理机制的叙述正确的是（）
   A.catch部分捕捉到异常情况时，才会执行finally部分
   B.当try区段的程序发生异常时，才会执行finally部分
   C.当try区段不论程序是否发生错误及捕捉到异常情况，都会执行finally部分
   D.以上都是
   答: C
   73.下面有关JDK中的包和他们的基本功能，描述错误的是？
   A.java.awt： 包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面
   B.java.io：　 包含提供多种输出输入功能的类
   C.java.lang： 包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET
   D.java.util：　 包含一些实用性的类
   答: C
   74.cnt的值是

A.cnt=5 B.cnt=2 C.cnt=3 D.cnt=6
答: A
75.下面所示的java代码，运行时，会产生（）类型的异常 int Arry_a[] = new int[10];
System.out.println(Arry_a[10]);
A.ArithmeticException
B.NullPointException
C.IOException
D.ArrayIndexOutOfBoundsException
答: D
76.下面代码的输出结果是什么？

A.3 B.123 C.1 D.12
答: D
77.下面不属于Object类中方法的是:
A.hashCode() B.finally() C.wait() D.toString()
答: B
78.下列哪些情况可以终止当前线程的运行？
A.当一个优先级高的线程进入就绪状态时
B.当该线程调用sleep()方法时
C.当创建一个新线程时
D.抛出一个异常时
答: D
79.对Collection和Collections描述正确的是
A.Collection是java.util下的类，它包含有各种有关集合操作的静态方法
B.Collection是java.util下的接口，它是各种集合结构的父接口
C.Collections是java.util下的接口，它是各种集合结构的父接口
D.Collections是java.util下的类，它包含有各种有关集合操作的静态方法
答: BD
80.java关于异常处理机制的叙述哪些正确
A.catch部分捕捉到异常情况时，才会执行finally部分
B.当try区段的程序发生异常时，才会执行catch区段的程序
C.在try区段不论程序是否发生错误及捕获到异常错误，都会执行finally部分
D.以上都是
答: BC
81.java中关于继承的描述正确的是（）
A.一个子类只能继承一个父类
B.子类可以继承父类的构造方法
C.继承具有传递性
D.父类一般具有通用性，子类更具体
答: ACD
82.欲构造ArrayList类的一个实例，此类继承了List接口，下列哪个方法是正确的？
A.ArrayList myList=new Object（）
B.List myList=new ArrayList()
C.ArrayList myList=new List()
D.List myList=new List()
答: B
83.假设有以下代码String s = “hello”：String t = “hello”；char c [ ] = {‘h’,‘e’,‘l’,‘l’,‘o’}；下列选项中返回false的语句是？
A.s.equals (t)； B.t.equals ©；
C.s==t； D.t.equals (new String (“hello”))；
答: B
84.下列关于构造函数的描述正确的是?
A.构造函数可以声明返回类型
B.构造函数不可以用private修饰
C.构造函数必须与类名相同
D.构造函数不能带参数
答: C
85.this代表了()的对象引用,super表示的是当前对象的()对象?
A.当前类 当前类 B.当前类的父类 当前类
C.当前类 当前类的父类 D.以上都不正确
答: C
86.有如下代码：请写出程序的输出结果。

A.432 B.531 C.421 D.523
答: B
87.下列哪一种叙述是正确的（ ）
A.abstract修饰符可修饰字段、方法和类
B.抽象方法的body部分必须用一对大括号{ }包住
C.声明抽象方法，大括号可有可无
D.声明抽象方法不可写出大括号
答: D
88.下列代码的输出结果是?

A.The program prints”0” B.The program prints”4”
C.The program prints”8” D.The program prints”12”
E.The code does not complete.
答: B
89.下面有关重载函数的说法中正确的是
A.重载函数必须具有不同的返回值类型
B.重载函数形参个数必须不同
C.重载函数必须有不同的形参列表
D.重载函数名可以不同
答: C
90.对文件名为Test.java的java代码描述正确的是()

A.输出：0000 B.输出：123
C.编译报错 D.输出：No name
答: C
91.以下哪些类是线程安全的（）
A.Vector B.HashMap
C.ArrayList D.StringBuffer E.Properties
答: ADE
92.根据下面的代码，String s = null;会抛出NullPointerException异常的有（）。
A.if( (s!=null) & (s.length()>0) ) B.if( (s!=null) && (s.length()>0) )
C.if( (s==null) | (s.length()0) ) D.if( (snull) || (s.length()==0) )
答: AC
93.如下Java语句 double x= 3.0; int y=5; x/=–y;执行后， x的值是（）
A.3 B.0.6 C.0.4 D.0.75
答: D
94.关于接口和抽象类，错误的是？
A.接口可以继承接口
B.抽象类可以实现(implements)接口，抽象类可以继承实体类，但前提是实体类必须有明确的构造函数
C.这两种说法不全对
D.这两种说法都对
答: D
95.输入流将数据从文件，标准输入或其他外部输入设备中加载道内存，在 java 中其对应于抽象类（）及其子类。
A.java.io.InputStream B.java.io.OutputStream
C.java.os.InputStream D.java.os.OutputStream
答: A
96.以下程序运行的结果为（）

A.run main B.main run C.main D.run E.不能确定
答: A
97.下列关于java 中的 wait()方法和 sleep()方法的区别描述错误的是？
A.wait()方法属于Object类，二sleep()属于Thread类
B.调用wait()方法的时候，线程会放弃对象锁
C.调用sleep()方法的过程中，线程不会释放对象锁
D.sleep()方法导致了程序暂停执行指定的时间，让出cpu给其他线程
答: D
98.Java中用正则表达式截取字符串中第一个出现的英文左括号之前的字符串。比如：北京市（海淀区）（朝阳区）（西城区），截取结果为：北京市。正则表达式为（）
A.".?(?=\()" B.".?(?=()"
C.".(?=\()" D.".(?=()"
答: A
99.A 派生出子类 B ， B 派生出子类 C ，并且在 java 源代码有如下声明：

1. A a0=new A();
2. A a1=new B();
3. A a2=new C();
   问以下哪个说法是正确的？（）
   A.只有第一行能通过编译
   B.第1、2行能通过编译，但第3行编译出错
   C.第1、2、3行能通过编译，但第2、3行运行时出错
   D.第1行，第2行和第3行的声明都是正确的
   答: D
   100.下列Java代码中的变量a、b、c分别在内存的____存储区存放。

A.堆区、堆区、堆区 B.堆区、栈区、堆区
C.堆区、栈区、栈区 D.堆区、堆区、栈区
E.静态区、栈区、堆区 F.静态区、栈区、栈区
答: C
101.请问运行主要的程序会打印出的是什么（）

A.2,2 B.2,3 C.3,2 D.3,3
答: C
102.以下代码在编译和运行过程中会出现什么情况

A.编译运行通过，输出结果是88
B.编译时错误，count变量定义的是私有变量
C.编译时错误，System.out.println方法被调用时test没有被初始化
D.编译和执行时没有输出结果
答: A
103.关于Java的异常处理机制的叙述哪些正确？
A.不论程序是否发生错误及捕捉到异常情况，都会执行finally部分
B.其他选项都不正确
C.当try区段的程序发生异常时，才会执行catch区段的程序
D.catch部分捕捉到异常情况时，才会执行finally部分
答: AC
104.在java中重写方法应遵循规则的包括（）
A.访问修饰符的限制一定要大于被重写方法的访问修饰符
B.可以有不同的访问修饰符
C.参数列表必须完全与被重写的方法相同
D.必须具有不同的参数列表
答: BC
105.关于私有访问控制符 private 修饰的成员变量，以下说法正确的是（）
A.可以三种类所引用：该类自身、与它在同一包中的其他类，在其他包中的该类的子类
B.可以被两种类访问和引用：该类本身、该类的所有子类
C.只能被该类自身所访问和修改
D.只能被同一个包中的类访问
答: C
106.对 Map 的用法，正确的有：
A.new java.util.Map().put(“key” , “value”) ;
B.new java.util.SortedMap().put(“key” , “value”) ;
C.new java.util.HashMap().put( null , null ) ;
D.new java.util.TreeMap().put( 0 , null ) ;
答: C D
107.设 int a,b,c; 执行表达式 a=b=1 ， a++ ， b+1 ， c=a+b-- 后， a,b 和 c 的值分别是
A.2,1,2 B.2,0,3 C.2,2,3 D.2,1,3
答: B
108…任意2n个整数，从其中选出n个整数，使得选出的n个整数和同剩下的n个整数之和的差最小。
答:

109.检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果。

答: 输出结果：goodandgbc

110 .编写函数扫描制定目录（包含各级目录）下所有文本文件（ .txt ），将扫描到的文件全路径以及文件大小记录到指定的文件中，返回扫描到的文件总数。
答: 先上个单线程，留待改进。
/*
* 总入口
* @param path
* @param list_filo
/
static void intScanTextFiles(String path,String list_filo){
StringBuffer result = new StringBuffer();
int count = scanFiles(path, list_filo,result);
writeResult(result, list_filo,count);
}
static int scanFiles(String path,String list_filo,StringBuffer result){
File file = new File(path);
File[] list = file.listFiles();
int count = 0;
for (File file2 : list) {
if(file2.isDirectory()){
count += scanFiles(file2.getAbsolutePath(), list_filo,result);
}
if(file2.isFile()&&isTxt(file2.getName())){
result.append(file2.getAbsolutePath()).append(" 字节数:");
result.append(file2.length()).append("\n");
count ++;
}
}
return count;
}
/*
* 写入结果
* @param result)
* @param list_filo
/
static void writeResult(StringBuffer result,String list_filo,int count){
File file = new File(list_filo);
File folder = file.getParentFile();
if (!folder.exists()) {// 判断文件夹是否存在,不存在就建立个目录
folder.mkdirs();
}
try {
if (!file.exists()) {
file.createNewFile();
}
PrintStream ps = new PrintStream(new FileOutputStream(file));
ps.println(result.toString());// 往文件里写入字符串
ps.print("扫描总数： "+count);
ps.close();
} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
} catch (IOException e) {
// TODO Auto-generated catch block
}
}
/*
* 判断是否为txt文件
* @param fileName
* @return
*/
static boolean isTxt(String fileName){
//扩展名格式：
if (fileName.lastIndexOf(".") >= 0) {
String extName = fileName.substring(fileName.lastIndexOf("."));
if(".TXT".equals(extName)||".txt".equals(extName)){
return true;
}
}
return false;
}
public static void main(String[] args) {
String path = “C:\Users\chen\Desktop\面试题”;
String result = “C:\Users\chen\Desktop\result.txt”;
ScanFile.intScanTextFiles(path, result);
}