Java基础周测-06

一、单选题

1、启动多线程的方式是调用如下哪一个方法

A.start 
B.do   
C.run   
D.sleep

参考答案：A

 

2、哪个关键字可以对对象加锁

A.transient  
B.synchronized  
C.serialize 
D.static

参考答案：B

 

3、以下哪个方法用于定义线程的执行体

A.start() 
B.init() 
C.run() 
D.synchronized()

参考答案：C

 

4、线程通过（ ）方法可以休眠一段时间，然后恢复运行

A.run 
B.setPrority         
C.yield         
D.sleep

参考答案：D

 

5、运行在操作系统上的每个应用都会独占一个独立的

A.线程  
B.进程   
C.thread   
D.Runnable

参考答案：B

 

6、请问wait()方法在以下哪个代码中被调用

A.一个while()循环体中        
B.run方法中        
C.同步化代码块中        
D.代码的任何地方

参考答案：C

 

7、下列流中那个使用了缓冲区技术

A.BufferedOutputStream    
B.FileInputStream
C.FileOutputStream    
D.FileReader

参考答案：A

 

8、与InputStream流相对应的Java系统的标准输入对象是

A.System.in    
B.System.out    
C.System.err    
D.System.exit()

参考答案：A

 

9、以下通过哪个类对象可以实现从文件读取数据

A.FileWriter   
B.FileOutputStream  
C.BufferedWriter   
D.FileInputStream

参考答案：D

 

10、为了从文本文件中逐行读取内容，应该使用哪个处理流对象

A.BufferedReader    
B.BufferedWriter    
C.BufferedInputStream    
D.BufferedOutputStream

参考答案：A

 

11、使用Java IO流实现对文本文件的读写过程中，需要处理下列哪个异常

A.ClassNotFoundException
B.IOException
C.SQLException
D.RemoteException

参考答案：B

 

12、从InputStream对象中如何创建一个Reader对象

A.使用InputStream类中定义的createReader()方法   
B.用Reader类中的createReader()方法   
C.构造一个InputStreamReader实例，将InputStream对象作为InputStreamReader类构造器的参数传入   
D.构造一个OutputStreamWriter实例，将InputStream对象作为OutputStreamWriter类构造器 的参数传入

参考答案：C

 

二、多选题

1、以下关于ThreadLocal的作用描述正确的是

A、 ThreadLocal用来解决多线程程序的并发

B、 多线程类需要继承ThreadLocal类;

C、 多线程类需要实现ThreadLocal接口

D、 ThreadLocal为每个使用该变量的线程提供独立的变量副本

参考答案：A D

 

2、有三种原因可以导致线程不能运行，它们是

A.等待        
B.阻塞        
C.休眠        
D.挂起及由于I/O操作而阻塞 

参考答案：A B C

 

3、关于sleep()和wait()，以下描述正确的是

A.sleep是线程类Thread的方法，wait是Object类的方法；
B.sleep不释放对象锁，wait释放对象锁；
C.sleep暂停线程、但监控状态仍然保持，结束后会自动恢复；
D.wait后进入等待队列，只有针对此对象发出notify方法后获得对象锁进入运行状态。   可运行状态

参考答案：A B C

 

4、有关线程的哪些描述是正确的

A.一旦一个线程被创建，它就立即开始运行
B.使用 start() 方法可以使一个线程成为可运行的，但是它不一定立即开始运行
C.一个线程可能因为yield的原因停止，进入可运行状态
D.当一个线程因为wait而停止运行时，它被放在锁池队列       等待队列

参考答案：B C

 

5、以下哪几种是Java实现多线程的方式

A.Thread类       
B.Runnable类        
C.Runnable接口
D.Thread接口

参考答案：A C

 

6、能指定字符编码的I/O流类型是

A.Reader       
B.InputStreamReader        
C.BufferedReader
D.OutputStreamWriter

参考答案：B D 

 

7、下列哪些选项的内容可以作为 FileInputStream 类构造方法的参数

A.File    
B.String    
C.InputStream        
D.FileOutPutStream

参考答案：A B

 

7、以下哪几个是字节流

A.InputStream       
B.OutputStream        
C.Read
D.Write

参考答案：A B

 

8、在java中，被看作为输出流的选项是

A.OutputStream     
B.Reader        
C.InputStream        
D.Writer

参考答案：A D

三、判断题

1、当时用IO流操作文件之后不需要关闭流，因为jvm会协助关闭的（×）

2、从内存往外部设备写数据，称为输出。把数据读到内存中，称为输入（√）

3、ByteArrayInutStream 和 ByteArrayOutputStream 对内存中的字节数组进行读写操作，属于字节流（√）

4、实现 Serializable 接口的可以被序列化和反序列化。该接口中没有定义抽象方法，也没有定义常量（√）

5、序列化是指将字节序列转换成 Java 对象，实现了Serializable或者Externalizable接口的类的对象才可以被序列化（×）

6、RandomAccessFile类提供有删除磁盘文件的方法（×）File类提供

7、Java流的方向是先进先出的方式（√）

8、线程使用sleep方法去休眠后可以使用notify方法唤醒（×）      interrupt 中断异常

9、线程使用sleep方法休眠是会释放该线程同步锁定的对象（×）

10、线程可以用yield方法使低优先级的线程运行（×）

11、一个线程在调用它的 start() 方法之前，该线程将一直处于新建状态（√）

12、一个线程可以调用 yield() 方法使其他线程有机会运行（√）

13、如果线程终止，它便不能运行（√）

14、Thread的Stop()方法是终止当前线程，已经过时，不推荐使用（√）

15、在Java中，高优先级的可运行线程会抢占低优先级线程（√）    抢占：更大的机会，不一定

 

四、编程题

1、Student类有姓名年龄（省略）

     //完成Student对象序列化 到文件//完成从文件中反序列化Student对象并打印

import java.io.*;

public class StudentTest {
    public static void main(String[] args) {
        writeStudent();
        readStudent();
    }

    //完成Student对象序列化到文件
    private static void writeStudent() {
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
        try {
            //实例化FileOutputStream
            fos = new FileOutputStream("student.dat");
            //实例化ObjectOutputStream
            oos = new ObjectOutputStream(fos);
            //实例化Student
            Student s = new Student("jack", 20);
            //ObjectOutputStream 将Person对象写入流中
            oos.writeObject(s);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            try {
                if (oos != null) {
                    oos.close();
                }
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //完成从文件中反序列化Student对象并打印
    private static void readStudent() {
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            //实例化FileInputStream
            fis = new FileInputStream("student.dat");
            //实例化ObjectInputStream对象
            ois = new ObjectInputStream(fis);
            //readObject 从流中读取数据转换成Student
            Student s = (Student) ois.readObject();
            //打印
            System.out.println(s);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            try {
                if (ois != null) {
                    ois.close();
                }
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2、写两个线程，⼀个线程打印1~52，另⼀个线程打印A~Z，打印顺序是12A34B56C78D.........4748X4950Y5152Z

public class TwoThread {
    public static void main(String args[]) {
        //必须new了一个MyObject1对象，不能new2个
        MyObject1 my = new MyObject1();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 26; i++) {
                    my.printNum();
                }
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 26; i++) {
                    my.printA();
                }
            }

        }).start();
    }
}

class MyObject1 {
    //标记
    private static boolean flag = true;
    public int count = 1;

    //synchronized锁住this，只new了一个MyObject1对象所以this是全局的
    public synchronized void printNum() {
        while (!flag) {/*false*/
            try {
                //线程等待
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.print((2 * count - 1));/*1*/ /*3*/
        System.out.print(2 * count);/*2*/ /*4*/

        flag = false;
        this.notify();
    }

    //synchronized锁住this，只new了一个MyObject1对象所以this是全局的
    public synchronized void printA() {
        while (flag) {/*true*/
            try {
                //线程等待
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.print((char) (count + 'A' - 1));
        count++;
        flag = true;
        this.notify();
    }
}
/*
先打印数字
数字、字母 交替

控制顺序：
wait等待
notify唤醒 

数字输出：12...34...56...78...    
public int count = 1;
System.out.print((2 * count - 1));//1    //3     //5    ...
System.out.print(2 * count);      //2    //4     //6    ...
*/