点关注，不迷路；持续更新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 是最基本的集合接口，一个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 接口，是将惟一键映射到特定的值上；主要区别在于：

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

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

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

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

11、Arraylist 与Vector 区别？

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

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

• 数据增长：当需要增长时,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();
    }
}

写在最后

点关注，不迷路；持续更新Java架构相关技术及资讯热文！！！