Java面试题总结之Java基础(三)

1、JAVA 语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try 块中可以抛出异常吗？

答：Java 通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java 中，每个异常都是一个对象，它是Throwable 类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java 的异常处理是通过5 个关键词来实现的：try、catch、throw、throws 和finally。一般情况下是用try 来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理；try 用来指定一块预防所有“异常”的程序；catch 子句紧跟在try 块后面，用来指定你想要捕捉的“异常”的类型；throw 语句用来明确地抛出一个“异常”；throws 用来标明一个成员函数可能抛出的各种“异常”；Finally 为确保一段代码不管发生什么“异常”都被执行的一段代码；可以在一个成员函数调用的外面写一个try 语句，在这个成员函数内部写另一个try 语句保护其他代码。每当遇到一个try 语句，“异常”的框架就放到堆栈上面，直到所有的try 语句都完成。如果下一级的try 语句没有对某种“异常”进行处理，堆栈就会展开，直到遇到有处理这种“异常”的try 语句。

2、运行时异常与一般异常有何异同？

答：异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java 编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

3、说出一个你最常见到的runtime exception？

答：ArithmeticException, ArrayStoreException, BufferOverflowException,

BufferUnderflowException, CannotRedoException, CannotUndoException,

ClassCastException, CMMException, ConcurrentModificationException,

DOMException, EmptyStackException, IllegalArgumentException,

IllegalMonitorStateException, IllegalPathStateException,

IllegalStateException, ImagingOpException, IndexOutOfBoundsException,

MissingResourceException, NegativeArraySizeException,

NoSuchElementException, NullPointerException, ProfileDataException,

ProviderException, RasterFormatException, SecurityException,

SystemException, UndeclaredThrowableException,

UnmodifiableSetException, UnsupportedOperationException

4、final, finally, finalize 的区别?

答：final：修饰符（关键字）；如果一个类被声明为final，意味着它不能不能作为父类被继承，因此一个类不能既被声明为abstract的，又被声明为final 的；将变量或方法声明为final，可以保证它们在使用中不被改变；被声明为final 的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改；被声明为final 的方法也同样只能使用，不能重载。finally：异常处理时提供finally 块来执行任何清除操作。finalize：方法名；Java 技术允许使用finalize() 方法在垃圾收集器，将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时，对这个对象调用的。它是在Object 类中定义的，因此所有的类都继承了它。子类覆盖finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

5、类Example A 继承Exception，类ExampleB 继承Example A；

有如下代码片断：

try{

throw new ExampleB(“b”)；

}catch（ExampleA e）{

System.out.printfln（“ExampleA”）；

}catch（Exception e）{

System.out.printfln（“Exception”）；

}

输出的内容应该是：

A：ExampleA  B：Exception  C：b  D：无

答：输出为A。

6、介绍JAVA 中的Collection FrameWork(及如何写自己的数据结构)

答：Collection FrameWork 如下：

Collection

├List元素可以重复，有序(存入顺序和取出顺序一致)

│├LinkedList底层数据结构是链表，查询慢，增删快，线程不安全效率高。

│├ArrayList底层数据结构是数组，查询快，增删慢，线程不安全效率高。

│└Vector底层数据结构是数组，查询快，增删慢，线程安全效率低。

│ └Stack

└Set元素无序，不可以重复。

├HashSet线程不安全，存取速度快。

└TreeSet线程不安全，可以对Set集合中的元素进行排序。

Map

├Hashtable线程安全，速度快。底层是哈希表数据结构。是同步的。不允许null作为键，null作为值

├HashMap线程不安全，速度慢。底层也是哈希表数据结构。是不同步的。允许null作为键，null作为值。替代了Hashtable.

└WeakHashMap可以用来对Map集合中的键进行排序。

Collection 是最基本的集合接口，一个Collection 代表一组Object，即Collection 的元素（Elements）； Map 提供key 到value 的映射。

Collection 和 Collections的区别

Collection是集合类的上级接口，子接口主要有Set 和List、Map。

Collections是针对集合类的一个帮助类，提供了操作集合的工具方法：一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

7、你所知道的集合类都有哪些？主要方法有哪些？

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

8、说出ArrayList,Vector, LinkedList 的存储性能和特性？

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

9、Collection 和Collections 的区别？

答：Collection 是java.util 下的接口，它是各种集合的父接口，继承于它的接口主要有Set 和List；Collections 是个java.util 下的类，是针对集合的帮助类，提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

10、HashMap 和Hashtable 的区别?

答：二者都实现了Map 接口，是将惟一键映射到特定的值上；主要区别在于：

1)HashMap 没有排序，允许一个null 键和多个null 值,而Hashtable 不允许；

2)HashMap 把Hashtable 的contains 方法去掉了，改成containsvalue 和containsKey,因为contains 方法容易让人引起误解；

3)Hashtable 继承自Dictionary 类，HashMap 是Java1.2 引进的Map 接口的实现；

4)Hashtable 的方法是Synchronize 的，而HashMap 不是，在多个线程访问Hashtable 时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。Hashtable 和HashMap 采用的hash/rehash 算法大致一样，所以性能不会有很大的差异。

11、Arraylist 与Vector 区别？

答：就ArrayList 与Vector 主要从二方面来说：

1）同步性：Vector 是线程安全的（同步），而ArrayList 是线程序不安全的；

2）数据增长：当需要增长时,Vector 默认增长一倍，而ArrayList 却是一半。

12、List、Map、Set 三个接口，存取元素时，各有什么特点？

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

13、Set 里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

答：Set 里的元素是不能重复的，用equals ()方法来区分重复与否。覆盖equals()方法用来判断对象的内容是否相同，而”==”判断地址是否相等,用来决定引用值是否指向同一对象。

14、用程序给出随便大小的10 个数，序号为1-10，按从小到大顺序输出，并输出相应的序号。

答：代码如下：

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Random;

public class RandomSort {

      public static void printRandomBySort() {

             Random random = new Random(); // 创建随机数生成器

             List<Integer> list = new ArrayList<Integer>();

             // 生成10 个随机数，并放在集合list 中

             for (int i = 0; i < 10; i++) {

                    list.add(random.nextInt(1000));

             }

             Collections.sort(list); // 对集合中的元素进行排序

             //第一种输出方法

             Iterator<Integer> it = list.iterator();

             int count = 0;

             while (it.hasNext()) { // 顺序输出排序后集合中的元素

                    System.out.println(++count + ": " + it.next());

             }

             //第二种输出方法

             for (Integer integer : list) {

                    System.out.println(integer);

             }

      }

      public static void main(String[] args) {

             printRandomBySort();

      }

}

15、用JAVA 实现一种排序，JAVA 类实现序列化的方法？在COLLECTION 框架中，实现比较要实现什么样的接口？

答：用选择排序代码如下：

public class ChooseSort {

   private int[] array;

   private int length;

   public ChooseSort(int[] array) {

      this.array = array;

      this.length = array.length;

   }

   /**

    * 打印数组中的所有元素

    */

   public void display() {

      for (int i : array) {

        System.out.print(i + " ");

      }

      System.out.println();

   }

   /**

    * 选择排序算法

    */

   public void chooseSort() {

      for (int i = 0; i < length - 1; i++) {// 做第i趟排序

        int minIndex = i;

        for (int j = minIndex + 1; j < length; j++) {// 选最小的记录

           if (array[minIndex]>array[j]) {

              minIndex = j;// 记下目前找到的最小值所在的位置

           }

        }

        // 在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换

        if (i != minIndex) { // 交换a[i]和a[minIndex]

           int temp = array[i];

           array[i] = array[minIndex];

           array[minIndex] = temp;

        }

      }

   }

   public static void main(String[] args) {

      int[] array = { 100, 45, 36, 21, 17, 13, 7 };

      ChooseSort cs = new ChooseSort(array);

      System.out.println("排序前的数据为：");

      cs.display();

      cs.chooseSort();

      System.out.println("排序后的数据为：");

      cs.display();

   }

}

JAVA 类实现序例化的方法是实现java.io.Serializable 接口；Collection 框架中实现比较要实现Comparable 接口和Comparator 接口。

16、sleep() 和wait() 有什么区别?

答：sleep 是线程类（Thread）的方法，使此线程暂停执行并指定时间，把执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep 不会释放对象锁。wait 是Object 类的方法，对对象调用wait 方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify 方法（或notifyAll）后本线程才进入对象锁定池准备，获得对象锁进入运行状态。

17、当一个线程进入一个对象的一个synchronized 方法后，其它线程是否可进入此对象的其它方法?

答：其它线程只能访问该对象的其它非同步方法，同步方法则不能进入。

18、请说出你所知道的线程同步的方法。

答：wait():使一个线程处于等待状态，并且释放所持有的对象的lock；sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException 异常；notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM 确定唤醒哪个线程，而且不是按优先级；

notityAll():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们互相竞争。

19、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?

答：多线程有两种实现方法，分别是继承Thread 类与实现Runnable 接口,同步的实现方面有两种，分别是synchronized,wait 与notify。

20、同步和异步有何异同，在什么情况下使用他们？举例说明。

答：如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

21、启动一个线程是用run()还是start()?

答：启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM 调度并执行。这并不意味着线程就会立即运行。当cpu分配给它时间时，才开始执行run()方法(如果有的话)。start()是方法,它调用run()方法.而run()方法是你必须重写的. run()方法中包含的是线程的主体。

22、线程的基本概念、线程的基本状态以及状态之间的关系？

答：线程指在程序执行过程中，能够执行程序代码的一个执行单位，每个程序至少都有一个线程，也就是程序本身；Java 中的线程有四种状态分别是：运行、就绪、挂起、结束。

23、简述synchronized 和java.util.concurrent.locks.Lock 的异同？

答：相同点：Lock 能完成synchronized 所实现的所有功能；

不同点：Lock 有比synchronized 更精确的线程语义和更好的性能。synchronized 会自动释放锁，而Lock 一定要求程序员手工释放，并且必须在finally中释放。

24、java 中有几种方法可以实现一个线程？用什么关键字修饰同步方法?stop()和suspend()方法为何不推荐使用？

答：有两种实现方法，分别是继承Thread 类与实现Runnable 接口；用synchronized 关键字修饰同步方法；反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在；suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被“挂起”的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。故不应该使用suspend()，而应在自己的Thread 类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

25、设计4 个线程，其中两个线程每次对j 增加1，另两个线程对j 每次减少1；写出程序。

答：以下程序使用内部类实现线程，对j 增减的时候没有考虑顺序问题：

public class TestThread {

   private int j;

   public TestThread(int j) {

      this.j = j;

   }

//增加j
   private synchronized void inc() {

      j++;

      System.out.println(j + "--Inc--" + Thread.currentThread().getName());

   }

 //减少j

   private synchronized void dec() {

      j--;

      System.out.println(j + "--Dec--" + Thread.currentThread().getName());

   }

   public void run() {

      new Dec().start();

      new Thread(new Inc()).start();

      new Dec().start();

      new Thread(new Inc()).start();

   }

   class Dec extends Thread {

      public void run() {

        for (int i = 0; i < 100; i++) {

           dec();

        }

      }

   }

   class Inc implements Runnable {

      public void run() {

        for (int i = 0; i < 100; i++) {

           inc();

        }

      }

   }

   public static void main(String[] args) {

      new TestThread(5).run();

   }

}

26、什么是java 序列化，如何实现java 序列化？

答：序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题；序列化的实现：将需要被序列化的类实现Serializable 接口，该接口没有需实现的方法，implements Serializable 只是为了标注该对象是可被序列化的。

27、java 中有几种类型的流？JDK 为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？

答：字节流，字符流。字节流继承于InputStream、OutputStream，字符流继承于Reader、Writer。在java.io 包中还有许多其他的流，主要是为了提高性能和使用方便。

28、文件和目录（IO）操作：

1)如何列出某个目录下的所有文件？

2)如何列出某个目录下的所有子目录？

3)如何判断一个文件或目录是否存在？

4)如何读写文件？

答：1)示例代码如下:

File file = new File("e:");

      File[] files = file.listFiles();

      for (int i = 0; i < files.length; i++) {

        if (files[i].isFile())

           System.out.println(files[i]);

}

2)示例代码如下:

File file = new File("e:\\");

      File[] files = file.listFiles();

      for (int i = 0; i < files.length; i++) {

        if (files[i].isDirectory())

           System.out.println(files[i]);

  }

3)创建File 对象,调用其exsit()方法即可返回是否存在,如:

System.out.println(new File("d:\\t.txt").exists());

4)示例代码如下:

public class Test {

   public static void main(String[] args) throws IOException {

      // 读文件:

      FileInputStream fin = new FileInputStream("e:\\tt.txt");

      byte[] bs = new byte[100];

      while (true) {

        int len = fin.read(bs);

        if (len <= 0)

           break;

        System.out.print(new String(bs, 0, len));

      }

      fin.close();

      // 写文件:

      FileWriter fw = new FileWriter("e:\\test.txt");

      //System.getProperty("line.separator")相当于"/n"\n’ 这样写的话，剔除了平台无关性

      fw.write("hello world!" + System.getProperty("line.separator"));

      fw.write("你好！郑州！");

      fw.close();

   }

}

29、写一个方法,输入一个文件名和一个字符串,统计这个字符串在这个文件中出现的次数。

答：代码如下：

public static int countWords(String file, String find) throws Exception {

      int count = 0;

      Reader in = new FileReader(file);

      int c;

      while ((c = in.read()) != -1) {

        while (c == find.charAt(0)) {

           for (int i = 1; i < find.length(); i++) {

              c = in.read();

              if (c != find.charAt(i))

                 break;

              if (i == find.length() - 1)

                 count++;

           }

        }

      }

      return count;

}

30、Java 的通信编程，编程题(或问答)，用JAVA SOCKET 编程，读服务器几个字符，再写入本地显示？

答：Server 端程序:

import java.net.*;

import java.io.*;

public class Server {

   private ServerSocket ss;

   private Socket socket;

   private BufferedReader in;

   private PrintWriter out;

   public Server() {

      try {

        //创建 ServerSocket 对象（并绑定端口）

        ss = new ServerSocket(10000);

        while (true) {

           //调用 accept 方法，等待来自客户端的连接

           socket = ss.accept();

           String RemoteIP = socket.getInetAddress().getHostAddress();

           String RemotePort = ":" + socket.getLocalPort();

           System.out.println("A client come in!IP:" + RemoteIP + RemotePort);

           //调用 getXXXStream 方法，进行 I/O操作

           in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

           String line = in.readLine();

           System.out.println("Cleint send is :" + line);

           out = new PrintWriter(socket.getOutputStream(), true);

           out.println("Your Message Received!");

           out.close();

           in.close();

           //关闭 Socket

           socket.close();

        }

      } catch (IOException e) {

        out.println("wrong");

      }

   }

   public static void main(String[] args) {

      new Server();

   }

}

Client 端程序:

import java.io.*;

import java.net.*;

public class Client {

   Socket socket;

   BufferedReader in;

   PrintWriter out;

   public Client() {

      try {

        System.out.println("Try to Connect to 127.0.0.1:10000");

        //1.创建 Socket 对象，并连接服务器 （ip字符串,端口号）

        socket = new Socket("127.0.0.1", 10000);

        System.out.println("The Server Connected!");

        System.out.println("Please enter some Character:");

        BufferedReader line = new BufferedReader(new InputStreamReader(System.in));

        out = new PrintWriter(socket.getOutputStream(), true);

        out.println(line.readLine());

        //2.调用 getXXXStream 方法，进行 I/O操作

        in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

        System.out.println(in.readLine());

        out.close();

        in.close();

        //3、关闭 Socket

        socket.close();

      } catch (IOException e) {

        out.println("Wrong");

      }

   }

   public static void main(String[] args) {

      new Client();

   }

}