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

时间  2019-12-05
标签 java 面试 总结 基础 栏目 Java 繁體版
原文   原文链接

 

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

答：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();

        //三、关闭 Socket

        socket.close();

      } catch (IOException e) {

        out.println("Wrong");

      }

   }

 

   public static void main(String[] args) {

      new Client();

   }

}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程