贵大选课系统引导页：学生选课系统

第四章java中的集合框架
4.1：java中的集合框架概述

1.java概念与作用

现实中很多事物凑在一起都是集合   如购物车是商品的集合   军队呢 是军人的集合   学校是学生的结合     数学中的集合：  具有共同属性的事物的总体  java中的集合类呢 跟数学的集合有点类似   java中的集合:是一种工具，就像容器。存储任意数量的具有共同属性的对象

作用:  1.在类的内部，对数据进行组织2.简单而快速的搜索大数量的条目； 3.有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速增删改

2.体系结构

3.实际应用

与数组不同的是 ——为何选择集合 而不是数组    因为数组的长度是固定的  而集合不同集合的长度是可以增加的 

集合有两种 一个是Collection  另一个是Map 两个跟接口

Collection 有三个子接口  List  Queue  Set   其中呢List  Queue是排列有序的  可重复的  而Set是无序列的 不可重复的  List的实现类  ArrayList   Queue的实现类LinkedList   Set的实现类HashSet

Map的最用的是HapMap（哈希码） <Kev，Value>  键值对

4.2：Collection接口

Collection接口

是List.Set和Queue接口的父接口  可以用于增删改查的操作

List接口以及实现类ArratList

List是元素有序并且可以重复的集合，被称为序列

List可以精确的控制每个元素的插入位置  或删除某个位置的元素

ArrayList  数组序列，是List的一个重要的实现类

ArrayList底层是由数组来实现的

4.3：学生选课  创建学生类和课程类

讲解创建了两个类   一个学生类一个课程类  然后定义了String类型的两个变量  一个 id  一个name   然后创建了一个含参构造器   使用this方法让新创建的参数等于传入进去的值

package imooc;
//课程类
    public class Course {
         public String id;
         public String name;
         public Course (String id , String name) {//含参构造器
             this.name=name ; 
             this.id=id;
             }
         public Course(){
         }
    }
package imooc;
//学生类
import java.util.HashSet;//导包
import java.util.Set;
 
public class Student {
    public String id;
    public String name;
    public Set <Course> courses;
    public Student(String id , String name) {//含参数构造器
        this.id=id;//初始化  让新对象的id 等于传递进去的id值
        this.name=name;
        this.courses=new HashSet<Course>();
    }
}

4.4：学生选课---添加课程

使用List储存    新建一个类    使用this 来new对象 ArrayList（）  储存容器  

创建一个课程对象，并调用add返回发，添加备选课程List中

创建主方法来  new对象  调用对象名的  add  来获取课程

Course cr1 = new Course ("1","数据结构");//new对象和内容
        coursesToSelect.add(cr1);//添加一个数据
        Course temp =(Course) coursesToSelect.get(0);
        //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
        System.out.println("添加课程："+temp.id+":"+temp.name);//输出
        Course cr2 = new Course ("2","c语言");
        coursesToSelect.add(0,cr2);//添加一个数据
        Course temp2 =(Course) coursesToSelect.get(0);
        System.out.println("添加课程："+temp2.id+":"+temp2.name);//输出
        //Course cr3 = new Course ("1","数据结构");//new对象和内容
        //coursesToSelect.add(4,cr3);//添加一个数据
        //如果插入的数据超出范围的话 就会输出数组下标越界 因为这个底层是数组
        coursesToSelect.add(cr1);//添加一个数据
        Course temp0 =(Course) coursesToSelect.get(2);
        //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
        System.out.println("添加课程："+temp.id+":"+temp.name);//输出
        //一下方法会抛出数组下表越界异常
        Course[] course = { new Course("3","离散数学"),new Course("4","汇编语言")};//添加课程  这是同时插入两门课程的方法  
        coursesToSelect.addAll(Arrays.asList(course));//使用addAll方法来
        Course temp3 = (Course) coursesToSelect.get(3);    //因为存进去的时候会自动编程Object类型  需要强制转换去出 
        Course temp4 = (Course) coursesToSelect.get(4);    //因为存进去的时候会自动编程Object类型  需要强制转换去出 
        //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
        System.out.println("添加两门课程："+temp3.id+":"+
        temp3.name+":"+temp4.id+":"+temp4.name);
        Course[] course2 = { new Course("5","高等数学"),new Course("6","MYSQL")};//添加课程  这是同时添加了两门课程的方法  
        coursesToSelect.addAll(2, Arrays.asList(course2    ));//addAll方法的使用
        Course temp5 = (Course) coursesToSelect.get(2);
        Course temp6 = (Course) coursesToSelect.get(3);
        //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
        System.out.println("添加两门课程："+temp5.id+":"+
                temp5.name+":"+temp6.id+":"+temp6.name);

4.5：学生选课---添加课程2

与4.4不同的是  add改成了addAll来添加数据  同样是使用强制转换将原来的Object来转换成相应的数据

Course cr1 = new Course ("1","数据结构");//new对象和内容
        coursesToSelect.add(cr1);//添加一个数据
        Course temp =(Course) coursesToSelect.get(0);
        //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
        System.out.println("添加课程："+temp.id+":"+temp.name);//输出
        Course cr2 = new Course ("2","c语言");
        coursesToSelect.add(0,cr2);//添加一个数据
        Course temp2 =(Course) coursesToSelect.get(0);
        System.out.println("添加课程："+temp2.id+":"+temp2.name);//输出
        //Course cr3 = new Course ("1","数据结构");//new对象和内容
        //coursesToSelect.add(4,cr3);//添加一个数据
        //如果插入的数据超出范围的话 就会输出数组下标越界 因为这个底层是数组
        coursesToSelect.add(cr1);//添加一个数据
        Course temp0 =(Course) coursesToSelect.get(2);
        //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
        System.out.println("添加课程："+temp.id+":"+temp.name);//输出
        //一下方法会抛出数组下表越界异常
        Course[] course = { new Course("3","离散数学"),new Course("4","汇编语言")};//添加课程  这是同时插入两门课程的方法  
        coursesToSelect.addAll(Arrays.asList(course));//使用addAll方法来
        Course temp3 = (Course) coursesToSelect.get(3);    //因为存进去的时候会自动编程Object类型  需要强制转换去出 
        Course temp4 = (Course) coursesToSelect.get(4);    //因为存进去的时候会自动编程Object类型  需要强制转换去出 
        //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
        System.out.println("添加两门课程："+temp3.id+":"+
        temp3.name+":"+temp4.id+":"+temp4.name);
        Course[] course2 = { new Course("5","高等数学"),new Course("6","MYSQL")};//添加课程  这是同时添加了两门课程的方法  
        coursesToSelect.addAll(2, Arrays.asList(course2    ));//addAll方法的使用
        Course temp5 = (Course) coursesToSelect.get(2);
        Course temp6 = (Course) coursesToSelect.get(3);
        //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
        System.out.println("添加两门课程："+temp5.id+":"+
                temp5.name+":"+temp6.id+":"+temp6.name);

4.6：学生选课---课程查询

使用get方法来获取课程  ​​​​​​然后使用for循环  获得学生课程   再打印输出就可以  在主方法中来使用方法   

另一种方法迭代器   再是使用迭代器来 wheil循环   通过hasnext来判断是否有下一个  然后在使用next方法来获取   知道hasnext判断没有下一值  结束循环  再打印输出

再另一种方法屎  foreach循环来 输出课程   使用for循环  Object循环遍历集合  还是需要使用强制类型转换    因为类型屎 Object类  所以要使用强制类型转换来转换相应的类型

    public void testGet() {
        int size =coursesToSelect.size();//调用List里的size方法来获取集合的长度的值
        for(int i= 0 ; i<size ;i++) {//使用for循环遍历 
            Course cr1=(Course) coursesToSelect.get(i); //同样还是需要强转
            //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
            System.out.println("课程："+cr1.id+":"+cr1.name);//打印输出
        }
    }
    //通过迭代器来遍历List
     public void testIterator() {
         //通过集合迭代器方法来  来取得迭代器实例
         System.out.println("有如下课程待选（通过迭代器访问：）");
         Iterator it=coursesToSelect.iterator();
         while (it.hasNext()) {
             Course cr=(Course)it.next();
             System.out.println("课程："+cr.id+":"+cr.name);
             
         }
     }
     //通过foreach方法访问集合元素
     public void testForEach() {
         System.out.println("使用foreach方法来遍历输出");
         for(Object obj:coursesToSelect) {//去遍历每个集合中的变量
             Course cr = (Course) obj;
            //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
             System.out.println("课程："+cr.id+":"+cr.name);
         }
     }

4.7：学生选课---课程修改

修改List里的内容

使用set方法来修改对象    再在主方法中调用方法   打印输出

 //修改List中的元素
     public void testModify() {
         coursesToSelect.set(4,new Course("7","毛概"));//使用set方法来重写指定位置的课程
     }
4.8：学生选课---课程删除

使用remove方法来删除   先是使用get方法来读取指定内容中的元素   传入到remove方法中删除      还是使用强制类型转换来  

removeAll方法  使用方法是先来使用get方法来获取你想删除的课程的位置的

 //删除List中的元素 
     public void testRemove() {
        // Course cr = (Course) coursesToSelect.get(4);//获取索引位置上4的课程
        //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
         System.out.println("即将删除4位置和5位置上的课程");//输出
        // System.out.println("我是课程："+cr.id+":"+cr.name+"我即将被删除");
        // coursesToSelect.remove(cr);//删除索引4位置上的课程
         Course [] courses= {(Course) coursesToSelect.get(4),(Course) coursesToSelect.get(5)};//使用removeAll方法来删除 4位置和5位置上的元素
         coursesToSelect.removeAll(Arrays.asList(courses));
        // coursesToSelect.remove(4);//删除索引4位置上的课程
         System.out.println("成功被删除");//打印输出
         testForEach();
     }
4.9：学生选课---应用泛型管理课程

如果在集合里添加的类型不同的话   比如 一开始是int类型  后面传入的参数是 String类型的话  java就会抛出异常   会报错

泛型的使用的话   泛型只能储存同一种类型的才能使用  如果不是同一类型的话  就会抛出异常  

可以在<>中定义指定类型    规定了指定类型  调用时就不需要使用强制类型转换  

package imooc;
 
import java.util.ArrayList;
import java.util.List;
 
public class TestGeneric {
//带有泛型的   Course， List类型的属性
    public List <Course> courses;//规定泛型的类型
         public TestGeneric() {
             this.courses = new ArrayList<Course>();//初始化对象
    }
         //测试添加
         public void testAdd() {
             Course cr1 = new Course("1","大学语文");//new对象cr1
             courses.add(cr1);//使用add方法来添加cr1
            // courses.add("能否加一些奇怪的东西呢");
             Course cr2 = new Course("2","java从入门到退学");//new对象cr2
             courses.add(cr2);//使用add方法来添加cr2
         }
         public void testForEach() {
             for (Course cr :courses) {//跟上个类不一样 不需要执行类型转换  因为规定了类型属性 所以不需要强制转化
                 System.out.println(cr.id+":"+cr.name);
             }
         }
         public static void main(String[]args) {
             TestGeneric tg =new TestGeneric();
             tg.testAdd();//调用add方法 
             tg.testForEach();//调用foreach方法
         }
}

4.10：学生选课---应用泛型管理课程2

需要继承父类  一开始子类中是不可以使用无参构造方法  需要在父类中 先定义一个无参器  子类中才能使用无参构造方法   泛型不能使用基本数据类型  需要使用基本类型的包装类 才不会报错

 再去调用方法 就可以打印输出   如果不是的话 就会报错  

//泛型集合可以添加子类的对象实例
         public void testChild(){
             ChildCourse ccr = new ChildCourse();
             ccr.id="3";
             ccr.name="我是子类型的课程对象实例";
             courses.add(ccr);
         }
         //泛型不能使用基本数据类型   需要使用包装类
         public  void testBasicType() {
             //List<int> list =new ArrayList<int>();
             List<Integer> list =new ArrayList<Integer>();
             list.add(1);
             System.out.println("基本数据类型必须使用包装类作为泛型"+list.get(0));
         }
4.11：学生选课---通过Set集合管理课程

Set接口以及其实现类  ---- HashSet

Set是元素无序并不可重复的集合    被称为集

HashSet---哈希集，  是Set的一个重要的实现类 

Set是不能使用get方法来读取里面的数量 因为Set集合是没有序列的  只能使用for循环 或者迭代器来 把他循环遍历出来 

主要是讲解了使用 Scanner  来获取学生在键盘上输入的数   然后在使用for循环来循环三次  遍历学生选的课程  在使用使用if 判断语句来 来判断是否输入的数 和相应的课程是否一直   使用equals来 判断是否一直    然后再调用方法  打印输出  

Set中，添加某个对象 ，无论添加多少此  最终只会保留一个该对象（的引用） 并且，保留的是第一次添加的那一天 

package imooc;
 
import java.util.ArrayList;
import java.util.List;
 
public class TestGeneric {
//带有泛型的   Course， List类型的属性
    public List <Course> courses;//规定泛型的类型
         public TestGeneric() {
             this.courses = new ArrayList<Course>();//初始化对象
    }
         //测试添加
         public void testAdd() {
             Course cr1 = new Course("1","大学语文");//new对象cr1
             courses.add(cr1);//使用add方法来添加cr1
            // courses.add("能否加一些奇怪的东西呢");
             Course cr2 = new Course("2","java从入门到退学");//new对象cr2
             courses.add(cr2);//使用add方法来添加cr2
         }
         public void testForEach() {
             for (Course cr :courses) {//跟上个类不一样 不需要执行类型转换  因为规定了类型属性 所以不需要强制转化
                 System.out.println(cr.id+":"+cr.name);
             }
         }
         public static void main(String[]args) {
             TestGeneric tg =new TestGeneric();
             tg.testAdd();//调用add方法 
             tg.testForEach();//调用foreach方法
         }
}

第五章java中的集合框架（中）
5.1：Map&HashMap简介

Map接口   跟前两种的不同的是  前面两种一个一个出现的  Map接口是成对出现的

Map接口

Map提供了一种映射关系 ，其中的元素是以键值对（key-value）形式储存的 ，能够实现根据key快熟查询value

Map中的键值对以Entry类型的对象实例形式存在  

键（key）不可重复的   value值是可以的

每个键最多只能映射一个值 （value）

Map接口提供了分别返回key值集合 ，value值集合以及Entry（键值对）集合得方法

Map也是一样支持泛型的 形式如下  Map（k，v）

HashMap类  

HashMap 是Map得一个重要的实现类  ，基于哈希表实现

HashMap中得Entry对象是无序排列得  

Key值为null得映射  （key值不可重复）

5.2：学生选课---使用Map中添加学生

显示创造一个Scanner对象来获取学生从键盘中输入的值    在使用for循环来遍历  再使用get方法来哎获取 学生的id  在使用for循环来判断是学生输入的数  是否为空   如果为空的话  就是用next获取学生输入的名字 再new对象来创建一个新的对象  需要传入两个参数  也是键值对  一个是传入一个  int类型和一个String类型  然后储存学生的信息

ketSet方法  返回Map中的所有“键”的Set集合 

遍历keySet，取得每一个键 ，再调用方法来取得每一个间的value

最终 Set集合是没有顺序的  

package imooc;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
 
public class SetTest {
    public List<Course>coursesToSelect;
public SetTest() {
    coursesToSelect= new ArrayList<Course>();
    }
public void testAdd() {
    //创建一个对象 并使用add来添加一个数据
    Course cr1 = new Course ("1","数据结构");//new对象和内容
    coursesToSelect.add(cr1);//添加一个数据
    Course temp =(Course) coursesToSelect.get(0);
    //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
    System.out.println("添加课程："+temp.id+":"+temp.name);//输出
    Course cr2 = new Course ("2","c语言");
    coursesToSelect.add(0,cr2);//添加一个数据
    Course temp2 =(Course) coursesToSelect.get(0);
    System.out.println("添加课程："+temp2.id+":"+temp2.name);//输出
    //Course cr3 = new Course ("1","数据结构");//new对象和内容
    //coursesToSelect.add(4,cr3);//添加一个数据
    //如果插入的数据超出范围的话 就会输出数组下标越界 因为这个底层是数组
    //coursesToSelect.add(cr1);//添加一个数据
    //Course temp0 =(Course) coursesToSelect.get(2);
    //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
    //System.out.println("添加课程："+temp.id+":"+temp.name);//输出
    //一下方法会抛出数组下表越界异常
    Course[] course = { new Course("3","离散数学"),new Course("4","汇编语言")};//添加课程  这是同时插入两门课程的方法  
    coursesToSelect.addAll(Arrays.asList(course));//使用addAll方法来
    Course temp3 = (Course) coursesToSelect.get(3);    //因为存进去的时候会自动编程Object类型  需要强制转换去出 
    Course temp4 = (Course) coursesToSelect.get(4);    //因为存进去的时候会自动编程Object类型  需要强制转换去出 
    //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
    //System.out.println("添加两门课程："+temp3.id+":"+
    //temp3.name+":"+temp4.id+":"+temp4.name);
    Course[] course2 = { new Course("5","高等数学"),new Course("6","MYSQL")};//添加课程  这是同时添加了两门课程的方法  
    coursesToSelect.addAll(2, Arrays.asList(course2    ));//addAll方法的使用
    Course temp5 = (Course) coursesToSelect.get(2);
    Course temp6 = (Course) coursesToSelect.get(3);
    //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
    //System.out.println("添加两门课程："+temp5.id+":"+
        //    temp5.name+":"+temp6.id+":"+temp6.name);
    //取出List中的元素的方法
    }
//存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
    //System.out.println("添加两门课程："+temp5.id+":"+
    //    temp5.name+":"+temp6.id+":"+temp6.name);
//通过foreach方法访问集合元素
public void testForEach() {
     System.out.println("使用foreach方法来遍历输出");
     for(Object obj:coursesToSelect) {//去遍历每个集合中的变量
         Course cr = (Course) obj;
        //存入一个数据是 会变成Object类型的  因为取出一个类型是  都是Object类型 是需要强行转换的  才能输出
         System.out.println("课程："+cr.id+":"+cr.name);
     }
}
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SetTest st =new SetTest();
        st.testAdd();
        st.testForEach();//创建一个新的学生对象
        Student student = new    Student("1","丁富贵");
        System.out.println("欢迎学生"+ student.name+"选课");
        //创建一个Scanner对象 用来获取从键盘上输入的课程id
        Scanner console =new Scanner(System.in);
        for(int i = 0;i<3;i++) {//可以选三门课程
            System.out.println("请输入课程id");//打印
            String courseId =console.next();//返回从键盘上输入的字符串
            for(Course cr:st.coursesToSelect) {//for循环比对每一个从键盘上输入的值
                if(cr.id.equals(courseId)) {//比较输入的字符串是否相等  如果相等的话就添加到cr的对象里
                    student.courses.add(cr);
                }
            }
        }
        //打印输出学生所选的课程
        //for(Course cr :student.courses) {
            //System.out.println("选择了课程"+cr.id+":"+cr.name);}
        st.testForEachForSet(student);
        }
    public void testForEachForSet(Student student ) {
    //打印学生所选的课程
        for(Course cr: student.courses) {
            System.out.println("选择了课程:"+cr.id+":"+cr.name);
        }
    }
    }

5.3：学生选课---删除Map中的学生

还是一样 先创建一个Scanner来获取学生中键盘中输入的值  在使用if语句来判断是否有学生的信息    还是跟Set一样使用remove来删除指定信息   先是运行前面的操作 如果显示有学生的信息 就使用remove语句来删除学生的信息

public void testRemove() {
        //提示输入待删除的学生id
        Scanner console = new Scanner(System.in);
        while(true) {
            System.out.println("请输入要删除的学生id");
            //获取从键盘上输入待删除学生的id字符串
            String id = console.next();
            //判断该id是否有相应的学生对象
            Student st =students.get(id);
            if(st==null) {
                //提示输入的id并不存在
                System.out.println("该id不存在");
                continue;
            }
            students.remove(id);
            System.out.println("成功删除学生"+st.name);
        }
    }

5.4：学生选课---修改Map中的学生

还是一样 先是创建一个Scanner来获取学生从键盘中输入的值   使用while循环来   然后使用next方法   再是使用if语句来判断是否为空 如果为空的话 就打印输出     如果显示没有的话 就需要创建一个学生id    就需要提供新的已经存在的学生姓名   再是使用Scanner来获取键盘上输入的值  调用put方法来修改信息 

public void testModify() {
        //提示输入要修改的学生id
        System.out.println("请输入要修改的学生id：");
        //创建一个Scanner对象，去获取从键盘上输入的id字符串
        Scanner console = new Scanner (System.in);
        while(true) {
            //取得一个从键盘上输入的学生的id
            String stuID =console.next();
            //从student查找该学生的id对象的学生对象
            Student student =students.get(stuID);
            if(student==null) {
                System.out.println("该id不存在！请重新输入！");
                continue;
            }
            //提示当前的学生对象的名字
            System.out.println("当前该学生的id所对应的学生为："+student.name);
            //提示输入新的学生姓名 ，来修改已有的映射
            System.out.println("请输入新的学生姓名");
            String name = console.next();
            Student newStudent =new Student(stuID,name);
            students.put(name, newStudent);
            System.out.println("修改成功");
            break;
        }
    }

第六章java中的集合框架（下）
6.1：学生选课---判断List中课程是否存在

显示使用get方法选择指定位置是否是该课程     使用cantains方法来判断是否包含该课程 如果是的话就打印 然后再输出是否有相应课程   再看情况打印出  true或者false

    //测试List的contains方法  判断列表中是否包含该课程  返回真 或者假
    /*public void  testListContains() {
        //取得备选课程序列中的第0个元素
        Course course = coursesToSelect.get(0);
        //打印输出coursesToSelected是否包含course对象
        System.out.println("取得课程："+course.name);
        System.out.println("备选课程中是否包含课程;"+course.name+","
                coursesToSelect.contains(course));//判断是否包含该课程 如果包含的话返回真  不包含返回假
        //创建一个新的课程对象，id和名称，与course对象完全一样
        Course course2 = new Course(course.id,course.name);
        //打印输出coursesToSelected是否包含course对象
        System.out.println("取得课程："+course2.name);
        System.out.println("备选课程中是否包含课程;"+course2.name+","
        coursesToSelect.contains(course2));//判断是否包含该课程 如果包含的话返回真  不包含返回假
    }
*/

6.2：学生选课---判断Set中课程是否存在

先是new一个对象    然后再是创建一个Scaner获取从键盘中输入的值  再使用for循环来遍历  再是时使用next方法来到下一个  使用cantains方法来判断是否包含该课程

 public void taseSetContains() {
         //提示输入课程名称
         System.out.println("请输入学生已选课程的名称");
         String name = console.next();
        //创建一个新的课程对象，id和名称，与course对象完全一样
            Course course2 = new Course(course.id,course.name);
            //打印输出coursesToSelected是否包含course对象
             course2.name=name;
             System.out.println("取得课程："+course2.name);
                System.out.println("备选课程中是否包含课程;"+course2.name+","
                student.courses.contains(course2));
     }
6.3：学生选课---获取List中课程的位置 

获取课程的位置是需要通过indexOf方法来获取某元素的位置

先是使用if语句判断 然后再通过indexOf方法来获取某元素的位置  括号中输入你想获取课程的索引位置  然后再依次输出 

if(coursesToSelect.contains(course))
            System.out.println("课程："+course.name+"索引的位置为："
                    + ""+coursesToSelect.indexOf(course));
        }
6.4：学生选课---判断Map中是否包含指定的键值对

再Map中使用containsKey（）方法来判断是否包含某个Key值   用containsValue（）方法  ，来判断是否包含某个Value值   还是一样创建一个Scaner的对象 获取学生从键盘中输入的值  然后再是使用if语句来判断从键盘上输入的id是否存在    获取键盘中输入的id  如果存在的话  就依次输出打印

public void testContainsKeyOrValue() {
        //提示输出学生id
        System.out.println("请输入要查询学生的id");
        Scanner console = new Scanner (System.in);
        String id = console.next();
        //再Map中用containsKey()方法，来判断是否包含某个Key值
        System.out.println("你输入的学生id为："+id+"在学生映射表中是否存在"
                +students.containsKey(id));
        if(students.containsKey(id))
            if(students.containsKey(id))
                System.out.println("对应的学生为："+students.get(id).name);
    }
6.5：学生选课---Collections工具类

Collections工具类 是java集合框架中，用于操作对象的工具类  也是java集合框架的成员  

其中有sort（排序）方法

泛型是不能使用基本数据类型的   如果使用的话就会报错    需要使用相应的包装类  

需要插入十个100以内的不重复的整数   需要使用for循环来操作    为了保证不重复需要嵌套do...wheil循环    为了do...wheil循环中保证其中的数不重复 需要使用contains来处理

添加成功后需要使用foreach循环来去迭代每一个元素  然后打印输出  调用cCoolections的sort方法 （）括号内需要传入你想排序的变量名  然后再主方法new对象 然后调用方法Sort方法  再输出 这样的话就先排序好的顺序  

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
public class CollectionsTest {
//将要完成
    //通过Collections.sort()方法来对Integer泛型的List进行排序
    //对String泛型进行List进行排序
    //对其他的类型泛型的List进行排序  以Student位列
    
    
 
    //通过Collections.sort()方法来对Integer泛型的List进行排序
     //床啊进一个Integer泛型的List  插入十个100以内的不重复的随机整数
    //调用Collections.sort()方法对其进行排序
    public   void  testSort1(){
        List<Integer> integerList =new ArrayList<Integer>();
        //插入十个100以内的不重复的随机整数
        Random random =new Random ();
        Integer k;
        for(int i=0;i<10;i++) {
            k = random.nextInt();
        }while (integerList.contains(k));
        integerList.add(k);
        System.out.println("成功添加整数：" +k);
    }
    System.out.println("--------排序钱---------");
    for(Integer integer:integerList) {
        System.out.println("元素"+integer);
    }
    Collections.sort(integerList);
    System.out.println("--------排序后---------");
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        CollectionsTest.sort(integerList);
    }
}

6.6：学生选课---尝试对学生序列排序

如果使用sort方法的话  跟之前一样使用的话  就会报错  会爆出不适用于该参数     sort方法是需要必须实现Comparable接口

public void testSort3(){
        List<Student>studentList= new ArrayList<Student>();
        studentList.add(new Student (1+"","小明"));
        studentList.add(new Student (1+"","小红"));
        studentList.add(new Student (1+"","小明1"));
        System.out.println("--------排序钱---------");
        for(Student student :studentList ) {
            System.out.println("学生"+student.name);
        }
        Collections.cort(studemtList);
    }
6.7：Comparable接口

在java中想要排序  需要两个对象是可以比较的   Comparable  -----默认比较规则   Comparator  临时比较规则  

Comparable接口----可比较的 

实现该接口表示：这个类的实例可以比较大小，可以进行自然的排序  

定义了默认的比较规则

其实现类需要实现compareTo（）方法

compareTo()方法返回证书表示大，负数表示小 0表示相等

Comparator接口  比较工具接口 

用于定义临时的比较规则  ，而不是默认的比较规则 

其实现类需要实现compare（）方法

Comparator和Comparable都是java集合框架的成员

6.8：学生选课---实现学生序列排序

需要实现Comparable接口  需要设为一样的泛型    需要使用相应的方法   如果小的话 就会输出正整数  如果大的话  就会输出负整数  如果相等的话就会输出0  然后先创建一个对象 要把名字改为字符串类型  id需要改成一千以内的正整数  再是调用该方法   然后输出 就会输出该结果   输出出来的   都是按照id的正整数来排列的       排序规则是 先数字后字母  数字0~9字母a~z的顺序    数字是先从第一位数字来排序的   

public void testSort3(){
        List<Student>studentList= new ArrayList<Student>();
        Random random =new Random();
        studentList.add(new Student (random.nextInt(1000)+"","MIKE"));
        studentList.add(new Student (random.nextInt(1000)+"","ANGELA"));
        studentList.add(new Student (random.nextInt(1000)+"","LUCY"));
        System.out.println("--------排序钱---------");
        for(Student student :studentList ) {
            System.out.println("学生"+student.id+":"+student.name);
        }
        Collections.cort(studentList);
        System.out.println("--------排序后---------");
        for(Student student :studentList ) {
            System.out.println("学生"+student.id+":"+student.name);
        }
    }