20145226夏艺华 《Java程序设计》第5周学习总结

教材学习内容总结

第八章 异常处理

语法与继承架构

使用 try、catch

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

try{
    ...(需要尝试捕捉的程序代码)
}
catch(... ex){
    ...(发生错误时执行的代码)
}

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

• 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("必须输入整数");
       }
    }
}

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

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);
    }
}

异常继承架构

• Throwable 定义了取得错误信息、堆栈追踪等方法，有两个子类：java.lang.Error 与 java.lang.Exception

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

• 单就语法与继承架构上来说，如果某个方法声明会抛出 Throwable 或子类实例，只要不是属于 Error、ava.lang.RuntimeException 或其子类实例，你就必须明确使用 try、catch语法加以处理，或者用 throws 声明这个方法会抛出异常，否则会编译失败

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

• 执行期异常（非受检异常）：因为编译程序不会强迫一定得在语法上加以处理，亦称为非受检异常

• 规则表达式：String 的 matches() 方法中设定了 "\d*"，这是规则表示式，表示检查字符串中的字符是不是数字，若是则 matches() 返回 true

• 如果父类异常对象在子类异常对象前被捕捉，则 catch 子类异常对象的区块将永远不不会被执行

多重捕捉语法：

try{
        做一些事...
    }catch(IOException | InterruptedException | ClassCastException e){
//catch 区块会在发生 IOException、InterruptedException、ClassCastException 时执行
        e.printStackTrace();
    }

• catch 括号中列出的异常不得有继承关系，否则会发生编译错误

catch or throw?

• 如果方法设计流程中发生异常，而设计时没有充足的信息知道该如何处理，那么可以抛出异常，让调用方法的客户端来处理。为了告诉编译程序这个事实，必须用 throws 声明此方法会抛出的异常类型或父类型，编译程序才会让你通过编译。例如：

public class FileUtil {
    public static String readFile(String name)
        throws FileNotFoundException{
        StringBuilder text = new StringBuilder();
        Scanner console = new Scanner(new FileInputStream(name));
        while(console.hasNext()){
            text.append(console.nextLine())
                    .apend('\n');
        }
        return text.toString();
    }
}

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

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();
    }
}

• 如果抛出的是受检异常，表示你认为客户端有能力且应处理异常，此时必须在方法上使用 throws 声明；

• 如果抛出的异常是非受检异常，表示你认为客户端调用方法的时机出错了，抛出异常是要求客户修正这个漏洞再来调用方法，此时也就不使用 throws 声明

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

1.    不声明` throws`任何异常
2.    `throws`父类该方法中声明的某些异常
3.    `throws`父类该方法中声明异常的子类

但是不可以：

4.    `throws`父类方法中未声明的其他异常
5.    `throws`父类方法中声明异常的父类

• 自定义异常

• 自定义异常类别时，可以继承 Throw、Error 或 Exception 或其子类，如果不是继承自Error或 RuntimeException，那么就会是受检异常

• 自定义受检异常：

public class CustomizedException extends Exception{
    ...
}

• 错误发生时：

*    无足够信息处理异常：就现有信息处理完异常后，重新抛出异常
*    已针对错误做了某些处理：考虑自定义异常，用以更精确地表示出未处理的错误
*    客户端有能力处理未处理的错误：自定义受检异常、填入适当错误信息并重新抛出，并在方法上使用 `throws`加以声明
*    客户端没有准备好就调了方法造成未处理错误：自定义受检异常、填入适当错误信息并重新抛出

异常堆栈

• 在多重方法调用下，异常发生点可能是在某个方法之中，若想得知异常发生的根源，以及多重方法调用下的堆栈传播，可以利用异常对象自动收集的堆栈追踪来取得相关信息

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

public class StackTraceDemo1
{
    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();
    }
}

• 如果并不知道调用的顺序，当异常发生而被捕捉后，可以调用 printStackTrace() 在控制台显示堆栈追踪

• 如果想要取得个别的堆栈元素进行处理，则可以使用 getStackTrace()，这会返回 StackTraceElement 数组，数组中索引0为异常根源的相关信息，之后为各方法调用中的信息，可以使用StrackTraceElement的 getClassName()、getFileName()、getLineNumber()、getMethodName() 等方法取得对应的信息

• 要善用堆栈追踪，前提是程序代码中不可有私吞异常的行为

• 在使用 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();
    }
}

• 如果想要异常堆栈起点为重抛异常的地方，可以使用 fillInStackTrace() 方法，这个方法会重新装填异常堆栈，将起点设为重抛异常的地方，并返回 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();
    }
}

assert

• assert 语法：

assert boolean_expression;
assert boolean_expression : detail_expression;
•boolean_expression 若为 true，则什么事都不会发生，如果为 false，则会发生 java.lang.AssertionError，此时若采取的是第二个语法，则会将 detail_expression 的结果显示出来，如果当中是个对象，则调用 toString() 显示文字描述结果

• 断言：程序执行的某个时间点或某个情况下，必然处于或不处于何种状态，这是一种断言

使用断言需要注意：

• 断言客户端调用方法前，已经准备好某些前置条件（通常在private方法之中）

• 断言客户端调用方法前，已经准备好某些前置条件（通常在private方法之中）

• 断言客户端调用方法后，具有方法承诺的结果。

• 断言对象某个时间点下的状态。

• 使用断言取代批注。

• 断言程序流程中绝对不会执行到的程序代码部分。

• checkGreaterThanZero() 是一种前置条件检查，如果程序上线后就不再需要这种检查的话，可以将之以 assert取代，并在开发阶段使用 -ea 选项，而程序上线后取消该选项

• 使用断言的时机：一定不能有 default 的状况，也可以使用 assert 来取代

异常与资源管理

• 使用finally

如果最后一定要执行关闭资源的动作，try、catch语法可以搭配finally，无论try区块中有无发生异常，若撰写有finally区块，则finally区块一定会被执行。如：

import java.io.*;
import java.util.Scanner;
public class FileUtil
{
    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;
    }
}

• try with resources

• 尝试关闭资源语法：想要尝试自动关闭资源的对象，是在撰写在 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();
    }
}

若一个异常被 catch 后的处理过程引发另一个异常，通常会抛出第一个异常作为响应，addSupperessed() 方法可将第二个异常记录在第一个异常>中，JDK7 中与之对应的是getSuppressed() 方法，可返回 Throwable[]，代表先前被addSupperessed()记录的各个异常对象。

使用自动尝试关闭资源语法时，也可搭配 catch。

java.lang.AutoCloseable

• JDK的尝试关闭资源语法可套用的对象，必须操作java.lang.AutoCloseable接口。如：

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

使用 Collection 收集对象

• 认识 collection 架构

• 收集对象的行为，像是新增对象的 add()方法、移除对象的 remove()方法等，都是定义在 java.util.Collection 中

• 既然可以收集对象，也要能逐一取得对象，这就是java.lang.Iterable定义的行为，它定义了iterator()方法返回 java.lang.Iterable 操作对象，可以让你逐一取得收集的对象

• 收集对象的共同行为定义在 Collection 中，然而收集对象会有不同的需求

1.    `java.util.List`：收集时记录每个对象的索引顺序，并可依索引取回对象
2.    `java.util.Set`：收集的对象不重复，具有集合的行为
3.    `java.util.Queue`：收集对象时以队列方式，收集的对象加入至尾端，取得对象时从前端
4.    `java.util.Deque`：可对Queue的两端进行加入、移除等操作
5.    `java.util.ArrayList`：以数组操作 List（想要收集对象时具有索引顺序，操作方法之一是使用数组）

List

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

ArrayList 特性

*    考虑是否使用 ArrayList，就等于考虑是否要使用到数组的特性
*    数组在内存中会是连续的线性空间，根据索引随机存取时速度快，如果操作上有这类需求时，像是排序，就可使用ArrayList，可得到较好的速度表现

LinedList 特性

*    `LinkedList`在操作List接口时，采用了链接（Link）结构
*    在`SimpleLinkedList`内部使用Node 封装新增的对象，每次 `add()` 新增对象之后，将会形成链状结构
*    若收集的对象经常会有变动索引的情况，也许考虑链接方式操作的List会比较好，像是随时会有客户端登录或注销的客户端List，使用LinkedList会有比较好的效率

Set

• 使用 Set 接口操作对象：在收集对象的过程中若有相同的对象，则不再重复收集，若有这类需求，可以使用 Set 接口的操作对象，例如：

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(" ");
//String 的 split() 方法，可以指定切割字符串的方式，在这里指定以空格切割，split()会返回 String[]，包括切割的每个字符串
        return new HashSet(Arrays.asList(tokens));
//将 String[] 中的每个字符串加入 Set 的操作 HashSet 中
    }
}

• HashSet的操作概念是，在内存中开设空间，每个空间会有个哈希编码

• 如果对象要加入 HashSet，则会调用对象的hashCode()取得哈希码，并尝试放入对应号码的哈希桶中。如果哈希桶中没对象，则直接放入；如果哈希桶中有对象，会再调用对象的 equals() 进行比较，如果比较结果为 false，则表示两个对象非重复对象，可以收集，如果比较结果为 true，表示两个对象是重复对象，则不予收集

Queue

• Queue继承自Collection，所以也具有Collection的add()、remove()、element()等方法，然而Queue定义了自己的offer()、poll()与peek()等方法，最主要的差别之一在于：add()、remove()、element()等方法操作失败时会抛出异常，而offer()、poll()与peek()等方法操作失败时会返回特定值。

• 如果对象有操作 Queue，并打算以队列方式使用，且队列长度受限，通常建议使用offer()、poll()与peek()等方法

• offer():offer()方法用来在队列后端加入对象，成功返回 true ,失败则返回 false

• poll():poll()方法用来取出队列前端对象，若队列为空则返回 null

• peek():peek()用来取得（但不取出）队列前端对象，若队列为空则返回 null

• LinkeedList 不仅操作了 List 接口，也操作了 Queue 的行为，所以可将 LinkedList 当作队列来使用，例如：

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就定义了这类行为

• 操作失败时抛出异常：addFiret()、removeFirst()、getFirst()、addLast()、removeLast()、getLast()

• 操作失败时返回特定值：offerFirst()、pollFirst()、peekFirst()、offerLast()、pollLast()、peekLast()

• java.util.ArrayDeque操作了Deque接口，可以使用ArrayDeque来操作容量有限的堆栈

使用泛型

• 泛型语法使用样例：

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;
   }
}

• 只要声明参考时有指定类型，那么创建对象时就不用再写类型时了

Lambda

• Lambda 表达式：

Request request = () -> out.printf("处理数据 %f%n",Math.random());

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

• 在使用 Lambda 表达式，编译程序在推断类型时，还可以用泛型声明的类型作为信息来源

• 虽然不鼓励使用Lambda表达式来写复杂的演算，不过若流程较为复杂，无法在一行的Lambda表达式中写完时，可以使用区块{}符号包括演算流程

• 在Lambda表达式中使用区块时，如果方法必须返回值，在区块中就必须使用return

Iterable与Iterator

• iterator() 方法会返回 java.util.Iterator 接口的操作对象，这个对象包括了Collection 收集的所有对象，可以使用Iterator 的 hasNext() 看看有无下一个对象，若有，再使用 next() 取得下一个对象

 static void forEach(Collection collection) {
        Iterator iterator = colleciton.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

• interator()方法提升至新的java.util.Iterable父接口

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

 static void forEach(Iterable iterator) {
        for(Object o: iterable){
            System.out.println(o);
        }
    }

• Iterable 新增了 forEach() 方法，可以让你对迭代对象进行指定处理

Comparable与Comparator

• Collections的sort()方法要求被排序的对象必须操作java.lang.Comparable接口，这个接口有个compareTo()方法必须返回大于0、等于0或小于0的数

• Collections的sort()方法有另一个重载版本，可接受java.util.Comparator接口的操作对象，如果使用这个版本，排序方式将根据Comparator的compare()定义来决定，例如：

import java.util.*;
class StringComparator implements Comparator<String>
{
    @Override
    public int compare(String s1, String s2)
    {
        return -s1.compareTo(s2);
    }
}
public class Sort5
{
    public static void main(String[] args)
    {
        List<String> words = Arrays.asList("B", "X", "A", "M", "F", "W", "O");
        Collections.sort(words, new StringComparator());
       System.out.println(words);
   }
}

• 在Java的规范中，跟顺序有关的行为，通常要不对象本身是Comparable，要不就是另行指定Comparator对象告知如何排序

• JDK8在List上增加了sort()方法，可接受Comparator实例来指定排序方式

键值对应的Map

• 常用 Map 操作类

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

• 建立 Map 操作对象时，可以使用泛型语法指定键与值的类型

• 要建立键值对应，可以使用put()方法，第一个自变量是键，第二个自变量是值

• 对于 Map 而言，键不会重复，判断键是否重复是根据 hashCode() 与 equals()，所以作为键的对象必须操作 hashCode() 与 equals()。若要指定键取回对应的值，则使用 get() 方法

• 如果想要键是有序的，可以使用 TreeMap。如果使用 TreeMap 建立键值对应，则键的部分将会排序，条件是作为键的对象必须操作 Comparable 接口，或者是在创建TreeMap时指定操作Comparator接口的对象，例如：

import java.util.*;
public class Messages2
{
    public static void main(String[] args)
    {
        Map<String, String> messages = new TreeMap<>();
        messages.put("Justin", "Hello！Justin的信息！");
        messages.put("Monica", "給Monica的悄悄话！");
        messages.put("Irene", "Irene的可爱猫喵喵叫！");
        System.out.println(messages);
    }
}

• Properties类继承自Hashtable，HashTable操作了Map接口，Properties自然也有Map的行为。虽然也可以使用put()设定键值对应、get()方法指定键取回值，不过一般常用Properties的setProperty()指定字符串类型的键值，getProperty()指定字符串类型的键，取回字符串类型的值，通常称为属性名称与属性值。

• 可以使用Properties的load()方法指定InputStream的实例

• 如果想取得Map中所有的键，可以调用Map的keySet()返回Set对象。由于键是不重复的，所以用Set操作返回是理所当然的做法，如果想取得Map中所有的值，则可以使用values()返回Collection对象。例如：

import java.util.*;
import static java.lang.System.out;
public class MapKeyValue
{
    public static void main(String[] args)
    {
        Map<String, String> map = new HashMap<>();
        map.put("one", "一");
        map.put("two", "二");
        map.put("three", "三");
        out.println("显示鍵");
        map.keySet().forEach(key -> out.println(key));
        out.println("显示值");
        map.values().forEach(key -> out.println(key));
    }
}

• 如果想同时取得Map的键与值，可以使用entrySet()方法，这会返回一个Set对象，每个元素都是Map.Entry实例。可以调用getKey()取得键，调用getValue()取得值。

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

这几章里使用的各种类的方法比较多，所以在这里做一下总结。

类、方法、函数的区别？

• Java是完全面向对象的，Java的类，就是一切对象的模板。
• 方法和函数一个意思，是某一个对象的一种行为。属性也是属于某一个对象的。
• 也就是说，属性和行为，（变量和函数）组成了类（也就是对象的模型）。
• 类不能调用，只能用来生成对象，但是类有行为可以直接执行。比如静态方法，举个例子：鸡蛋涨价了，这个就是类行为。可以修饰成静态。
• 主函数比较特别，包含在不同的类中，会受的访问控制修饰的影响，比如公有私有是否静态的属性和行为的调用，会受到影响。

类的定义是 : < class> <类名> ，通常在Java 中提到class，就是指类的意思。

方法与函数其实一样的，只是在C语言中我们习惯叫函数，而在Java中我们习惯叫方法，不管怎么叫，都是指同一个意思。

方法（或函数，为了方便，下面我都说 方法 ） 必须在类中。

方法的定义是 ：<修饰符><返回值><方法名> (<参数类型> <参数名>){.....}

一般来说：aa.XXX(); 就是指调用实体aa的XXX()方法

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

除了教材上的代码之外，我运用已学的知识写了一些自己的小程序以加深对知识点的理解掌握～

NO.1

根据所学知识自己动手写了一个小程序玩～以下是debug前：

import java.util.Set;
import java.util.TreeSet;
import java.util.Iterator;
/**
 * Created by XiaYihua on 2017/1/28.
 */
public class Test0128{
    public static void main(String[] args){
        Set<String> set = new TreeSet<>();
        set.add("B");
        set.add("A");
        set.add("D");
        set.add("C");
        set.add("E");
        set.add("F");
        Iterator<String> iter = set.iterator();
        while (iter.hasNext()){
            String str = iter.next();
            if("A".equals(str)){
                iter.remove();
            }else {
                System.out.println(iter.next());
            }
        }
    }
}

debug之后发现，有一处逻辑错误。。。

经过单步调试之后发现，错误出现在System.out.println(iter.next());这里，以下是修改之后的代码：

import java.util.Set;
import java.util.TreeSet;
import java.util.Iterator;
/**
 * Created by XiaYihua on 2017/1/28.
 */
public class Test0128 {
    public static void main(String[] args){
        Set<String> set = new TreeSet<>();
        set.add("B");
        set.add("A");
        set.add("D");
        set.add("C");
        set.add("E");
        set.add("F");
        Iterator<String> iter = set.iterator();
        while (iter.hasNext()){
            String str = iter.next();
            if("A".equals(str)){
                iter.remove();
            }else {
                System.out.println(str);
            }
        }
    }
}

运行结果：

很开心～

通过这个小程序我深入地理解了Iterator下的next()方法。

NO.2

关于ArrayList的使用我也动手写了一个小程序～

import java.util.ArrayList;
/**
 * Created by XiaYihua on 2017/1/28.
 */
public class JavaCollection {
    public static void main(String[] args){
        ArrayList<String> lists = new ArrayList<>();
        if(lists.isEmpty()){
            System.out.println("list is empty!");
        }
        lists.add("one");
        lists.add("two");
        lists.add("three");
        System.out.println("one is at " + lists.indexOf("one"));
        System.out.println("two is at " + lists.indexOf("two"));
        System.out.println("three is at " + lists.indexOf("three"));
        System.out.println("After adding:");
        for (int i = 0; i < lists.size(); i++) {
            System.out.println(lists.get(i));
        }
        lists.remove("two");
        System.out.println("After remove two:");
        for (int i = 0; i < lists.size(); i++) {
            System.out.println(lists.get(i));
        }
        System.out.println("one is at " + lists.indexOf("one"));
        System.out.println("two is at " + lists.indexOf("two"));
        System.out.println("three is at " + lists.indexOf("three"));
        }
    }

运行结果：



通过这个小程序让我对ArrayList的各种方法有了进一步的理解和掌握～

本周代码托管截图

学习进度条

	代码行数（新增/累积）	博客量（新增/累积）	学习时间（新增/累积）	重要成长
目标	5000行	30篇	400小时
第二周	200/400	1/3	12/52
预备作业	0/400	1/4	15/67
第三周	500/900	1/5	10/77
第四周	500/1500	1/6	15/92
第五周	500/2000	1/7	20/112

参考资料

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