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

教材学习内容总结

第十章

串流设计

Java将输入/输出抽象化为串流，数据有来源及目的地，衔接两者的是串流对象。
输入串流代表对象为java.io.Inputstream实例，输出串流代表对象为java.io.OutputStream实例。
在进行InputStream与OutStream的相关操作时若发生错误，会抛出java.io.IOException异常，在dump()方法上声明throws，由调用``dump()```方法的客户端处理。
InputStream的read()方法，每次都会尝试读入byte数组的长度的数据，并返回事迹读入的字节，可以使用OutputStream的wirte()方法，指定要写出的byte数组，初始索引与数组长度。

串流继承架构

可以使用System的setIn()方法指定InputStream实例，重新指定标准输入来源。
标准输出，可以重新导向至文档，只要执行程序时使用>将输出结果导向至指定文档，使用>>是附加信息。可以使用System的setOut()方法指定printStream实例，将结果输出至指定的目的地。
System.err：标准错误输出串流，立即显示错误信息。无法重新导向。
FileInputStream是InputStream的子类，可以指定文件名创建实例，一旦创建文档就开启，接着就可用来读取数据。
FileOutputStream是OutputStream的子类，可以指定文件名创建实例，一旦创建文档就开启，接着就可以用来写出数据。
ByteArryInputStream是InputStrteam的子类，可以指定byte数组创建实例，一旦创建就可将byte数组当做数据源进行读取。
ByteArryOutputStream是OutputStream的子类，可以指定byte数组创建实例，一旦创建将byte数组当做目的地写出数据。

串流处理装饰器

InputStream、OutputStream提供串流基本操作，如果想要为输入/输出的数据做加工处理，则可以使用打包器类。
BufferedOutputStream与BufferedInputStream：具备缓冲区作用，可以默认或自定义缓冲区大小。
DataInputStream与DataOutputStream：具备数据转换处理功能，自动在指定的类型与字节间转换。
ObjectInputStream、ObjectOutputStream:具备对象串行化能力。
接口没有定义任何方法，只是作为表示之用，表示这个对象是可以串行化的。如果在作对象串行化的时候，对象中的某些数据成员不希望被写出，可以表上transient关键字。

字符处理类

Reader与Writer继承架构

针对字符数据的读取，JavaSE提供了java.io.Reader类，其抽象化了字符数据读入的来源。
针对字符数据的写入，则提供了java.io.Writer类。其抽象化了数据写出的目的地。
FileReader与FileWriter：读取与写入文档并将数据转换为字符，默认会使用操作系统默认编码来做字符转换。
StringReader与StringWriter：将字符串打包，当作读取来源与写入目的地。
CharArrayReader与CharArrayWriter：将char数组当作读取来源与写入目的地。

字符处理装饰器

想要将这些字节数据转换为对应的编码字符，可以使用InputStreamReader、OutputStreamWriter对串流数据打包。
BufferedReader、BufferedWriter可对Reader、Writer提供缓冲区作用，在处理字符输入/输出时，对效率也会有所帮助。
PrintWriter还可以对Writer进行打包，提供print()、println()、format()等方法。

第十一章

线程

线程简介

多线程程序即程序拥有多个流程。
在java中，如果想在main()以外独立设计流程，可以撰写类操作java.lang.Runnable()接口，流程的进入点是操作在run()方法中。从main()开始的流程会由主线程执行，run()方法可以创建Thread实例来执行。启动额外线程执行指定流程，必须调用Thread实例的start()方法。

Thread与Runnable

如果想要为JVM加装CPU，就是创建Thread实例，要启动额外CPU就是调用Thread实例的start()方法，额外CPU执行流程的进入点，可以定义在Runnale接口的run()方法中。
操作Runnable接口的好处就是较有弹性，你的类还有机会继承其他类。若继承了Thread，那该类就是一种Thread，通常是为了直接利用Thread中定义的一些方法，才会继承Thread来操作。

线程生命周期

Daemon线程:主线程会从main()方法开始执行，直到main()方法结束后停止JVM。如果主线程中启动了额外线程，默认会等待被启动的所有线程都执行完run()方法才中止JVM。如果一个Thread被标示为Daemon线程，在所有的非Daemon线程都结束时，JVM自动就会终止。
Thread基本状态图：用Thread实例start()方法后，基本状态为可执行（Runnable）、被阻断（Blocked）、执行中（Running）。使用Thread.sleep()会让线程进入Bocked状态。
安插线程：当线程使用join()加入至另一个线程时，另一个线程会等待被加入的线程工作完毕，然后在继续它的动作，join()的意思表示将线程加入称为另一个线程的流程中。
停止线程：线程完成run()方法后，就会进入Dead，进入Dead的线程不可以再次调用start()方法，否则会抛出IllegalThreadStateException异常。

关于ThreadGroup

每个线程都属于某个线程群组。
ThreadGroup中interrupt()方法可以中断群组中所有线程，setMaxPriority()方法可以设定群组中所有线程最大优先权，activeCount()方法获取群组的线程数量。 enumerate()方法可以一次取得群组中所有线程；uncaughtException()方法第一个参数可取得发生异常的线程实例，第二个参数可取得异常对象。
未捕捉异常会由线程实例setUncaughtExceptionHandler()设定的Thread.UncaughtExceptionHandler实例处理之后是线程ThreadGroup，然后是默认的Thread.UncaughtExceptionHandler。

synchronized与volatile

不具备线程安全的类：线程存取同一对象相同资源时可能引起竞速情况的类。
被标示为synchronized的区块将会被监控，任何线程要执行synchronize区块都必须先取得指定的对象锁定。由于线程无法取得锁定时会造成阻断，不正确地使用synchronize有可能造成效能低下，另一个问题则是死结。
在变量上声明volatile，标示变量是不稳定、易变的，也就是可能在多线程下存取。被标示为volatile的变量，不允许线程快取，变量值的存取一定是在共享内存中进行。volatile保证的是单一变数的可见性，线程对变量的存取一定是在共享内存中，不会在自己的内存空间中快取变量，线程对共享内存中变量的存取，另一线程一定看得到。

等待与通知

调用锁定对象的wait()方法,线程会释放对象锁定，并进入对象等待集合而处于阻断状态，其他线程可以竞争对象锁定，取得锁定的线程可以执行synchronize区块的代码。
调用锁定对象的notify()方法,从对象等待集合中随机通知一个线程加入排班，再次执行synchronize前，被通知的其他线程共同竞争对象锁定。
调用锁定对象的notifyAll()方法,所有等待集合中的线程都会被通知参与排班，这些线程会与其他线程共同竞争对象锁定。

并行API

Lock、ReadWriteLock与Condition

1.使用Lock

lock接口主要操作类之一为ReentrantLock，可以达到synchronized的作用。
Lock接口还定义了tryLock()方法，如果线程调用tryLock()可以取得锁定会返回true，若无法取得锁定并不会发生阻断，而是返回false。

2.ReadWriteLock
ReadWriteLock接口定义了读取锁定与写入锁定行为，可以使用readLock()、writeLock()方法返回Lock操作对象。

3.使用StampedLock
StampedLock类可支持了乐观读取操作。

4.使用Condition
Condition接口用来搭配Lock，最基本用法就是达到Object的wait()、notify()、notifyAll()方法的作用。Condition的await()、signal()、signalAll()方法，可视为Object的wait()、notify()、notifyAll()方法的对应。

使用Excutor

1.使用ThreadPoolExecutor

定义了java.util.concurrent.Executor接口，目的是将Runnable指定与实际执行分离。
通常会使用java.util.concurrent.Executors的newCachedThreadPool()、newFixedTheadPool()静态方法来创建ThreadExecutor实例。

2.使用ScheduledThreadPoolExecutor
ScheduledExecutorService为ExecutorService的子接口，schedule()方法用来排定Runnable或Callable实例延迟多久后执行一次，并返回Future子接口ScheduledFuture的实例，对于重复性的执行，可使用scheduleWithFixedDelay()和scheduleAtFixedRate()方法。

3.使用ForkJoinPool
ForkJoinPool与其他的ExecutorService操作不同的地方在于，它是闲聊了工作窃取演算，其建立的线程如果完成手边任务，会尝试寻找并执行其他任务建立的资额任务，让线程保持忙碌状态，有效利用处理器的能力。ForkJoin框架适用于计算密集式的任务，较不适合用于容易造成线程阻断的场合。

并行Collection简介

CopyOnWriteArrayList操作了List接口，这个类的实例在写入操作时，内部会建立新数组，并复制原有数组索引的参考，然后在新数组上进行写入操作，写入完成后，再将内部原参考旧数组的变量参考至新数组。
CopyOnWriteArraySet操作了Set接口。
BlockedQueue是Queue的子接口，新定义了put()、take()方法。
ConcurrentMap是Map的子接口。
ConcurrentHashMap是ConcurrentMap的操作类，ConcurrentNavigableMap是ConcurrentMap的子接口，其操作类为ConcurrentSkipListMap，可视为支持并行操作的TreeMap版本。

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

问题1：BufferedInputStream与DataInputStream都是FilterInputStream的子类，那两者有何异同呢？
问题1解决方案：上网搜索得到如下答案：DataInputSteam:可以读输入流基本类型的操作，比如readInt(),readDouble(),readLong()...

BufferedInputStream避免每次都物理得读取,告诉从缓冲区读,和FileInputSteam等InputStream子类联合使用(非FileterInputStream).且FilterInputStream(InputStream in) 这个方法是protected 的，无法在不属于它的子类或者同包类访问。

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

问题1：在学习使用Lock时，学习书上的代码，总是会出现如下所示的错误。

编译后还会出现如下所示的错误

问题1解决方案：研究提示的错误，发现在该包中之前练习的代码中有定义相同的类，因此把其中一个的雷鸣改掉，编译通过，如下

代码托管

上周考试错题总结

输入"cd"命令并按回车键后,将会出现什么情况?

答：从当前目录切换到用户主目录。
现有：

list是一个合法的集合引用getCollection()返回一个合法集合的引用

哪个是合法的？

A .

or(Object o ； list)

B .

for(Object o : getCollection())

C .

for(Object o : list.iterator())

D .

for(lterator i ; list.iterator() ; i.hasNext () )

E .

for(lterator i=list.iterator(); i.hasNext (); )

答：选B与E，没有认真审题，这是道多选题。

Which of the following methods will not compile?

A .private void method1(String name) {

if (name.equals("star"))

throw new IllegalArgumentException(name);

}

B .private void method2(int age) {

if (age > 30)

throw Exception();

}

C .public double method5() throws Exception {

return 0.7;

}

D .protected double method4() throws Exception {

throw new Throwable();

}

答：选B、D。

现有：

    1．  class Propeller2  {

    2.   pulolic static void main (String[]args)／／add code here?

    3.    {  new Propeller2().topGo();  }

    4．

    5.void topGo()  ／／add code here?

    6．    {   middleGo()；  }

    7．

    8.void middleGo()  ／／add code here?

    9.    {   go();  System.out.println ("late middle");  }

    10．

    11． void go()  ／／add code here?

    12.    {throw new Exception();  }

    13.  }

为使代码通过编译，需要在哪一行加入声明throws Exception?

答：在第2行、第5行、第8行和第11行。

现有

 1. class Calc {

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

 3.    try {

 4.         int x = Integer.parselnt ("42a") ;

 5.     //insert code here

 6.         System.out.print ("oops");

 7.    }

 8.   }

 9. }

下面哪行分别插入到第五行，会导致输 "oops" ?

A .

catch (IllegalArgumentException e) {

B .

} catch (IllegalStateException c) {

C .

} catch (NumbelFormatException n) {

D .

} catch (ClassCastException c) {

答：选A、C。

在方法的声明中，要求该方法必须抛出异常时使用哪个关键字？

答：throws

throw与throws的区别如下：

区别一: throw是语句抛出一个异常；throws是方法抛出一个异常；

区别二: throws可以单独使用,但throw不能；

区别三:throws E1,E2,E3只是告诉程序这个方法可能会抛出这个异常,方法的调用者可能要处理这些异常.而这些异常E1

E2,E3可能是由函数体产生的.

而throw是明确之外这个地方要抛出这个异常。

可参考博客链接。
下列属于非受检异常的是哪项？

答：OutOfMemoryError

非受检异常指的是java.lang.RuntimeException和java.lang.Error类及其子类。

    1.abstract class Color  {

    2.protected abstract  String getRGB();

    3.  }

    4．

    5. public class Blue extends Color  {

    6．    ／／insert code here

    7.  }

和四个声明：

```public String getRGB()  {  return "blue";  }```

```String getRGB()  {  return  "blue";  )```

```private  String getRGB()  {  return  "blue";  }```

```protected String getRGB()  {  return "blue";  )```

分别插入到第6行，有几个可以通过编译？

答：两个，对于这道题，我觉得应该有三个是可以通过编译的，但是答案只有两个。

结对及互评

评分标准

正确使用Markdown语法（加1分）：
- 不使用Markdown不加分
- 有语法错误的不加分（链接打不开，表格不对，列表不正确...）
- 排版混乱的不加分
模板中的要素齐全（加1分）
- 缺少“教材学习中的问题和解决过程”的不加分
- 缺少“代码调试中的问题和解决过程”的不加分
- 代码托管不能打开的不加分
- 缺少“结对及互评”的不能打开的不加分
- 缺少“上周考试错题总结”的不能加分
- 缺少“进度条”的不能加分
- 缺少“参考资料”的不能加分
教材学习中的问题和解决过程, 一个问题加1分
代码调试中的问题和解决过程, 一个问题加1分
本周有效代码超过300分行的（加2分）
- 一周提交次数少于20次的不加分
其他加分：
- 周五前发博客的加1分
- 感想，体会不假大空的加1分
- 排版精美的加一分
- 进度条中记录学习时间与改进情况的加1分
- 有动手写新代码的加1分
- 课后选择题有验证的加1分
- 代码Commit Message规范的加1分
- 错题学习深入的加1分
- 点评认真，能指出博客和代码中的问题的加1分
- 结对学习情况真实可信的加1分
扣分：
- 有抄袭的扣至0分
- 代码作弊的扣至0分
- 迟交作业的扣至0分

点评模板：

博客中值得学习的或问题：
- xxx
- xxx
- ...
代码中值得学习的或问题：
- xxx
- xxx
- ...
基于评分标准，我给本博客打分：XX分。得分情况如下：xxx
参考示例

点评过的同学博客和代码

本周结对学习情况
- 20155306
- 结对照片
- 结对学习内容
  
  一起学习了第十章、第十一章的内容。
上周博客互评情况
- 20155233
- 20155302
- 20155333
- 20155230

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

随着对java学习的深入，慢慢的学习的内容变得越来越难，同时更加需要与已经学习的知识相互关联，因此找到适合自己的学习方法极为重要，希望在日后的学习中可以更好地找到适合自己的学习方法。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）
目标	5000行	30篇	400小时
第一周	20/20	1/4	20/20
第二周	145/165	1/5	12/32
第三周	411/576	1/6	16/48
第四周	1021/1597	1/7	25/73
第五周	1115/2712	1/8	28/103
第六周	1126/3838	1/9	20/123

尝试一下记录「计划学习时间」和「实际学习时间」，到期末看看能不能改进自己的计划能力。这个工作学习中很重要，也很有用。

耗时估计的公式

：Y=X+X/N ，Y=X-X/N，训练次数多了，X、Y就接近了。

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

计划学习时间:24小时
实际学习时间:20小时
改进情况：

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

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

巴特西

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

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

教材学习内容总结

第十章

串流设计

串流继承架构

串流处理装饰器

字符处理类

Reader与Writer继承架构

字符处理装饰器

第十一章

线程

线程简介

Thread与Runnable

线程生命周期

关于ThreadGroup

synchronized与volatile

等待与通知

并行API

Lock、ReadWriteLock与Condition

使用Excutor

并行Collection简介

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

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

代码托管

上周考试错题总结

结对及互评

评分标准

点评模板：

点评过的同学博客和代码

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

学习进度条

参考资料

最新文章

热门文章