20145223 《Java程序设计》第6周学习总结

教材学习内容总结

·Java中将数据从来源取出或是将数据写入目的地，使用输入、输出串流，其分别的代表对象为java.io.InputStream实例和java.io.OutputStream实例

·在不使用InputStream或者OutputStream实例的时候必须使用close()方法关闭串流。

FileInputStream fileInputStream =
                new FileInputStream(new File(args[0]));
            FileOutputStream fileOutputStream =
                new FileOutputStream(new File(args[1]));
            …
            fileInputStream.close();
            fileOutputStream.close();
while(true) {
                if(fileInputStream.available() < 1024) {
                    //剩余的资料比1024字节少
                    //一位一位读出再写入目标文件
                    int remain = -1;
                    while((remain = fileInputStream.read())
                                           != -1) {
                        fileOutputStream.write(remain);
                    }
                    break;
                }
                else {
                    //从来源档案读取数据至缓冲区
                    fileInputStream.read(buffer);
                    //将数组数据写入目标文件
                    fileOutputStream.write(buffer);
                }
            }

·FileInputStream是InputStream的子类，可指定文件名创建实例，文档创建后就可以直接读取数据。FileOutputStream是OutputStream的子类，同样可指定文件名创建实例读取数据。但是以上两者在不使用的时候也同样需要使用close()方法关闭文档。

·File实例用作一个档案或目录的抽象表示

            File file = new File(args[0]);
            if(file.isFile()) { //是否为档案
                System.out.println(args[0] + "檔案");
                System.out.print(
                      file.canRead() ?"可读" :"不可读");
                System.out.print(
                      file.canWrite() ?"可写" :"不可写");
                System.out.println(
                      file.length() +"位組");
            }
            else {
                //列出所有的档案及目录
                File[] files = file.listFiles();
                ArrayList<File> fileList =
                                    new ArrayList<File>();
                for(int i = 0; i < files.length; i++) {
                    //先列出目录
                    if(files[i].isDirectory()) {//是否为目录
                        //取得路径名
                        System.out.println("[" +
                                files[i].getPath() + "]");
                    }
                    else {
                        //档案先存入fileList，待会再列出
                        fileList.add(files[i]);
                    }
                }
                //列出档案
                for(File f: fileList) {
                    System.out.println(f.toString());
                }
                System.out.println();
            }

·ByteArrayStream是InputStream的子类，可指定byte数组创建实例，创建后可将byte数组当做数据源进行数据的读取。（与此类似的还有OutputStream的子类ByteArrayOutStream）

·InputStream、OutS太热门提供串流基本操作。想要为输入或者输出的数据进行打包处理，可以使用打包器类。

·FileReader、FileWriter可以对文档做读写和写入，同时默认使用操作系统默认的编码进行编码的转换。

·想要存取的是一个文本文件，可直接使用java.io.FileReader、java.io.FileWriter类别

            FileReader fileReader =
                new FileReader(args[0]);
            FileWriter fileWriter =
                new FileWriter(args[0] + ".txt");
            int in = 0;
            char[] wlnChar = {'\r', '\n'};
            while((in = fileReader.read()) != -1) {
                if(in == '\n') {
                    //写入"\r\n"
                    fileWriter.write(wlnChar);
                }
                else
                    fileWriter.write(in);
            }
            fileReader.close();
            fileWriter.close();

·想要目前流程暂停操作时间，可使用java.lang.Thread的静态sleep()方法，指定单位是毫秒，调用这个方法必须处理java.lang.InterruptedException。

·如果您的类别已经要继承某个类别，那么您就不能继承Thread类别

·继承了Thread类别，您就不能再继承其它类别

·实作java.lang.Runnable接口来定义具线程功能的类别

·Runnable接口中定义一个run()方法要实作

·在实例化一个Thread对象时，可以传入一个实作Runnable接口的对象作为自变量

·简单的继承Thread的例子：

public class EraserThreadextends Thread {
    private boolean active;
    private String mask;
    …
    //重新定义run()方法
    public void run () {
        while(isActive()) {
            System.out.print(mask);
	     try {
                //暂停目前的线程50毫秒
	Thread.currentThread().sleep(50);
             }
             catch(InterruptedException e) {
                 e.printStackTrace();
             }
        }
    }
}
//启动Eraser线程
            EraserThread eraserThread = new EraserThread('#');
            eraserThread.start();
            String password = scanner.next();
            eraserThread.setActive(false);

·Runable

public class EraserimplementsRunnable { //实作Runnable
    private boolean active;
    private String mask;
   …
    //重新定义run()方法
    public void run () {
        while(isActive()) {
            System.out.print(mask);
	     try {
                //暂停目前的线程50毫秒
	Thread.currentThread().sleep(50);
             }
             catch(InterruptedException e) {
                 e.printStackTrace();
             }
        }
    }
}
            //Eraser实作Runnable界面
            Eraser eraser = new Eraser('#');
            //启动Eraser线程
            Thread eraserThread = new Thread(eraser);
            eraserThread.start();
            String password = scanner.next();
            eraser.setActive(false);

·进入Blocked状态，以下的几个对应情况让线程回到Runnable状态

--输入输出完成

--呼叫interrupt()

--取得对象锁定

--呼叫notify()或notifyAll()

        Thread thread = new Thread(new Runnable() {
            public void run() {
                try {
                    //暂停99999毫秒
                    Thread.sleep(99999);
                }
                catch(InterruptedException e) {
                    System.out.println("I'm interrupted!!");
                }
             }
        });
      thread.start();
      thread.interrupt(); // interrupt it right now

·线程完成run()方法，就会进入Dead，进入（或者已经调用过start()方法）的线程，不可以再次调用start()方法，否则会抛出错误。

·如果要停止线程，最好自行操作，让程序走完应有流程，而不是调用syop()方法

·wait()、notify()与notifyAll()是由Object类别所提供的方法

·当物件的wait()方法被调用，目前的线程会被放入对象的等待池中，线程归还对象的锁定

public synchronized void setProduct(int product) {
        if(this.product != -1) {
            try {
                //目前店员没有空间收产品，请稍候！
                wait();
            }
            catch(InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.product = product;
        System.out.printf("生产者设定(%d)%n", this.product);
        //通知等待区中的一个消费者可以继续工作了
        notify();
    }
    public synchronized int getProduct() {
        if(this.product == -1) {
            try {
                //缺货了，请稍候！
                wait();
            }
            catch(InterruptedException e) {
                e.printStackTrace();
            }
        }
        int p = this.product;
        System.out.printf("消费者取走(%d)%n", this.product);
        this.product = -1; //取走产品，-1表示目前店员手上无产品
        //通知等待区中的一个生产者可以继续工作了
        notify();
        return p;
    }

教材学习中的问题和解决过程

·如果一个对象所持有的数据可以被多线程同时共享存取时，您必须考虑到「数据同步」的问题

·数据同步指的是两份数据整体性、一致性

·在学习的过程中，数据的不同步而可能引发的错误通常不易察觉，可能是在程序执行了几千几万次之后，才会发生错误。网上对于同步化有这样一个说法，这通常会发生在您的产品已经上线之后，甚至是程序已经执行了几年之后。

·所以，在程序一开始进行编译的过程中就要对同步化问题加以重视。

其他（感悟、思考等，可选）

随着往后的学习，我觉得java的内容越来越抽象和难以理解，很多时候你知道是这个一个东西，但是你不一定知道它是用来做什么的，在使用它的过程中应该注意些什么问题，甚至会和其他概念搞混。所以越往后，我觉得我投入java 的时间应该逐渐变多，不然书上的知识就很难完全消化理解了，也没有充足的时间进行动手实践了。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	4000行	20篇	400小时
第一周	200/200	1/1	15/12
第二周	180/380	1/1	18/12
第三周	600/980	1/1	17/16
第四周	400/380	1/1	16/15
第五周	300/680	1/1	14/14
第六周	200/200	2/2	10/10

代码托管截图

参考资料