20145330第六周《Java学习笔记》

2021-12-23 07:39:45

20145330第六周《Java学习笔记》###

这周算是很忙碌的一周。因为第六周陆续很多实验都开始进行，开始要准备和预习的科目日渐增多，对Java分配的时间不知不觉就减少了，然而第十和十一章内容相对有很多，所以效率是一件很重要的事情。

第十章输入与输出

Java将输入输出抽象化为串流，数据有来源及目的地，衔接两者的是串流对象。
- 比喻来说，数据就好比水，串流就好比水管，通过水管的衔接，水由一端流向另一端
- 如果想要将数据从来源取出，可以使用输入串流。
- 如果想要将数据写入目的地，可以使用输出串流。
标准输入输出
- System.in：标准输入，默认关联到键盘(终端输入)
- System.out：标准输出，默认关联到显示器(终端输出)
- System.err：标准错误，默认关联到显示器(终端输出)
- 输入输出重定向：setIn，setOut，setErr
来源与目的都不知道的情况下，可以设计一个通用的dump()方法，如果要将某个文档读入并另存为另一个文档，则可以这么使用：



	import java.io.*;

	public class StreamIO {

    public static void dump(InputStream src, OutputStream dest)

            throws IOException {

        try (InputStream input = src; OutputStream output = dest) {

            byte[] data = new byte[1024];

            int length;

            while ((length = input.read(data)) != -1) {

                output.write(data, 0, length);

            }

        }

      }

	}



	import java.io.*;

	public class Copy {

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

        StreamIO.dump(

                new FileInputStream(args[0]),

                new FileOutputStream(args[1])

        );

      }

  	}

这个程序可以由命令行自变量指定读取的文档来源与写出的目的地
如果要从HTTP服务器读取某个网页，另存为文档，也可以使用这里设计的dump()方法，例如：



	import java.io.*;

	import java.net.URL;

	public class Download {

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

        URL url = new URL(args[0]);

        InputStream src = url.openStream();

        OutputStream dest = new FileOutputStream(args[1]);

        StreamIO.dump(src, dest);

    	}

	}

串流继承架构
- 标准输入输出
  - 可以使用system的setIn()方法指定InputStream实例，重新指定便准输入来源。



	import java.io.*;

	import java.util.*;

	public class StandardIn {

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

        System.setIn(new FileInputStream(args[0]));

        try (Scanner file = new Scanner(System.in)) {

            while (file.hasNextLine()) {

                System.out.println(file.nextLine());

            }

        }

      }

	}

- 除了 system.in 与 system.out 之外，还有个system.err 为PrintStream 实例，成为标准错误输出串流，它是用来立即显示错误信息。

FileInputStream与FileOutputStream
- FileInputStream是InputStream的子类，可以指定文件名创建实例，一旦创建文档就开启，接着就可以用来读取数据。
- FileOutputStream是OutputStream的子类，可以指定文件名创建实例，一旦创建文档就开启，接着就可以用来读出数据。
- FileInputStream与FileOutputStream在读取、写入文档时，是以字节为单位，通常会使用一些高阶类加以打包，进行一些高阶操作。
ByteArrayInputStream与ByteArrayOutputStream
- ByteArrayInputStream是InputStream的子类，可以指定byte数组创建实例，一旦创建就可将byte数组当作数据源进行读取。
- ByteArrayOutputStream同理
串流处理装饰器
- BufferedInputStream与BufferedOutputStream
  - BufferedInputStream与BufferedOutputStream主要在内部提供缓冲区功能，操作上与InputStream与OutputStream并没有太大差别。例如，改写前面的IO.dump()为BufferedIO.dump()方法：



	import java.io.*;

	public class BufferedIO {

    public static void dump(InputStream src, OutputStream dest)

            throws IOException {

        try(InputStream input = new BufferedInputStream(src);

            OutputStream output = new BufferedOutputStream(dest)) {

            byte[] data = new byte[1024];

            int length;

            while ((length = input.read(data)) != -1) {

                output.write(data, 0, length);

            }

        }

     }

	}

DataInputStream与DataOutputStream
- 实际应用例子，下面的Member类可以调用save()储存Member实例本身的数据：



	import java.io.*;

	public class Member {

    private String number;

    private String name;

    private int age;

    public Member(String number, String name, int age) {

        this.number = number;

        this.name = name;

        this.age = age;

    }

    public String getNumber() {

        return number;

    }

    public void setNumber(String number) {

        this.number = number;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    @Override

    public String toString() {

        return String.format("(%s, %s, %d)", number, name, age);

    }

    public void save() throws IOException {

        try(DataOutputStream output =

                    new DataOutputStream(new FileOutputStream(number))) {

            output.writeUTF(number);

            output.writeUTF(name);

            output.writeInt(age);

        }

    }

    public static Member load(String number) throws IOException {

        Member member;

        try(DataInputStream input =

                    new DataInputStream(new FileInputStream(number))) {

            member = new Member(

                    input.readUTF(), input.readUTF(), input.readInt());

        }

        return member;

   	 }

	}

ObjectInputStream与ObjectOutputStream
- ObjectInputStream提供readObject（）方法将数据读入为对象，ObjectOutputStream提供writeObject()方法将对象写至目的地
字符处理类
- Reader与Writer继承结构
  - 针对字符数据的读取，JavaSE提供了java.io.Reader类，其抽象化了字符数据读入的来源。
  - 针对字符数据的写入，JavaSE提供了java.io.Writer类，其抽象化了字符数据读入的目的地。
  - FileReader与FileWriter则可以对文档做读取与写入，读取或写入时默认会实用操作系统默认编码来做字符转换。



	import java.io.*;

		public class CharUtil {

    	public static void dump(Reader src, Writer dest) throws IOException {

        try(Reader input = src; Writer output = dest) {

            char[] data = new char[1024];

            int length;

            while((length = input.read(data)) != -1) {

                output.write(data, 0, length);

           		 }

        		}

    		}

		}

字符处理装饰器
- InputStreamReader与OutputStreamWriter
  - 串流处理的字节数据，实际上代表某些字符的编码数据
- BufferedReader与BufferedWriter
  - 可对Reader、Writer提供缓冲区作用，在处理字符输入输出时，对效率也会有所帮助
- PrintWriter
  - 除了可以对OutputStream打包之外，还可以对Writer进行打包，提供print()、printLn()、format()等方法。



	import java.io.*;

	public class CharUtil2 {

    public static void dump(Reader src, Writer dest) throws IOException {

        try(Reader input = src; Writer output = dest) {

            char[] data = new char[1024];

            int length;

            while((length = input.read(data)) != -1) {

                output.write(data, 0, length);

            }

        }

    }

    public static void dump(InputStream src, OutputStream dest,

                            String charset) throws IOException {

        dump(

                new InputStreamReader(src, charset),

                new OutputStreamWriter(dest, charset)

        );

    }

    //

    public static void dump(InputStream src, OutputStream dest)

            throws IOException {

        dump(src, dest, System.getProperty("file.encoding"));

    	}

	}

线程与并行API##

要让目前流程暂停指定时间，可以使用java.lang.Thread的静态sleep()方法，指定的单位是毫秒，调用这个方法必须处理java.lang.InterruptedException
Thread与Runnable
撰写多线程程序的方式：操作Runnable接口，在run（）中定义额外流程；继承Thread类，在run（）中定义额外流程；
差别：操作Runnable接口的好处就是较有弹性，类还有机会继承其他类；若继承了Thread类，那该类就是一种Thread，通常是为了直接利用Thread中定义的一些方法，才会继承Thread来操作。
如果主程序中启动了额外线程，默认会等待被启动的所有线程都执行完run（）方法才中止JVM。如果一个Thread被标示为Daemon线程，在所有的非Daemon线程都结束时，JVM自动就会终止。



	public class DaemonDemo {

    public static void main(String[] args) {

        Thread thread = new Thread(() -> {

            while (true) {

                System.out.println("Orz");

            }

        });

        // thread.setDaemon(true);

        thread.start();

    	}

	}

在调用Thread实例start（）方法后，基本状态为可执行（Runnable）、被阻断（Blocked）、执行中（Running）。
线程有其优先权，可使用Thread的setPriority（）方法设定优先权，可设定值为1到10，默认是5，超出1到10外的设定值会抛出IllegalArgumentException。数字越大优先权越高，排班器越优先排入CPU，如果优先权相同，则输流执行。
线程完成run（）方法后，就会进入Dead，进入Dead（或已经调用过start（）方法）的线程不可以再次调用start（）方法，否则会抛出IllegalArgumentException。
如果要停止线程，最好自行操作，让线程跑完应有的流程，而非调用Thread的stop（）方法。不仅停止线程必须自行根据条件操作，线程的暂停、重启，也必须视需求操作，而不是直接调用suspend（）、resume（）等方法。
每个线程产生时，都会归入某个线程群组，这视线程是在哪个群组中产生，如在main（）主流程中产生一个线程，该线程会属于main线程群组。如果没有指定，则归入产生该子线程的线程群组，也可以自行指定线程群组，线程一旦归入某个群组，就无法更换群组。
每个对象都会有个内部锁定，或称为监控锁定。被标示为synchronized的区块将会被监控，任何线程要执行synchronized区块都必须先取得指定的对象锁定。
如果在方法上标示synchronized，则执行方法必须取得该实例的锁定。synchronized不只可声明在方法上，也可以描述句方式使用。不正确的使用可能会造成死结。



	class Resource {

    private String name;

    private int resource;

    Resource(String name, int resource) {

        this.name = name;

        this.resource = resource;

    }

    String getName() {

        return name;

    }

    synchronized int doSome() {

        return ++resource;

    }

    synchronized void cooperate(Resource resource) {

        resource.doSome();

        System.out.printf("%s 整合 %s 的资源%n",

                this.name, resource.getName());

   		 }

	}

	public class DeadLockDemo {

    public static void main(String[] args) {

        Resource resource1 = new Resource("resource1", 10);

        Resource resource2 = new Resource("resource2", 20);

        Thread thread1 = new Thread(() -> {

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

                resource1.cooperate(resource2);

            }

        });

        Thread thread2 = new Thread(() -> {

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

                resource2.cooperate(resource1);

            }

        });

        thread1.start();

        thread2.start();

    }

}

Java的synchronized提供的是可重入同步，也就是线程取得某对象锁定后，若执行过程中又要执行synchronized，尝试取得锁定的对象又是同一个，则可以直接执行。
执行synchronized范围的程序代码期间，若调用锁定对象的wait（）方法，线程会释放对象锁定，并进入对象等待集合而处于阻断状态，其他线程可以竞争对象锁定，取得锁定的线程可以执行synchronized范围的程序代码。
放在等待集合的线程不会参与CPU排班，wait（）可以指定等待时间，时间到之后线程会再次加入排班，如果指定时间0或不指定，则线程会持续等待，直到被中断（调用interrupt（）或是告知notify（））可以参与排班。
在使用高级并行API时，Lock接口的操作对象可实现synchronized的功能。



	import java.util.Arrays;

	public class ArrayList {

    private Object[] list;

    private int next;

    public ArrayList(int capacity) {

        list = new Object[capacity];

    }

    public ArrayList() {

        this(16);

    }

    public void add(Object o) {

        if(next == list.length) {

            list = Arrays.copyOf(list, list.length * 2);

        }

        list[next++] = o;

    }

    public Object get(int index) {

        return list[index];

    }

    public int size() {

        return next;

    	}

	}

在使用高级并行API时，Condition接口的操作对象可实现Object的wait（）、notify（）、notifyAll（）功能。在使用高级并行API时，Future接口的操作对象可以让你在未来取得执行结果。

教材学习中的问题

撰写单线程序、多线程程序的方式差别：操作Runnable接口的好处就是较有弹性，类还有机会继承其他类；若继承了Thread类，那该类就是一种Thread，通常是为了直接利用Thread中定义的一些方法，才会继承Thread来操作。

代码托管截图

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	5000行	30篇	400小时
第一周	200/200	2/2	20/20
第二周	300/500	2/4	18/38
第三周	500/1000	3/7	22/60
第四周	300/1300	2/9	30/90
第五周	300/1600	1/10	20/110
第六周	250/1850	2/12	20/130

参考资料###

《Java学习笔记》

码农公寓

20145330第六周《Java学习笔记》###

第十章 输入与输出

线程与并行API##

教材学习中的问题

代码托管截图

学习进度条

参考资料###

相关文章

第十章输入与输出