20155207王雪纯 2016-2017-2 《Java程序设计》第六周学习总结

20155207 2016-2017-2 《Java程序设计》第六周学习总结

教材学习内容总结

第10章 输入/输出

10.1

InputStream

与

OutputStream

10.1.1 串流设计概念

数据从来源取出，使用输入串流，代表对象为

java.io.InputStream

实例，将数据写入目的地，使用输出串流，代表对象为

java.io.OutputStream

InputStream

和

OutputStream

可以用自动关闭资源语法关闭

InputStream

的

read()

方法，每次会尝试读入

byte

数组长度的数据，并返回实际读入的字节

FileInputStream

是

InputStream

的子类，用于衔接文档以读入数据，

FileInputStream

同理，指定文档来源与写出目的地可用于将文档读入并另存为另一个文档

从HTTP服务器读取某个网页，并另存为文档，使用

java.net.URL

,指定网址，

URL

实例会自动进行HTTP协议，使用

openStream()

方法取得

InputStream

实例

10.1.2 串流继承架构

标准输入/输出

System.in

与

System.out

分别是

InputStream

和

OutputStream

的实例

可以使用

System

的

setIn()

方法指定

InputStream

实例，重新指定标准输入来源

标准输出可以重新导向至文档，只要执行程序时使用 > 将结果导向至指定的文档，使用 >> 则是附加信息

可以使用

System

的

setOut()

方法指定

PrintStream

实例，将结果输出至指定的目的地

System.setErr()

为

PrintSteam

实例，用来显示错误信息，输出的信息一定会显示在文本模式中，也可以使用

System.setErr()

指定

PrintStream

重新指定标准错误输出串流

FileInputStream

与

FileOutputStream

FileInputStream

是

InputStream

的子类，可以指定文件名创建实例，一旦创建文档就开启可以读取数据

同理，

FileOutputStream

是

OutputStream

的子类，指定文件名来创建实例，一旦创建文档就开启，接着就可以用来写出数据,不用时都要用

close()

关闭文档

在读取、写入文档时，以字节为单位

ByteArrayInputStream

与

ByteArrayOutStream

ByteArrayInputStream

是

InputStream

的子类，可以指定

byte

数组创建实例，一旦创建就将

byte

数组当作数据源进行读取，同理，

ByteArrayOutputStream

将

byte

数组当作目的地写出数据

10.1.3 串流处理装饰器

为输入/输出的数据做处理，可以使用打包器类

装饰器：这些类并没有改变

InputStream

和

OutputStream

行为，只不过在取得数据或者要输出时做一些处理

BufferedInputStream

与

BufferedOutputStream

提供缓冲区功能，主要在内部提供缓冲区功能，操作上与

InputStream

、

OutputStream

没有太大区别

创建

BufferedInputStream

和

BufferedOutputStream

必须提供

InputStream

和

OutputStream

进行打包，可以使用默认或自定义缓冲区大小

DataInptStream

与

DataOutputStream

提供读入、写入Java基本数据类型的方法，会自动在指定的类型与字节间转换

根据不同的类型使用

writexxx()

或

readxxx()

方法

ObjectInputStream

与

objectOutputStream

将内存中的对象整个存储下来，之后再读入还原为对象

ObjectInputStream

提供

readObject()

方法将数据读入对象，

objectOutputStream

提供

writeObject()

方法将对象写至目的地，可以被这两个方法操作的对象，必须操作

java.io.Serializable

接口（无定义方法接口，作标示之用，表示对象可串化）

10.2 字符处理类

10.2.1

Reader

与

Writer

继承架构

java.io.Reader

类和

java.io.Writer

类分别抽象化了字符数据读入的来源和写出的目的地

可以使用尝试自动关闭资源语法

FileReader

是一种

Reader

,主要用于读取文档并将读到的数据转换成字符，

StringWriter

是一种

Writer

可以将数据写至

StringWriter

，使用

toString()

方法取得字符串，代表所有写入的字符数据

10.2.2 字符处理装饰器

InputStreamReader

与

OutputStreamWriter

将字节数据转换为对应的编码字符，使用

InputStreamReader

与

OutputStreamWriter

对串流数据打包

可以指定编码，没有指定编码就用默认编码做字符转换

BufferedReader

与

BufferredWriter

为

Reader

、

Writer

提供缓冲区作用

readLine()

方法，可以读取一行数据并以字符串返回（不包括换行字符）

System.in

是

InputStream

实例，可以指定给

InputStreamReader

创建之用，

InputStreamReader

是一种

Reader

，可指定给

BufferedReader

创建之用

InputStreamReader

将

System.in

读入的字节数据做编码转换，

BufferedReader

将编码转换后的数据做缓冲处理

printWriter

PrintWriter

与

PrintStream

使用上类似，除了可以对

OutputStream

打包之外，还可以对

Writer

进行打包，提供

prinnt()

、

println()

、

format()

等方法

第11章 线程与并行API

11.1 线程

11.1.1 线程简介

如果想在

main()

以外独立建立流程，可以撰写类操作

java.lang.Runnable

接口，流程的进入点是操作在

run()

方法中

从

main()

开始的流程会由主线程执行，创建

Thread

实例来执行

runnable

实例定义的

run()

方法

启动线程执行指定流程，必须要调用

Thread

实例的

start()

11.1.2

Thread

与

Runnable

撰写多线程的程序的方式

将流程定义在

Runnable

的

run()

方法中

继承

Thread

类，重新定义

ru()

方法

操作

Runnable

接口有弹性，还有机会继承别的类

继承了

Thread

类，通常为了直接利用

Thread

中定义的一些方法

11.1.3 线程生命周期

Daemon

线程

一个

Thread

被标示为

Daemon

线程，在所有非

Daemon

线程都结束时，JVM自动终止

使用

setDaemon()

方法来设定一个线程是否为

Deamon

线程

使用

isDaemon()

方法判断线程是否为

Deamon

线程

默认所有从

Deamon

线程产生的线程也是

Deamon

线程

Thread

基本状态图

使用

Thread

的

setpriority()

方法设定优先权，1-10（

Thread MIN_PRIORITY

-

Thread MAX_PRIORITY

）,默认值是5（

Thread NORM_PRIORITY

）

让线程进入

Blocked

状态，调用

Thread.sleep()

等方法，等待输入/输出

线程因输入/输出进入

Blocked

状态，在完成输入/输出后，会回到

runnable

状态

进入

Blocked

状态的线程，可以由另一个线程调用该线程的

interrupt()

方法，让他离开

Blocked

状态

安插线程

join()

将线程加入另一线程的流程中

停止线程

线程完成

run()

方法后，会进入

Dead

，进入

Dead

的线程不可以再次调用

start()

方法

停止线程最好自行操作，让线程跑完应有的流程

11.1.4 关于

ThreadGroup

线程一旦归入某个群组，就无法更换

java.lang.ThreadGroup

可以管理群组中的线程

interrupt()

方法可以中断群组中的所有线程

setMaxpriority()

方法可以设定群组中所有线程最大优先权

enumerate()

方法可以一次取得群组中所有线程

activeCount()

方法取得群组的线程数量

uncaughtException()

方法处理某个线程未被捕捉的异常

11.1.5

synchronized

与

volatile

使用

synchronized

被标示为

synchronized

的区块将会被监控，任何线程要执行该区块必须先取得指定的对象锁定

线程尝试执行

synchronized

区块而进入

Blocked

，在取得锁定之后，会先回到

Runnable

状态，等待排入

Runnning

状态

死结：有些资源在多线程下彼此交叉取用

使用

volatile

synchronized

要求达到的所标示区块的互斥性（

synchronized

区块同时间只能有一个线程）与可见性（线程离开

synchronized

区块后，另一线程接触到的就是上一线程改变后的对象状态）

使用

volatile

达到变量范围

在变量上声明

volatile

，表示变量是不稳定、易变的，可能在多线程下存取，保证变量的可见性

11.1.6 等待与通知

调用锁定对象的

wait()

方法，线程释放对象锁定，进入对象等待集合处于阻断状态（不参与CPU排班），其他线程竞争对象锁定执行

synchronized

范围的程序代码

wait()

可以指定等待时间，时间到之后线程自动加入排班，指定时间为0或不指定，线程会继续等待，直到被中断

调用

notify()

,会从对象等待集合中随机通知一个线程加入排班，被通知的线程会与其他线程共同竞争对象锁定

调用

notifyAll()

会通知等待集合中的线程全部参加排班，这些线程会与其他线程共同竞争对象锁定

11.2 并行API

11.2.1

Lock

、

ReadWriteLock

和

Condition

使用

Lock

Lock

接口主要操作类之一为

ReentranLock

,可以达到

synchronized

的作用，也提供额外的功能

锁定

Lock

对象，调用其

lock()

方法，解除锁定，调用

unlock()

方法

trylock()

方法，取得锁定返回

true

，没取得锁定返回

false

使用

ReadWriteLock

ReadWriteLock

接口定义了读取锁定与写入锁定的行为，

ReentrantReadWriteLock

是

ReadWriteLock

接口的主要操作类

使用

StampedeLock

ReadWriteLock

在没有任何读取或写入锁定时，才可以取得写入锁定，可用于悲观读取

StampeedLock

支持乐观读取操作

使用

Condition

Condition

接口用来搭配

Lock

，最基本用法就是达到

Object

的

wait()

、

notify()

、

notifyAll()

方法的作用

调用

Lock

的

newCondition()

取得

Condition

操作对象

调用

Lock

的

await()

将会使线程进入

Condition

的等待集合

调用

signal()

方法通知等待集合中的一个线程，

signalAll()

方法通知所有等待集合中的线程

11.2.2 使用

Executor

java.util.concurrent.Executor

接口，将

Runnable

的制定与实际执行分离，定义了

execute()

方法

使用

ThreadPoolExecutor

（线程池）

定义在

java.util.concurrent.ExecutorService

，需要线程池的功能，可以使用其子类

java.util.concurrent.ThreadPoolExecutor

ExecutorService

的

shutdown()

方法会指定执行的

Runnable

都完成后啊，将

ExcutorService

关闭，

shutdownNow()

方法可以立即关闭

ExcutorService

使用

ScheduledThreadPoolExecutor

ScheduledExecutorService

为

ExecutorService

子接口，进行工作排成，

schedule()

方法用来排定

Runnable

或

Callable

实例延迟多久后执行一次，并返回

Future

子接口

ScheduleFuture

的实例，对于重复性的执行，可使用

scheduleWithFixedDelay()

与

scheduleAtfixedRate()

方法

scheduleWithFixedDelay()

可安排延迟多久首次执行

Runnable

，执行完会排定延迟多久再次执行，

scheduleAtfixedRate()

依据指定周期排定每次执行的时间，了两种方法上次排定的工作抛出异常，不会影响下次排程的进行

使用

ForkJoinPool

继承

Recursivetask

，主要是将子任务的分解与求解过程撰写于

compute()

方法中

11.2.3 并行

Collection

简介

CopyOnWriteArrayList

操作了

List

接口，复制数组

CopyOnWriteArraySet

操作了

Set

接口，适用于很少写入数据，但是迭代器频繁的情况

BlockingQueue

是

Queue

的子接口，新定义了

put()

和

take()

等方法，调用

put()

方法，在队列已满的情况下会被阻断，调用

take

方法，在队列为空的情况下会被阻断

使用

BlockingQueue

的操作

ArrayBlockingQueue

类，就不用处理

wait()

、

notify()

等流程

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

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

StringReader可以将字符串打包，当做读取来源，StringWriter可以作为写入目的地，最后toString（）取得所有写入的字符组成的字符串。CharArrayReader、CharArrayWriter类似，将char数组当做读取来源以及写入目的地。

代码调试中的问题和解决过程

存档IDEA程序时，再次打开无法运行，只能重新新建一个项目，因为打开时候默认的方式没有通过JDK

[代码托管]## [代码托管]

代码提交过程截图：

运行 git log --pretty=format:"%h - %an, %cd : %s" 并截图

代码量截图：



运行 find src -name "*.java" | xargs cat | grep -v ^$ | wc -l 并截图



CH06判断：可以用父类声明对象引用，用子类生成对象，但需要强制类型转换。（X）

CH06填空：写出编译P165 RPG.java的命令（javac –d . *.java）

结对及互评

评分标准

正确使用Markdown语法（加1分）：

不使用Markdown不加分

有语法错误的不加分（链接打不开，表格不对，列表不正确...）

排版混乱的不加分

模板中的要素齐全（加1分）

缺少“教材学习中的问题和解决过程”的不加分

缺少“代码调试中的问题和解决过程”的不加分

代码托管不能打开的不加分

缺少“结对及互评”的不能打开的不加分

缺少“上周考试错题总结”的不能加分

缺少“进度条”的不能加分

缺少“参考资料”的不能加分

教材学习中的问题和解决过程, 一个问题加1分

代码调试中的问题和解决过程, 一个问题加1分

本周有效代码超过300分行的（加2分）

一周提交次数少于20次的不加分

其他加分：

周五前发博客的加1分

感想，体会不假大空的加1分

排版精美的加一分

进度条中记录学习时间与改进情况的加1分

有动手写新代码的加1分

课后选择题有验证的加1分

代码Commit Message规范的加1分

错题学习深入的加1分

点评认真，能指出博客和代码中的问题的加1分

结对学习情况真实可信的加1分

扣分：

有抄袭的扣至0分

代码作弊的扣至0分

迟交作业的扣至0分

错题

3． import java.util.*;

4． class ForInTest {

5.static List list=new ArrayList();

6．

7.public static void main (String [] args) {

8.list. add("a")； list. add("b");list. add( "c")；

9． //insert code here

System.out.print (o)；

}

12． }

哪一行插入到第9行将导致输出“abc"？

A .

for (Iterator o : list.iterator()； o.hasNext (); )

B .

for (Iterator o : list)

C .

for (Object o : list.iterator())

D .

for (Object o ： list)

答案：D

下列哪些项是泛型的优点？ （选两项）

A .

不用向下强制类型转换

B .

代码容易编写

C .

类型安全

D .

运行速度快

答案：AD

点评模板：

博客中值得学习的或问题：

代码中值得学习的或问题：

问题：InputStream、Reader与Writer区别

解决过程：Writer针对于字符数据写入，Reader针对于字符数据的读取，InputStream针对于串流输入

基于评分标准，我给本博客打分：XX分。得分情况如下：

基于评分标准，我给本博客打分：10分。得分情况如下：

正确使用Markdown语法（加1分）：

模板中的要素齐全（加1分）

教材学习中的问题和解决过程, 加1分

代码调试中的问题和解决过程, 加1分

本周有效代码超过300分行，加2分

6 其他加分 ：

进度条中记录学习时间与改进情况的加1分

感想，体会不假大空的加1分

代码Commit Message规范的加1分

结对学习情况真实可信的加1分

参考示例

点评过的同学博客和代码

本周结对学习情况

20155223

结对照片

结对学习内容

XXXX

XXXX

...

上周博客互评情况

20155224

20155208

20155237

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

Java学习笔记的学习已经进行了一半以上，这期间总是跟着书敲代码，看知识点也是一扫而过，现在应该将重点放在实践上，注重应用，才能真正将这门课学会

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第一周	0/0	2/2	20/20
第二周	186/186	2/4	18/38
第三周	689/875	3/7	22/60
第四周	242/1117	2/9	30/90
第五周	698/1815	2/9	30/120
第六周	1269/3084	2/9	30/120

参考：软件工程软件的估计为什么这么难，软件工程 估计方法

计划学习时间:25小时

实际学习时间:25小时

改进情况：

(有空多看看现代软件工程 课件

软件工程师能力自我评价表)

参考资料

Java学习笔记(第8版)

《Java学习笔记(第8版)》学习指导