unmodifiableList() 方法用于返回指定列表的不可修改视图。

    在《重构——改善既有代码的设计》一书中，有一种重构手法叫Encapsulate Collection(封装集群)，为了演示该重构手法，我写了四个类，通过对比重构前后的代码，加深对这一重构手法的理解。

    类Student有一ArrayList属性，如果没有阅读《重构——改善既有代码的设计》一书，很多人可能会像我一样，如下设计类Student。但是，如果通过Student.getCourses()获得对ArrayList属性引用后，就可以任意为Student对象添加“课程”，而Student对象对此一无所知，这不符合面向对象编程的习惯。

    1. package com.readonlylist;
    3. import java.util.ArrayList;
    5. public class Student{
    7.     private String name;
    8.     private ArrayList<String> courses;
    10.     public Student(String name, ArrayList<String> courses){
    11.          this.name = name;
    12.          this.courses = courses;
    13.     }
    15.     public ArrayList<String> getCourses(){
    16.         return courses;
    17.     }
    19.     public void setCourses(ArrayList<String> courses){
    20.         this.courses = courses;
    21.     }
    23.     public String getName(){
    24.         return name;
    25.     }
    27.     public void setName(String name){
    28.         this.name = name;
    29.     }    
    30. }
    1. package com.readonlylist;
    3. import java.util.ArrayList;
    5. public class Test{
    6.     public static void main(String[] args) {
    7.         ArrayList<String> list = new ArrayList<String>();
    8.         list.add("001");
    9.         list.add("002");
    10.         Student s = new Student("Tom", list);
    12.         ArrayList<String> anotherList = s.getCourses();
    14.         anotherList.add("999");
    16.         System.out.println("Tom's course.length = " + s.getCourses().size());
    17.     }
    18. }

    重构后的Student类如下所示：

    1. package com.readonlylist;
    3. import java.util.ArrayList;
    4. import java.util.Collections;
    5. import java.util.List;
    7. public class Student1{
    8.     private String name;
    9.     private ArrayList<String> courses;
    11.     public Student1(String name, ArrayList<String> courses){
    12.          this.name = name;
    13.          this.courses = courses;
    14.     }
    16.     public String getName(){
    17.         return name;
    18.     }
    20.     public void setName(String name){
    21.         this.name = name;
    22.     }
    24.     public void addCourse(String course){
    25.          courses.add(course);
    26.     }
    28.     public String removeCourse(String course){
    29.          boolean removed = courses.remove(courses);
    30.          if (removed){
    31.              return course;
    32.          }else{
    33.             return null;
    34.         }
    35.     }
    37.     public List<String> getCourses(){
    38.          return Collections.unmodifiableList(courses);
    39.     }
    40. }
    1. package com.readonlylist;
    3. import java.util.List;
    4. import java.util.ArrayList;
    6. public class Test1{
    7.     public static void main(String[] args){
    8.          ArrayList<String> list = new ArrayList<String>();
    9.          list.add("001");
    10.          list.add("002");
    11.         Student1 s = new Student1("Tom", list);
    13.         List<String> anotherList = s.getCourses();
    14.         /**
    15.          * throws java.lang.UnsupportedOperationException
    16.          * should replace with s.addCourse(String course)
    17.          */
    18.         anotherList.add("999"); 
    20.         // never reached
    21.         System.out.println("Tom's course.length = " + s.getCourses().size());        
    22.     }
    23. }

    重构后，Student1类，仅对外提供的getCourses()方法，而没有setCourses()方法，而且通过getCourses()方法获得的courses是“只读的”，如果你试图向其添加一个新课程，则抛出java.lang.UnsupportedOperationException。你必须通过Student1.addCourse()来向特定的Student1对象添加一个新课程。就好像，你必须让顾客自己向购物车里放食物，而不能在顾客毫不知情下，偷偷向其购物车里放食物。