学生选课系统

第四章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（哈希码）  键值对

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 courses;
    public Student(String id , String name) {//含参数构造器
        this.id=id;//初始化  让新对象的id 等于传递进去的id值
        this.name=name;
        this.courses=new HashSet();
    }
}
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             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 courses;//规定泛型的类型
         public TestGeneric() {
             this.courses = new ArrayList();//初始化对象
    }
         //测试添加
         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 list =new ArrayList();
             List list =new ArrayList();
             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 courses;//规定泛型的类型
         public TestGeneric() {
             this.courses = new ArrayList();//初始化对象
    }
         //测试添加
         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 ListcoursesToSelect;
public SetTest() {
    coursesToSelect= new ArrayList();
    }
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 integerList =new ArrayList();
        //插入十个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(){
        ListstudentList= new ArrayList();
        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(){
        ListstudentList= new ArrayList();
        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);
        }
    }