20145201 《Java程序设计》第五周学习总结

教材学习内容总结

本周学习了课本第八、九章内容，即异常处理、Collection与Map。

第八章 异常处理

8.1 语法与集成架构

8.1.1 使用try、catch

• Java中所有错误都会被打包为对象，可以尝试（try）捕捉（catch）代表错误的对象后做一些处理。

代码如下：

import java.util.*;

public class Average2{
    public static void main(String[] args}{
       try
       {
           Scanner console = new Scanner(System.in);
           double sum = 0;
           int count = 0;
           while (true)
           {
               int number = console.nextInt();
               if (number ==0)
               {
                   break;
               }
               sum += number;
               count++;
           }
           System.out.printf("平均 %.2f%n",sum / count);
       }
       catch (InputMismatchException ex)
       {
           System.out.println("必须输入整数");
       }
    }
}

• JVM 会尝试执行 try 区块中的程序代码。如果发生错误，执行流程会跳离错误发生点，然后比较 catch 括号中声明的类型，是否符合被抛出的错误对象类型，如果是的话，就执行catch 区块中的程序代码。

• 有时错误可以在捕捉处理之后，尝试恢复程序正常执行流程。
  代码如下：

import java.util.*;
public class Average3 {
    public static void main(String[] args) {
            Scanner console = new Scanner(System.in);
            double sum = 0;
            int count = 0;
            while (true) {
                try {
                    int number = console.nextInt();
                    if (number == 0) {
                        break;
                    }
                    sum += number;
                    count++;
                } catch (InputMismatchException ex) {
                    System.out.printf("略过非整数输入:%s%n", console.next());
                }
            }
            System.out.printf("平均 %.2f%n", sum/count);
    }
}

8.1.2 异常继承架构

• 错误会被包装成对象，这些对象都是可抛出的（throw），因此设计错误对象都继承自java.lang.Throwable类，Throwable定义了取得错误信息、堆栈追踪等方法，它有两个子类java.long.Error与java.lang.Exception。

• Error与其子类实例代表严重系统错误（硬件层面错误，JVM错误或内存不足等），不建议用try、catch来处理Error对象。

• 程序设计本身的错误，建议使用Exception或其子类实例可以表现，通常称错误处理为“异常处理”

• 如果某个方法声明会抛出Throwable或子类实例。只要不是属于Error、java.lang.RuntimeException或其子类实例，就必须使用try、catch语法处理，或用throws声明这个方法会抛出异常，否则会编译失败。

• 受检异常：Exception或其子对象，但不属于RuntimeException或其子对象

• 非受检异常：属于RuntimeException衍生出的类实例，API客户端应该在调用方法前做好检查，以避免引发叙错误，因为编译程序不会强迫一定在语法上加以处理，亦称为非受检异常。

代码如下：

import java.util.Scanner;
public class Average4 {
    public static void main(String[] args) {
        double sum = 0;
        int count = 0;
        while(true){
            int number = nextInt();
            if(number ==0){
                break;
            }
            sum += number;
            count++;
        }
        System.out.printf("平均 %.2f%n",sum / count);
    }
    static Scanner console = new Scanner(System.in);
    static int nextInt(){
        String input = console.next();
        while(!input.matches("\\d*")){
            System.out.println("请输入数字");
            input = console.next();
        }
        return Integer.parseInt(input);
    }
}

• 实际上在异常发生时，可使用try、catch处理当时环境可进行的异常处理，当时环境下无法决定如何处理的部分，可以抛出由调用方法的客户端处理。如果想先处理部分事项再抛出，可以如下：

import java.io.*;
import java.util.Scanner;
public class FileUtil {
    public static String readFile(String name) throws FileNotFoundException{
        StringBuilder text = new StringBuilder();
        try{
            Scanner console = new Scanner (new FileInputStream(name));
            while(console.hasNext()){
                text.append(console.nextLine())
                        .append('\n');
            }
        }catch(FileNotFoundException ex){
            ex.printStackTrace();
            throw ex;
        }
        return text.toString();
    }
}

• 在catch区块进行完部分错误处理之后，可以使用throw（注意不是throws）将异常再抛出。

• 如果抛出的是受检异常，表示你认为客户端有能力且应该处理异常，此时必须在方法上使用throws声明；如果抛出的异常是非受检异常，表示你认为客户端调用方法的时机错了，抛出异常是要求客户端修正这个漏洞再来调用方法，此时也就不用throws声明。

• 如果使用继承时，父类某个方法声明throws某些异常，子类重新定义该方法时可以：

不声明throws任何异常。

throws父类该方法中声明的某些异常。

throws父类该方法中声明异常的子类。

但是不可以：

throws父类方法中未声明的其他异常。

throws父类方法中声明异常的父类。

8.1.3
Java是唯一采用受检异常的语言，这有两个目的：一是文件化；二是提供编译程序信息。

8.1.5

查看堆栈追踪最简单的方法，就是直接调用异常对象的printStackTrace().
代码如下：

public class StackTraceDemo {
    public static void main(String[] args) {
        try{
            c();
        }catch(NullPointerException ex){
            ex.printStackTrace();
        }
    }
    static void c(){
        b();
    }
    static void b(){
        a();
    }
    static String a(){
        String text = null;
        return text.toUpperCase();
    }
}

要善用堆栈追踪，前提是程序代码中不可有私吞异常的行为、对异常做了不适当的处理，或显示了不正确的信息。

在使用throw重抛异常时，异常的追踪堆栈起点，仍是异常的发生根源，而不是重抛异常的地方。
代码如下：

public class StackTraceDemo2 {
    public static void main(String[] args) {
        try{
            c();
        }catch(NullPointerException ex){
            ex.printStackTrace();
        }
    }
    static void c(){
        try{
            b();
        }catch(NullPointerException ex) {
            ex.printStackTrace();
            throw ex;
        }
    }
    static void b(){
        a();
    }
    static String a(){
        String text = null;
        return text.toUpperCase();
    }
}

如果想让异常堆栈起点为重抛异常的地方，可以使用fillStackTrack()方法，它会重新装填异常堆栈，将起点设为重抛异常的地方，并返回Throwable对象。
代码如下：

public class StackTraceDemo3 {
    public static void main(String[] args) {
        try{
            c();
        }catch(NullPointerException ex){
            ex.printStackTrace();
        }
    }
    static void c(){
        try{
            b();
        }catch(NullPointerException ex) {
            ex.printStackTrace();
            Throwable t = ex.fillInStackTrace();
            throw(NullPointerException) t;
        }
    }
    static void b(){
        a();
    }
    static String a(){
        String text = null;
        return text.toUpperCase();
    }
}

8.2异常与资源管理

8.2.1

try、catch语法还可以搭配finally使用，无论try区块中有无发生异常，若撰写有finally区块，则finally区块一定会被执行。
代码如下：

import java.io.*;
import java.util.Scanner;
public class TryCatchFinally {
    public static String readFile(String name) throws FileNotFoundException{
        StringBuilder text = new StringBuilder();
        Scanner console = null;
        try{
            console = new Scanner (new FileInputStream(name));
            while(console.hasNext()){
                text.append(console.nextLine())
                        .append('\n');
            }
        }finally{
            if(console!=null) {
                console.close();
            }   
            }
        return text.toString();
    }
}

如果程序撰写的流程中先return了，而且也有finally区块，finally区块会先执行完后，再将值返回。
代码如下：

public class FinallyDemo {
    public static void main(String[] args) {
        System.out.println(test(true));
    }
    static int test(boolean flag){
        try{
            if(flag){
                return 1;
            }
        }finally{
            System.out.println("finally...");
        }
    }return 0;
}

8.2.2
在JDK7之后，新增了尝试关闭资源语法。想要尝试自动关闭资源的对象，是撰写在try之后的括号中，如果无须catch处理任何异常，可以不用撰写，也不用撰写finally自行尝试关闭资源。
代码如下：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class FileUtil2 {
    public static String readFile(String name) throws FileNotFoundException {
        StringBuilder text = new StringBuilder();
        try (Scanner console = new Scanner(new FileInputStream(name))) {
            while (console.hasNext()) {
                text.append(console.nextLine())
                        .append('\n');
            }
        }
        return text.toString();
    }
}

8.2.3
JDK7的尝试关闭资源语法可套用的对象，必须操作java.lang.AutoCloseable接口，这是JDK7新增的接口。尝试关闭资源语法也可以同时关闭两个以上的对象资源，只要中间以分号分隔。在try的括号中，越后面撰写的对象资源会越早被关闭。
代码如下：

public class AutoClosableDemo {
    public static void main(String[] args) {
        try(Resource res = new Resource()){
            res.doSome();
        }catch(Exception ex){
            ex.printStackTrace();
        }
    }
}
class Resource implements AutoCloseable{
    void doSome(){
        System.out.println("做一些事");
    }
    @Override
    public void close() throws Exception{
        System.out.println("资源被关闭");
    }
}

尝试关闭资源语法也可以同时关闭两个以上的对象资源，只要中间以分号分隔。在try的括号中，越后面撰写的对象资源会越早被关闭。

第九章 Collection与Map

9.1 使用Collection收集对象

9.1.1

• 收集对象的行为，像是新增对象的add()方法、移除对象的remove()方法等，都是定义在java.util.Collection中，既然可以收集对象，也要能逐一取得对象，这就是java.lang.Iterable定义的行为，它定义了iterator()方法返回java.util.Iterator操作对象，可以让你逐一取得收集的对象。

9.1.2

• List是一种Collection,作用是收集对象，并以索引方式保留收集的对象顺序，其操作类之一是java.util.ArrayList。

代码如下：

import java.util.*;
import static java.lang.System.out;
public class Guest {
    public static void main(String[] args) {
        List names = new ArrayList();
        collectNameTo(names);
        out.println("访客名单:");
        printUpperCase(names);
    }
    static void collectNameTo(List names){
        Scanner console = new Scanner(System.in);
        while(true){
            out.print("访客名称：");
            String name = console.nextLine();
            if(name.equals("quit")){
                break;
            }
            names.add(name);
            
        }
    }
    static void printUpperCase(List names){
        for(int i = 0;i<names.size();i++){
            String name=(String) names.get(i);
            out.println(name.toUpperCase());
        }
    }
}

• 数组在内存中会是连续的线性空间，根据索引随机存取时速度快，如果操作上有这类需求时，像是排序，就可以使用ArrayList,可得到较好的速度表现。
• 注意：若收集的对象经常会有变动索引的情况，也许考虑链接方式操作的List会比较好，像是随时会有客户端登录或注销的客户端List，使用LinkedList会有比较好的效率。

9.1.3

• 同样是收集对象，在收集过程中若有相同对象，则不再重复收集，若有这类需求，可以使用Set接口的操作对象。
  eg.若有一个字符串，当中有许多英文单词，想要知道不重复的单词有几个
  代码如下：

import java.util.*;
public class WordCount {
    public static void main(String[] args) {
        Scanner console = new Scanner(System.in);
        System.out.print("请输入英文：");
        Set words = tokenSet(console.nextLine());
        System.out.printf("不重复单字有%d个：%s%n",words.size(),words);
    }
    static Set tokenSet(String line){
        String[] tokens = line.split(" ");
        return new HashSet(Arrays.asList(tokens));
    }
}

9.1.4

• 如果对象有操作Queue,并打算以队列方式使用，且队列长度受限，通常建议使用offer()、poll()、与peek()等方法。想对队列的前端与尾端进行操作，在前端加入对象与取出对象，在尾端加入对象与取出对象，Queue的子接口Deque就定义了这类行为。
  代码如下：

import java.util.*;
interface Request{
    void execute();
}
public class RequestQueue {
    public static void main(String[] args) {
        Queue requests = new LinkedList();
        offerRequestTo(requests);
        process(requests);
    }
    static void offerRequestTo(Queue requests){
        for(int i=1;i<6;i++){
            Request request = new Request(){
                public void execute(){
                    System.out.printf("处理数据%f%n",Math.random());
                }
            };
            requests.offer(request);
        }
    }
    static void process(Queue requests){
        while(requests.peek()!=null){
            Request rquest = (Request) request.poll();
            request.execute();
        }
    }
}

• 想对队列的前端与尾端进行操作，在前端加入对象与取出对象，在尾端加入对象与取出对象，Queue的子接口Deque就定义了这类行为。

9.1.5

• 泛型语法：类名称旁有角括号，这表示此类支持泛型。实际加入ArrayList的对象会是客户端声明的E类型。
  泛型语法代码如下：

import java.util.Arrays;

public class ArrayList<E>
{
     Object[] elems;
    private int next;

   public ArrayList(int capacity)
   {
        elems = new Object[capacity];
   }        

   public ArrayList()
   {
        this(16);
   }

   public void add(E e)
   {
        if(next == elems.length) 
        {
            elems = Arrays.copyOf(elems, elems.length * 2);
        }
        elems[next++] = e;
   }

   public E get(int index)
   {
        return (E) elems[index];
   }

   public int size()
   {
        return next;
   }
}

9.1.6
在JDK8中 Lambda表达式：Request request = ()-> out.ptinf("处理数据%f%n",Math.random() )

相对于匿名类语法来说，Lambda表达式的语法省略了接口类型与方法名称，->左边是参数列，而右边是方法本体。

简化代码

IntegerFunction doubleFunction = new IntegerFunction()
{
public Integer apply(Integer i)
{
return i*2;
}

}

简化后
IntegerFunction doubleFunction = (Integer i) -> i * 2;

9.1.7

• 在JDK5之后有了增强式for循环，它可运用在操作Iterable接口的对象上。

9.1.8

• 在收集对象之后，对对象进行排序是常用的动作，你不用亲自操作排序算法，java.util.Collections提供有sort()方法。由于必须有索引才能进行排序，因此Collections的sort()方法接受List操作对象。

代码如下

import java.util.*;
public class Sort {
    public static void main(String[] args) {
        List numbers = Arrays.asList(10,2,3,1,9,15,4);
        Collections.sort(numbers);
        System.out.println(numbers);
    }
}

9.2 键值对应的Map

9.2.1
若要根据某个键来取得对应的值，可以事先利用java.util.Map接口的操作对象来建立键值对应数据，之后若要取得值，只要用对应的键就可以迅速取得。

• 常用的Map操作类为java.util.HashMap与java.util.TreeMap，其继承自抽象类java.util.AbstractMap。

9.2.2访问Map键值
如果想取得Map中所有的键，可以调用Map的keySet（）返回Set对象。

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

有代码运行时本来输入的是小写字母，输出结果时就自动变成大写。

本周代码托管截图

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

本周学习了课本八九章内容，感触最多的是各种接口越来越多，比较容易遗忘，要多敲代码才可以加以熟悉巩固。这次没有将全部代码一一列在博客上，挑选了一些自己认为比较基础、重要的写在博客里，下面自己的练习代码托管至网上了。

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	4500行	30篇	400小时
第一周	200/200	2/2	20/20
第二周	300/500	1/3	18/38
第三周	400/900	1/4	22/60
第四周	1000/1900	1/5	35/95
第五周	800/2700	1/6	30/125

参考资料

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