Java集合框架（上）

Java中的集合类

-一种容器，存储任意数量具有共同属性的对象。

集合的作用

-容量在运行时可以动态扩展
-在类的内部，对数据进行组织。
-简单而快速的搜索大数量的条目。
-有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关的元素。
-有的集合接口，提供了映射关系，可以通过关键字（key）去快速找到对应的唯一对象，而这个关键字可以使任意类型。

与数组的对比

-数组长度固定，集合长度可变。
-数组只能通过下标访问元素，类型固定，而有的集合可以通过任意类型查找所映射的具体对象。

与泛型的关系

-集合中的元素，可以是任意类型的对象（对象的引用）
-泛型则是规定了某个集合只能存放特定类型的对象
-泛型集合可添加泛型子类型的实例对象
-泛型集合中的限定类型不能使用基本的数据类型
-可以通过使用包装类限定允许存入的基本数据类型

集合体系结构

collection

-Lsit

存储元素排列有序，并且可重复

-Queue

存储元素排列有序，并且可重复

-Set

无序且不可重复

Collection接口、子接口以及实现类

Lsit接口及其实现类——ArrayList

-List是元素有序并且可以重复的集合，被称为序列
-List可以精确控制每个元素的插入位置，或删除某个元素
-ArrayList——数组序列，是List一个重要实现类
-ArrayList底层由数组实现

List的常用方法

public class ListTest {

    private List<Course> listCourses;

    public ListTest(List<Course> listCourses) {
        this.listCourses = listCourses;
    }

    // 用于向课程集合中添加被选课程
    public void add() {
        Course course1 = new Course("1", "数据结构");
        listCourses.add(course1);
        Course temp = listCourses.get(0);
        System.out.println(temp.getId() + "/" + temp.getName());
        Course course2 = new Course("2", "C语言");
        /*
         * 在可以访问的位置中插入数据，之前相应的数据位置往后移动一位 目前可访问的位置为0 若试图访问其他位置则会发生数组下标越界异常
         */
        listCourses.add(0, course2);
        Course temp2 = listCourses.get(0);
        System.out.println(temp2.getId() + "/" + temp2.getName());

        // 一次添加多个元素
        Course[] courses = { new Course("3", "离散数学"), new Course("4", "汇编语言") };
        // asList将数组转换为集合
        listCourses.addAll(Arrays.asList(courses));
        Course temp3 = listCourses.get(2);
        System.out.println(temp3.getId() + "/" + temp3.getName());
        Course temp4 = listCourses.get(3);
        System.out.println(temp4.getId() + "/" + temp4.getName());

        Course[] courses2 = { new Course("5", "高等数学"), new Course("6", "大学英语") };
        // 新添加的两门课程从2处插入
        listCourses.addAll(2, Arrays.asList(courses2));
        Course temp5 = listCourses.get(2);
        System.out.println(temp5.getId() + "/" + temp5.getName());
        Course temp6 = listCourses.get(3);
        System.out.println(temp5.getId() + "/" + temp6.getName());
    }

    // 获取集合中元素
    public void get() {
        int size = listCourses.size();
        System.out.println("调用get方法");
        for (int i = 0; i < size; i++) {
            Course course = listCourses.get(i);
            System.out.println(course.getId() + "/" + course.getName());
        }
    }

    // 通过迭代器来遍历List
    public void iterator() {
        // 迭代器需要依赖集合存在，本身不能独立存在
        Iterator<Course> iterator = listCourses.iterator();
        System.out.println("通过迭代器访问");
        while (iterator.hasNext()) {
            Course course = iterator.next();
            System.out.println(course.getId() + "/" + course.getName());
        }
    }

    // 通过foreach遍历List
    public void foreach() {
        System.out.println("调用foreach");
        for (Course course : listCourses) {
            System.out.println(course.getId() + "/" + course.getName());
        }
    }

    // 修改List中的元素
    public void set() {
        System.out.println("调用set");
        // 将指定位置的元素进行修改
        listCourses.set(1, new Course("1", "Java"));
    }

    // 删除List中的元素
    public void remove() {
        Course course1 = listCourses.get(4);
        Course course2 = listCourses.get(5);
        System.out.println("按对象删除" + course1.getId() + "/" + course1.getName());
        System.out.println("按位置删除" + course2.getId() + "/" + course2.getName());
        // 按位置删除相应的元素
        listCourses.remove(5);
        // 按对象删除相应元素
        listCourses.remove(course1);
        // 测试removeAll
        System.out.println("采用removeAll的方法删除1，2位置");
        Course[] courses = { listCourses.get(0), listCourses.get(1) };
        listCourses.removeAll(Arrays.asList(courses));
        foreach();
    }

    public static void main(String[] args) {
        List<Course> list = new ArrayList<Course>();
        ListTest listTest = new ListTest(list);
        listTest.add();
        listTest.set();
        listTest.get();
        listTest.iterator();
        listTest.foreach();
        listTest.remove();
    }
}

1/数据结构
2/C语言
3/离散数学
4/汇编语言
5/高等数学
5/大学英语
调用set
调用get方法
2/C语言
1/Java
5/高等数学
6/大学英语
3/离散数学
4/汇编语言
通过迭代器访问
2/C语言
1/Java
5/高等数学
6/大学英语
3/离散数学
4/汇编语言
调用foreach
2/C语言
1/Java
5/高等数学
6/大学英语
3/离散数学
4/汇编语言
按对象删除3/离散数学
按位置删除4/汇编语言
采用removeAll的方法删除1，2位置
调用foreach
5/高等数学
6/大学英语

Set接口及其实现类——HashSet

-Set是元素无序并且不可以重复的集合，被称为集
-HashSet——哈希集，是Set重要的实现类
-循环遍历Set只能用foreach或者iterator
-Set中添加某个对象无论多少次，都只会保留第一次添加的那个
-Set可以添加空对象

链接与图片
代码块
分割线与删除线
代码块与语法高亮
在需要高亮的代码块的前一行及后一行使用三个反引号“`”，同时第一行反引号后面表面代码块所使用的语言，如下：

public class SetTest {

    private List<Course> listCourses;

    public SetTest(List<Course> listCourses) {
        super();
        this.listCourses = listCourses;
    }

    // 用于向课程集合中添加被选课程
    public void add() {
        Course course1 = new Course("1", "数据结构");
        listCourses.add(course1);
        Course temp = listCourses.get(0);
        System.out.println(temp.getId() + "/" + temp.getName());
        Course course2 = new Course("2", "C语言");
        /*
         * 在可以访问的位置中插入数据，之前相应的数据位置往后移动一位 目前可访问的位置为0 若试图访问其他位置则会发生数组下标越界异常
         */
        listCourses.add(0, course2);
        Course temp2 = listCourses.get(0);
        System.out.println(temp2.getId() + "/" + temp2.getName());

        // 一次添加多个元素
        Course[] courses = { new Course("3", "离散数学"), new Course("4", "汇编语言") };
        // asList将数组转换为集合
        listCourses.addAll(Arrays.asList(courses));
        Course temp3 = listCourses.get(2);
        System.out.println(temp3.getId() + "/" + temp3.getName());
        Course temp4 = listCourses.get(3);
        System.out.println(temp4.getId() + "/" + temp4.getName());

        Course[] courses2 = { new Course("5", "高等数学"), new Course("6", "大学英语") };
        // 新添加的两门课程从2处插入
        listCourses.addAll(2, Arrays.asList(courses2));
        Course temp5 = listCourses.get(2);
        System.out.println(temp5.getId() + "/" + temp5.getName());
        Course temp6 = listCourses.get(3);
        System.out.println(temp5.getId() + "/" + temp6.getName());
    }

    // 通过foreach遍历List
    public void foreach() {
        System.out.println("调用foreach");
        for (Course course : listCourses) {
            System.out.println(course.getId() + "/" + course.getName());
        }
    }

    // foreach输出所选课程
    public void StudentForeach(Student student){
        // 输出学生所选课程，输出顺序不固定
        for (Course course : student.getCourses()) {
            System.out.println(course.getId()+"/"+course.getName());
        }
    }
    public static void main(String[] args) {
        List<Course> list = new ArrayList<Course>();
        ListTest listCourses = new ListTest(list);
        SetTest setTest = new SetTest(list);
        setTest.add();
        setTest.foreach();
        // 创建一个学生对象
        Set<Course> courses = new HashSet<Course>();
        Student student = new Student("1","小明",courses);
        // 获取键盘输入的课程ID
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入课程ID");
            String id = scanner.next();
            for (Course course : setTest.listCourses) {
                if(course.getId().equals(id)){
                    student.getCourses().add(course);
                }
            }
        }
        setTest.StudentForeach(student);
    }
}

1/数据结构
2/C语言
3/离散数学
4/汇编语言
5/高等数学
5/大学英语
调用foreach
2/C语言
1/数据结构
5/高等数学
6/大学英语
3/离散数学
4/汇编语言
请输入课程ID
1
请输入课程ID
2
请输入课程ID
3
3/离散数学
2/C语言
1/数据结构