集合框架

一、集合基本含义

1.1 内容含义

集合类含义：一种工具类，类似于容器，存储任意数量的具有共同属性的对象。
集合的作用：
（1）在类的内部，对数据进行组织。
（2）简单而快速地搜索大数量的条目。
（3）有些集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速地插入或者删除有关元素。
（4）有些集合接口，提供了映射关系，可以通过关键字（key）去快速找到对应的唯一对象，而这个关键字可以是任意类型。

项目	含义
集合含义	集合代表了一组对象
集合框架含义	一套规范，用来表示、操作集合，使具体操作与实现细节解耦
目的	存储同类对象，并对他们进行操作。简化代码。
根接口	Collection接口 和Map接口
集合类之间的关系	继承
内容	接口→抽象类→实现类

1.2 与数组的区别

项目	数组	集合
长度	长度定长	长度可变。
元素类型	基本数据类型，对象型	对象型，键值对型。基本数据类型必须转换成包装类。
访问形式	只能通过索引访问	索引或映射对象（即键值对）。

1.3 直接成员

（1）Collection接口
（2）Map接口

二、Collection接口

2.1 基本含义

含义：一组对象。

2.2 直接子接口

2.2.1 List接口——序列

存储元素特点：排列有序，元素可重复。

（1）实现类：ArrayList（数组序列）。
方法使用：参见《Java学习-集合框架实现类（ArrayList）》
（2）实现类：LinkedList（链表）。

2.2.2 Set接口——集

存储元素特点：排列无序，元素不可重复。
实现类：HashSet（哈希集）。

2.2.3 Queue接口——队列

存储元素特点：排列有序，元素可重复。
实现类：LinkedList（链表）。

三、Map接口

含义：一组key-value对.
特点：
（1）映射关系，可以通过key快速查找value。
（2）key唯一，value可重复。即一个value可有多个key。

实现类：HashMap（哈希表）。

四、泛型——generic

目的：解决集合中存入数据时，自动转换成Object类型，而导致的存储类型混乱现象。
作用：规定某个集合只可以存放特定类型的对象。
参见《集合框架-泛型集合》

五、比较器

参见《集合框架-比较器》

六、迭代器

所有集合接口和类都没有提供相应的遍历方法。
遍历集合的方法。
（1）for循环结构。
（2）foreach循环结构。
（3）while循环结构。
（4）迭代器——Iterator接口
参见《集合框架-迭代器（Iterator接口）》

public class GenericTest{
  private List<Student> stu;
  public static void main(String[] args){
    Test t = new Test();
    //t.testError(); // 出错。
    t.testCorrect(); // 正确运行
    t.testGeneric();
    t.testGenericChild();
    t.testBasicType();
  }
  // 测试泛型不能使用基本类型
  public void testBasicType(){
    //List<int> li = new ArrayList<int>(); // 直接报错。
    List<Integer> li = new ArrayList<Integer>();
    li.add(1); // 1本来是基本类型，但此处被自动装箱了。
  }
  // 测试泛型子类存储
  public void testGenericChild(){
    StudentChild stuc = new StudentChild();
    stuc.setName("张三");
    stu.add(stuc); // 此处不报错。说明可以添加子类类型。
  }
  // 成员内部类。
  public class StudentChild extends Student{
  }
  // 测试泛型的使用。
  public void testGeneric(){
    List<Student> li = new ArrayList<>();
    li.add(new Student("张三"));
    // li.add("我是字符串，不是对象"); // 编译时自动检查报错。
    li.add(new Student("李四"));
    testGet(li);  // 正确输出。 
  }
  // 测试装入不正确（即不相同）类型对象
  public void testError(){
    List li = new ArrayList();
    li.add(new Student("张三");
    li.add("我是字符串，不是对象");
    testGet(li);  // 出错。
  }
  // 测试装入正确（即相同）类型对象
  public void testCorrect(){
    List li = new ArrayList();
    li.add(new Student("张三");
    li.add(new Student("李四");
    testGet(li);  // 正确输出。
  }
  // 测试获取。
  public void testGet(List li){
    for( int i = 0; i <li.size(); i++){
      System.out.println(li.get(i).getName());
    }
  }
}

课程类：

public class Course {
  private String name;
  private String id;
  public Course() {
  }
  public Course(String id, String name) {
    this.name = name;
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public String getId() {
    return id;
  }
  public void setId(String id) {
    this.id = id;
  }
}

学生类：

import java.util.HashSet;
import java.util.Set;
public class Student {
  private String name;
  private String id;
  // 存储学生选课的结果集。无序，不可重复。
  private Set course; 
  public Student() {
  }
  public Student(String id, String name) {
    this.id = id;
    this.name = name;
    // Set接口不能直接实例化。所以通过HashSet类来实例化。
    this.course = new HashSet();
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public String getId() {
    return id;
  }
  public void setId(String id) {
    this.id = id;
  }
  public Set getCourse() {
    return course;
  }
  public void setCourse(Set course) {
    this.course = course;
  }
}

ListTest类：
存储选课结果。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
public class ListTest {
  // 用于存放备选课程的List序列。有序，可重复。
  public List coursesToSelect;
  public ListTest() {
    this.coursesToSelect = new ArrayList();
  }
  // ========================增加（插入）=========================
  public void testAdd() {    
    Course cr1 = new Course("1", "语文"); // 创建一个课程对象。  
    
     // add(E e)
    coursesToSelect.add(cr1);
    // 获取元素。
    Course temp = (Course) coursesToSelect.get(0); 
    /**
     * 强制转换的原因。
     * （1）存入集合时：自动转换为Object型。存储的是对象的引用，
     * （2）取出集合时：需要转回Course类型。
     * （3）加入泛型后，就不需要进行强制转换了。
     */		
    System.out.println("添加了课程！" + temp.getId() + "：" + temp.getName());
    Course cr2 = new Course("2", "数学");
    
    // add(int index, E element)
    coursesToSelect.add(0, cr2);
    Course temp2 = (Course) coursesToSelect.get(0);
    System.out.println("添加了课程！" + temp2.getId() + "：" + temp2.getName());
    // 以下方法会抛出数组下标越界异常
    // Course cr3 = new Course("3", "test");
    // coursesToSelect.add(4, cr3);
    
    // addAll(Collection c) 
    Course[] course = { new Course("3", "英语"), new Course("4", "政治") };     
    // 数组。不可以直接添加到集合中，需要先转化为List集合。    
    coursesToSelect.addAll(Arrays.asList(course));
    Course temp3 = (Course) coursesToSelect.get(2);
    Course temp4 = (Course) coursesToSelect.get(3);
    System.out.println("添加了两门课程！" + temp3.getId() + "：" + temp3.getName() + ";" + temp4.getId() + "：" + temp4.getName());
    
    //addAll(int index, Collection c) 
    Course[] course2 = { new Course("5", "历史"), new Course("6", "地理") };
    coursesToSelect.addAll(2, Arrays.asList(course2));
    Course temp5 = (Course) coursesToSelect.get(2);
    Course temp6 = (Course) coursesToSelect.get(3);
    System.out.println("添加了两门课程！" + temp5.getId() + "：" + temp5.getName() + ";" + temp6.getId() + "：" + temp6.getName());
    
    // List集合中的元素，可以重复。
    coursesToSelect.add(cr1);
  }

  // ========================获取=========================
  public void testGet() {
    for (int i = 0; i < coursesToSelect.size(); i++) {
      Course cr = (Course) coursesToSelect.get(i);
      System.out.println("课程：" + cr.getId() + ":" + cr.getName());
    }
  }
  /**
   * 迭代器Iterator接口遍历List 
   * 特点：不能存储数据，只是用来遍历集合中的元素。即必须依赖于集合而存在。
   */
  public void testIterator() {
      System.out.println("通过迭代器Iterator接口遍历List");
      // 通过集合的iterator方法，创建迭代器的实例。
      Iterator it = coursesToSelect.iterator();
      // 未知次数时，使用while循环。
      while (it.hasNext()) {
        Course cr = (Course) it.next();
        System.out.println("课程：" + cr.getId() + ":" + cr.getName());
      }
  }
  /**
   * 通过for each 方法遍历List 
   * foreach是Iterator的简写。
   */
  public void testForeach() {
    System.out.println("通过Foreach遍历List");
     /**
      * 为什么使用Object：原因是当一个元素存入集合中时，其类型被忽略，存储为Object型。
      */
     for (Object obj : coursesToSelect) {
       Course cr = (Course) obj;
       System.out.println("课程：" + cr.getId() + ":" + cr.getName());
     }
  }
  // ========================修改=========================
  public void testModify() {
    coursesToSelect.set(1, new Course("7", "毛概"));
  }
  // ========================删除=========================
  public void testRemove() {
    testForeach();
    
    // remove(Obeject o);
    /*Course cr = (Course)coursesToSelect.get(1);
    System.out.println("我是课程：" + cr.getId() + ":" + cr.getName() + ",我即将被删除");
    coursesToSelect.remove(cr);*/
    
    // remove(int index)
    /* coursesToSelect.remove(1); */

    // removeAll(Collection c)
    Course[] courses = { (Course) coursesToSelect.get(0), (Course) coursesToSelect.get(1) };
    coursesToSelect.removeAll(Arrays.asList(courses));
    System.out.println("成功删除课程！");
    testForeach();
  }
  /**
   * 泛型的学习
   */
  public void testType() {
    System.out.println("只能向集合中添加相同类型的元素");
    coursesToSelect.add("我不是课程，我是一个无辜的字符串");
    testForeach();
  }

  public static void main(String[] args) {
    ListTest lt = new ListTest();
    it.testAdd();
    it.testGet();
    it.testIterator();
    it.testForeach();
    it.testModify();
    it.testForeach();
    it.testRemove();
    // it.testType(); // 抛出异常。因为字符串不能强制转换为Course类型。
  }
}