JAVA中的集合框架（上）List

第一节 JAVA中的集合框架概述

集合的概念，现实生活中：很多事物凑在一起就是一个集合；数学中的集合：具有相同属性事物的总体；JAVA中的集合：是一种工具类，就像是容器，储存任意数量的具有共同属性的对象。集合的作用：在类的内部，对数据进行组织（如果有些属性类型相同，但意义与作用不同，咱们就不能把它们放到集合，如学生的姓名和性别属性），简单而快速的搜索大数量的条目。
有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关元素；
有的集合接口，提供了映射关系，可以通过关键字key去快速查找到对应的唯一对象，而这个关键字可以是任意类型。
集合其实就是用来承装其它对象的容器。
与数组相比，为何选择集合而不是数组？数组的长度固定，还得复制，集合的长度可变。数组只能通过数组下标访问元素，类型固定，而有的集合可以通过任意类型查找所映射的具体对象，数组还要遍历元素比较麻烦。
集合的框架体系结构：

将collection想象成单身宿舍，三个子接口。
1.List（序列）：排列有序，可重复
2.Queue(队列)：排列有序，可重复
3.set(集)：无序，不可重复
将map当成成对出现，Collection 是存储的一个一个的对象，而Map提供映射的关系，内部以的Key，Value两个对象为一个映射来存储数据，Entry类（键值对）是Map的内部类，Key，Value就是Entry的实例，key和value可以是任意类型的对象。两个根接口：Collection和Map，Collection的子接口有：List序列（有序可重复）、Queue队列、Set集（无序不可重复）。实现类分别：ArrayList数组序列，LinkedList链表也是List的接口实现类，HashSet哈希集；Map的实现类有：HashMap哈希表。
在Collection或Map内部是如何存储对象呢？在每一个Collection类中，存储的就是一个个独立的对象，而Map内部有些特殊。有些集合内部能提供一种映射的关系，就是指Map类，在Map类的内部，一个key一个value两个对象为一个映射去存储数据，这样的一个映射就是Entry类的实例，这个Entry类是Map类的一个内部类，咱们把它翻译成键值对，一个键一个值，两个凑成映射的一对，其中key和value可以是任意类型的对象。
在Collection和Map众多子接口和实现类当中，ArrayList、HashSet、HashMap使用最多的三个实现类

第二节 Collection接口List接口简介

Collection接口、子接口及其实现类，Collection接口是java框架中的根接口，也是List、Set和Queue接口的父接口；定义了很多方法，可用于操作List、Set和Queue的方法，对集合的增删改查，可在API中查看Collection的介绍和方法。
List接口和其实现类 ArrayList
1.List是元素有序并且可以重复的集合，被称为序列
2.List可以精确的控制每个元素的插入位置，或删除某个指定位置的元素
3.ArrayList 数组序列，是List的一个重要实现类
4.ArrayList底层是由数组实现的

第三节 学生选课--创建学生类和课程类

/**
 * 课程类
 * Created by Administrator on 2017/4/2.
 */
public class Course {
    private String id;
    private String name;

    public String getId() {
        return id;
    }
    public String getName(){
        return name;
    }
    public void setId(String id){
        this.id=id;
    }

    public void setName(String name) {
        this.name = name;
    }
    public Course(String id,String name){
        this.id=id;
        this.name=name;
    }
}


import java.util.HashSet;
import java.util.Set;

/**
 * 学生类
 * Created by Administrator on 2017/4/2.
 */
public class Student {
    private String id;
    private String name;
    public Set courses;
    //课程信息存放在set属性里，和list一样是一个子接口
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public Student(String id,String name){
        this.id=id;
        this.name=name;
        this.courses=new HashSet();
        //构造方法里不能直接实例化，因为set是一个接口，通过HashSet()对courses实例化，HashSet是一个重要的实现类
    }
}

第四节 学生选课--添加课程I

在这里注意在List中添加元素，如果插入位置如果大于容量的长度就会报越界异常，如等于容量会在队尾添加一个，小于0也会报错。

import java.util.ArrayList;
import java.util.List;

/**
 * 添加课程
 * Created by Administrator on 2017/4/2.
 */

//既然学生要选课就要存放备选课程，用一个List容器来存放备选课程
public class ListTest {
    //新建ListTest类
    //创建一个List类型的属性，用于存放备选课程的容器List
    public List courseToSelect;
  //给类添加一个构造方法
    public ListTest(){
        this.courseToSelect=new ArrayList();
        //因为List是一个接口，咱们不能直接将它实例化，这里就引入了ArrayList来实现接口的实例化
    }
    //用于往courseToSelect添加课程对象
    public void testAdd(){
        //首先要有一个课程对象的实例
        Course cr1=new Course("1","数据结构");
        //调用add方法添加
        courseToSelect.add(cr1);
        //打印输出 courseToSelect.get(0)的数据
        //当一个对象存入集合后它就变成了Object类型的数据取出时就要把类型转换回来
        Course temp=(Course) courseToSelect.get(0);
        System.out.println("成功添加课程："+temp.getId()+":"+temp.getName());
        Course cr2=new Course("2","C语言");
        //重载的add方法可以指定位置添加元素
        courseToSelect.add(0,cr2);
        Course temp2=(Course) courseToSelect.get(0);
        System.out.println("成功添加课程："+temp2.getId()+":"+temp2.getName());
    }
    //调用main方法测试
    public static void main(String[] args) {
        ListTest lt=new ListTest();
        lt.testAdd();
    }
}

第五节 添加课程II

add和addAll分别各有两个方法，参数不同。其中addAll 需要先把数组转换成list Arrays.asList（）；这个方法也是有两种用法，可以指定位置添加元素。

Course[] cr3={new Course("3","离散数学"),new Course("4","汇编语言")};
        //创建一个课程数组
        //调用addAll把数组添加进去，但是这儿的参数要是Collection的实例，
        // 就需要把数组转换成List，用Arrays.asList()方法
        courseToSelect.addAll(Arrays.asList(cr3));
        //输出
        Course temp3=(Course)courseToSelect.get(2);
        Course temp4=(Course)courseToSelect.get(3);
        System.out.println("成功添加课程："+temp3.getId()+":"+temp3.getName()+";"
                +temp4.getId()+":"+temp4.getName());
        Course[] cr4={new Course("5","高等数学"),new Course("6","大学英语")};
        courseToSelect.addAll(2,Arrays.asList(cr4));
        Course temp5=(Course)courseToSelect.get(2);
        Course temp6=(Course)courseToSelect.get(3);
        System.out.println("成功添加课程："+temp5.getId()+":"+temp5.getName()+";"
                +temp6.getId()+":"+temp6.getName());
    }

第六节 学生选课--课程查询

get方法可以取到指定位置的元素，如果想取出每一个则可以使用for循环来遍历List，由于List中的数据类型是Object，再输出时需要强制转换下类型。长度集合.size()方法。

 /**
     * 定义方法循环遍历List中的元素
     */
    public void test1(){
        System.out.println("使用for循环遍历List中一共有以下课程");
        for(int i=0;i<courseToSelect.size();i++){
            //因为类型不同需要强制类型转换
            System.out.println("课程："+((Course)courseToSelect.get(i)).getId()+":"+
                    ((Course)courseToSelect.get(i)).getName());
        }
    }
    public void test2(){
        System.out.println("使用foreach循环遍历List中一共有以下课程");
        for(Object obj:courseToSelect){
            //因为类型不同需要强制类型转换
            System.out.println("课程："+((Course)obj).getId() +":"+((Course)obj).getName());
        }
    }

接下来还可以试验下List的重复性问题，List中可以重复元素
还有一种的特殊遍历方法，是通过迭代器来遍历集合中的元素 Iterator
Iterator就是迭代器的意思，在Collection接口中定义了iterator方法，通过这个方法可以返回一个当前集合对象的迭代器，再通过这个迭代器去遍历集合中的每个元素，Iterator本身也是一个接口。迭代器本身只是用来遍历元素的，它自己不具备任何存储的功能，可以理解为迭代器依赖于某个集合而存在，本身不能独立存在。

 public void test3(){
        System.out.println("通过迭代器遍历集合中元素，共有以下课程：");
        //通过集合的iterator方法来创建迭代器的实例
        Iterator it=courseToSelect.iterator();
        //遍历元素如有元素则输出它的真值
        while(it.hasNext()){
            Course cr=(Course) it.next();
            System.out.println("课程："+cr.getId()+":"+cr.getName());
        }
    }

第七节 学生选课--课程修改

如何修改List张的元素？用set方法，用指定元素替换列表中指定位置的元素。
set（int index，E element）
参数，要替换元素的索引，要在指定位置存储的元素
courseToSelect.set(4, new Course("7","毛概"));

第八节 学生选课--课程删除

删除List中的元素，删除的方法有remove 和removeAll方法
remove（int index）移除列表中指定位置的元素
remove（object o）此列表中移除第一次出现的指定元素（如果存在）
removeAll（Collection<?> c）从此列表中移除指定Collection中包含的其所有元素，在某个集合中将另一个集合中的所有元素完全删除，注意要将数组转换成List——Arrays.asList();

public void test5(){
        Course[] courses={(Course)courseToSelect.get(4),(Course)courseToSelect.get(5)};
        courseToSelect.removeAll(Arrays.asList(courses));
        courseToSelect.remove(0);
        courseToSelect.remove(courseToSelect.get(0));
    }

第九节 学生选课--应用泛型管理

是否有方法可以控制我往某个List或某个集合中添加元素的类型呢？
这时我们就要用到泛型。
泛型：集合中的元素，可以是任意类型的对象（对象的引用），集合里储存的都是一个个引用，它们都是指向某个具体的对象的。如果把某个对象放入集合，则会忽略他的类型，仅仅把它当做Object来处理，取出也是把它当做Object来取出。泛型则是规定了某个集合只能存放特定类型的对象，并且会在编译期间对其进行类型检查，可以直接按指定类型获取出集合中的元素，这样我们在后续获取并使用时不用因为Object类型再去强制转换了，直接就能使用。

public class ListText {
    public List<Course> courses;
    public ListText(){
        this.courses=new ArrayList<Course>();
    }
}

第十节 应用泛型管理课程

其实在泛型集合中，除了可以保存泛型类型的对象实例，还可以存入泛型的子类型的对象实例。泛型集合可以添加泛型子类型的对象实例，泛型不能是基本类型，必须是引用类型，如果非要用基本类型，可以通过使用包装类限定允许存入的基本数据类型。int Integer long Long boolean Boolean泛型是基本类型的包装类的实例化 举例：
List< Integer > list=new ArrayList < Integer > ();

第十一节 通过Set集合来管理课程

Set接口及其实现类——HashSet，Set是元素无序并且不可以重复的集合，被称为集，HashSet——哈希集，是Set的一个重要实现类，Set没有提供方法去修改某个位置上的元素，由于List有序，Set无序且不可重复，所以Set不可能提供一个指定索引位置，去修改相应元素的办法。没有set()方法，一样有add addAll remove removeAll size（）等方法，Set方法的遍历只能用foreach或者iterator，不能用get方法，因为无序，也无法查询指定索引位置的元素。

package student;
import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;
import java.util.Scanner;

/**
 * Created by Administrator on 2017/4/3.
 */
public class SetTest {
    /**
     *案例功能：
     * 提供备选课程
     * 创建学生对象，并给该学生添加三门课程添加在学生的courses—Set
     * 类型的属性当中
     * 显示备选课程
     * 循环三次，每次输入课程ID
     * 往学生的courses属性中添加与输入的ID相匹配的课程，
     * 输出学生选择的课程
     */
    //定义一个课程List，并且调用构造方法初始化。后将之前的添加方法赋值过来并遍历课程输出
    public List<Course> courseToSelect;
    public SetTest(){
        this.courseToSelect=new ArrayList<Course>();
    }
    public void testAdd(){
        //首先要有一个课程对象的实例
        Course cr1=new Course("1","数据结构");
        //调用add方法添加
        courseToSelect.add(cr1);
        //打印输出 courseToSelect.get(0)的数据
        //当一个对象存入集合后它就变成了Object类型的数据取出时就要把类型转换回来
        Course temp=(Course) courseToSelect.get(0);
        System.out.println("成功添加课程："+temp.getId()+":"+temp.getName());
        Course cr2=new Course("2","C语言");
        //重载的add方法可以指定位置添加元素
        courseToSelect.add(0,cr2);
        Course temp2=(Course) courseToSelect.get(0);
        System.out.println("成功添加课程："+temp2.getId()+":"+temp2.getName());
        Course[] cr3={new Course("3","离散数学"),new Course("4","汇编语言")};
        //创建一个课程数组
        //调用addAll把数组添加进去，但是这儿的参数要是Collection的实例，
        // 就需要把数组转换成List，用Arrays.asList()方法
        courseToSelect.addAll(Arrays.asList(cr3));
        //输出
        Course temp3=(Course)courseToSelect.get(2);
        Course temp4=(Course)courseToSelect.get(3);
        System.out.println("成功添加课程："+temp3.getId()+":"+temp3.getName()+";"
                +temp4.getId()+":"+temp4.getName());
        Course[] cr4={new Course("5","高等数学"),new Course("6","大学英语")};
        courseToSelect.addAll(2,Arrays.asList(cr4));
        Course temp5=(Course)courseToSelect.get(2);
        Course temp6=(Course)courseToSelect.get(3);
        System.out.println("成功添加课程："+temp5.getId()+":"+temp5.getName()+";"
                +temp6.getId()+":"+temp6.getName());
    }
    public void test2(){
        System.out.println("使用foreach循环遍历List中一共有以下课程：");
        for(Object obj:courseToSelect){
            //因为类型不同需要强制类型转换
            System.out.println("课程："+((Course)obj).getId() +":"+((Course)obj).getName());
        }
    }
    public static void main(String[] args) {
        SetTest st=new SetTest();
        st.testAdd();
        st.test2();
        Student st1=new Student("1","宫园薰");
        System.out.println("欢迎"+st1.getName()+"同学选课！每位同学可以选取三门课程哦");
        Scanner sc=new Scanner(System.in);
        //for循环循环三次，通过对比ID来存入对应的课程信息
        for(int i=0;i<3;i++) {
            System.out.println("请输入您选择的课程ID：");
            String courseId = sc.next();
            for (Course cr : st.courseToSelect) {
                if (courseId.equals(cr.getId())) {
                    st1.courses.add(cr);
                    break;
                }
            }
        }
        for(Course cr2:st1.courses){
            System.out.println("您选择了课程：ID："+cr2.getId()+":"+cr2.getName());
        }
    }
}