栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java第十七次作业:使用Java集合完成学生选课系统

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java第十七次作业:使用Java集合完成学生选课系统

 集合的作用

  •   在类的内部,对数据进行组织;简单而快速的搜索大数量的条目;
  •   人有的集合接口,提供了一系列排列有序的元素,并且可以在序列中间快速的插入或者删除有关元素;
  •    有的集合接口,提供了映射关系,可以通过关键字(key)去快速查找到对应的唯一对象,而这个关键字可以是任意类型。

 集合与数组的对比:
     数组的长度固定,集合长度可变
     数组只能通过下标访问元素。类型固定,而有的集合可以通过任意类型查找所映射的具体对象。
Java集合框架体系结构
Collection:(List和Queue常用)
List接口(序列):存储的元素是排列有序的,可重复的
    ArrayList(数组序列):
LinkedList(列表)
Queue接口(队列): 存储的元素是排列有序的,可重复的
    LinkedList(列表):
Set接口(集):无序,不可重复。
    HashSel():
Map:会一个key(任意类型的对象)和一个Value(任意类型的对象)两个对象为一个映射去存储数据
Entry是Map的内部类
  常用的类:HashMap:
使用频率最高的类:ArrayList HashSet HashMap

 

JAVA集合框架体系结构:Collection与Map是两个根接口。
Collection接口:内部存储的是一个个独立的对象。包含:
1、List接口:序列,存储元素排列有序且可重复。实现类:ArrayList,数组序列。实现类:LinkedList,链表。
2、Queue接口:队列,存储元素排列有序且可重复。实现类:LinkedList,链表。
3、Set接口:集,存储元素无序且不可重复。实现类:HashSet,哈希集。
Map接口:内部以两个对象(任意类型)为一个映射去存储数据,这一个映射就是Entry类(Map的内部类)的实例。包括:实现类:HashMap,哈希表。

 4-2Collection接口&list接口简介

 Collection接口 List接口及其实现类--ArrayList

1.List是有序并且可以重复的集合,被称为序列;

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

3.ArrayList--数组序列,是List的一个重要实现类;

4.ArrayList底层是由数组实现的。

  Collection接口是List、Set、Queue接口的父接口
Collection接口定义了可用于操作List、Set和Queue的方法--增删改查
List接口及其实现类--ArrayList
List是元素有序并且可以重复的集合,被称为序列。
List可以精确的控制每个元素的插入位置,或删除某个位置元素
List有add()插入方法和get()获取方法
ArrayList--数组序列,是List的一个重要实现类
ArrayList底层是由数组实现的,这也是其名字的由来

 4-3到4-6(学生选课,课程查询)
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import Eleven.Course;
public class ListTest {
	public List coursesToSelect;
	  public ListTest(){
	   this.coursesToSelect = new ArrayList();
	  }
	  
	     public void testAdd(){
	    	 //创建一个课程,并通过调用adda,
	      Course cr1 = new Course("1","数据结构");
	      coursesToSelect.add(cr1);
	      Course temp = (Course)coursesToSelect.get(0);
	      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);
	      
	      coursesToSelect.add(cr1);
	      Course temp0 = (Course)coursesToSelect.get(2);
	      System.out.println("添加了课程:" + temp.id + ":" + temp.name);
	      
	      Course[] course = {new Course("3","离散教学"),new Course("4","汇编语言")};
	      coursesToSelect.addAll(Arrays.asList(course));
	      Course temp3 = (Course)coursesToSelect.get(3);
	      Course temp4 = (Course)coursesToSelect.get(4);
	      
	      System.out.println("添加了两门课程:" + temp3.id + ":" + temp3.name + ";" + temp4.id + ":" + temp4.name);
	     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.id + ":" + temp5.name + ";" + temp6.id + ":" + temp6.name);
	     }
	     public void testGet(){
	      int size = coursesToSelect.size();
	      System.out.println("有如下课程待选:");
	      for(int i = 0;i < size;i++){
	       Course cr = (Course)coursesToSelect.get(i);
	       System.out.println("课程:" + cr.id + ":" + cr.name);
	      }
	      
	     }
	     public static void main(String[] args) {
	    	 ListTest lt=new ListTest();
	    	 lt.testAdd();
	    	 lt.testGet();
	     }
}

 

 

System.out.println("有如下课程待选(通过foreach访问):");
     for(Object obj:coursesToSelect){//遍历集合中的每一个元素,作为每一个Object变量
      Course cr=(Course) obj;
      System.out.println("课程:" + cr.id + ":" + cr.name);
      }
     }
     public void testModify(){
      coursesToSelect.set(4,new Course("7","毛概"));
      }
     public void testRemove(){
//      Course cr =(Course)coursesToSelect.get(4);
//      System.out.println("我是课程"+cr.id+":"+cr.name);
      System.out.println("即将删除4位置和5位置上的课程!");
      Course[] courses = {(Course)coursesToSelect.get(4),(Course)coursesToSelect.get(3)};
      coursesToSelect.removeAll(Arrays.asList(courses));
     // courseToSelect.remove(cr);
      System.out.println("成功删除");
      testForEach();
     }
     public static void main( String[] args){
      ListTest It = new ListTest();
      It.testAdd();
      It.testGet();
      It.testIterator();
      It.testForEach();
      It.testModify();
      It.testForEach();
     }
}

 

修改课程

public List a = new ArrayList();    //创建List

a.add(index,object);                    //j将元素添加到List的第index+1位置

a.get(index);                                //获取List的第index+1位置的元素

a.set(index,object)                      //更新List的第index+1位置的元素

a.remove(index,object)              //删除List的第index+1位置的元素

 4-8删除课程
(删除元素)List中有remove(index),remove(对象值)和removeAll(Arrays.asList(对象数组名))方法来删除容器中元素的值(用法和add类似).
Course是信息课程类,有id和name属性。courseToSelect是list的序列容器对象。
1.remove(index);删除位置要大于0并且小于List(序列容器)的长度。如果要删除全部可以用for循环嵌套此方法。
2.remove(object);先要获得删除的值,用法是先定义一个信息变量通过get()来存放要删除的值,然后用remove(删除的对象值);
public void textdelect{
Course cr=(Course)(courseToSelect.get(4));
courseToSelect.remove(cr);//通过remove(对象值);
或者 courseToSelect.remove(4);//通过remove(删除位置);  }
3.removeAll(Arrays.asList());要删除指定的多个位置  Arrays.asLIst(对象数组名);作用是把数组转换为集合
用法是先创建信息对象数组存放删除元素的值,然后再用removeAll(Arrays.asList(对象数组名))方法,删除集合数组的元素。
public void textdelext2{
Course []course={(Course)(courseToSelect.get(4)),(Course)(courseToSelect.get(5))};  // 定义数组存放要删除的值
courseToSelect.removeAll(Arrays.asList(course));  // 删除4和5位置的值  }

4-9到4-10应用泛型管理课程 
泛型<>;规定List定义的容器只能存储某种类型的元素。不用泛型的话是什么类型的元素都可以插入,因为插入集合是忽略其类型,把它看成为Object类型,取出时需要强行转换对应的类型。
编写带有泛型的集合
List courseToSelect;  
在构造方法中(实例化的时候也可以不在构造方法,直接实例就可以)
this.courseToSelect=new ArrayList();   //带有泛型-Course的List类型属性就创建了
泛型集合中,不能添加泛型规定的类型以及其子类型以外的对象,否则会报错。
运用了泛型的话,用foreach语句时 存储变量应该为泛型的类型。for(Course a:courseToSelect),不必再用Object取出再强转,因为已经规定容器里装的都是Course类型。

 泛型不能使用基本类型,只能使用包装类
public void testBasicType() {
List list = new ArrayList();
list.add(1);
System.out.println("基本类型必须使用包装类作为泛型!" + list.get(0));
}

 

通过Set集合管理课程

Set接口及其实现类——HashSet Set是元素无序并且不可以重复的集合,被称为集; HashSet——哈希集,是Set的一个重要实现类。

1、Set没有像List中set()方法一样就修改,因为List是有序的,可以指定位置,而Set是无序的。

2、查询遍历时,Set不能用get()方法去获取,因为无序没有指定索引ID,但可以使用foreach和iterator来遍历,但是每次遍历出来可能顺序都不一样,还是因为无序造成的。

3、Set中的size(),add(),addAll(),remove(),removeAll()与List类似。

4、Set还可以添加null;无序演示

map&hashMap简介

 

Map

提供了一种映射关系,其中的元素是以键值对(key-value)的形式存储的,能够实现根据key快速查找value

  •         Map中的键值对以Entry类型的对象实例形式存在
  •         键(key值)不可重复,value值可以
  •         每个键最多只能映射到一个值
  •         Map接口提供了分别返回key值集合、value值集合以及Entry(键值对)集合的方法
  •         Map支持泛型,形式如:Map

HashMap类


HashMap是Map的一个重要实现类,也是最常用的,基于哈希表实现
HashMap中的Entry对象是无序排列的
Key值和value值都可以为null,但是一个HashMap只能有一个 key值为null的映射(key值不可重复)

5-2使用Map添加学生 代码 
package com.imooc.collection;
 
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
 
public class MapTest {
 
    
    public Map students;
    
    
    public MapTest() {
        this.students = new HashMap();
    }
    
    
    public void testPut() {
        // 创建一个Scanner对象,用来获取输入的学生ID和姓名
        Scanner console = new Scanner(System.in);
        int i = 0;
        while (i < 3) {
            System.out.println("请输入学生ID:");
            String ID = console.next();
            // 判断该ID是否被占用
            Student st = students.get(ID);
            if (st == null) {
                // 提示输入学生姓名
                System.out.println("请输入学生姓名:");
                String name = console.next();
                // 创建新的学生对象
                Student newStudent = new Student(ID, name);
                // 通过调用students的put方法,添加ID-学生映射
                students.put(ID, newStudent);
                System.out.println("成功添加学生:" + students.get(ID).name);
                i++;
            } else {
                System.out.println("该学生ID已被占用!");
                continue;
            }
        }
    }
    
    
    public void testKeySet() {
        // 通过keySet方法,返回Map中的所有“键”的Set集合
        Set keySet = students.keySet();
        // 取得students的容量
        System.out.println("总共有:" + students.size() + "个学生!");
        // 遍历keySet,取得每一个键,再调用get方法取得每个键对应的value
        for (String stuId : keySet) {
            Student st = students.get(stuId);
            if (st != null)
                System.out.println("学生:" + st.name);
        }
    }
    
    
    public void testEntrySet() {
        // 通过entrySet方法,返回Map中的所有键值对
        Set> entrySet = students.entrySet();
        for (Entry entry : entrySet) {
            System.out.println("取得键:" + entry.getKey());
            System.out.println("对应的值为:" + entry.getValue().name);
        }
    }
    
    
    public static void main(String[] args) {
        MapTest mt = new MapTest();
        mt.testPut();
        mt.testKeySet();
//        mt.testRemove();
//        mt.testEntrySet();
//        mt.testModify();
//        mt.testEntrySet();
//        mt.testContainsKeyOrValue();
    }
 
}

 

删除Map中的学生

 

package com.imooc.collection;
 
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
 
public class MapTest {
 
    
    public Map students;
    
    
    public MapTest() {
        this.students = new HashMap();
    }
    
    
    public void testPut() {
        // 创建一个Scanner对象,用来获取输入的学生ID和姓名
        Scanner console = new Scanner(System.in);
        int i = 0;
        while (i < 3) {
            System.out.println("请输入学生ID:");
            String ID = console.next();
            // 判断该ID是否被占用
            Student st = students.get(ID);
            if (st == null) {
                // 提示输入学生姓名
                System.out.println("请输入学生姓名:");
                String name = console.next();
                // 创建新的学生对象
                Student newStudent = new Student(ID, name);
                // 通过调用students的put方法,添加ID-学生映射
                students.put(ID, newStudent);
                System.out.println("成功添加学生:" + students.get(ID).name);
                i++;
            } else {
                System.out.println("该学生ID已被占用!");
                continue;
            }
        }
    }
    
    
    public void testKeySet() {
        // 通过keySet方法,返回Map中的所有“键”的Set集合
        Set keySet = students.keySet();
        // 取得students的容量
        System.out.println("总共有:" + students.size() + "个学生!");
        // 遍历keySet,取得每一个键,再调用get方法取得每个键对应的value
        for (String stuId : keySet) {
            Student st = students.get(stuId);
            if (st != null)
                System.out.println("学生:" + st.name);
        }
    }
    
    
    public void testRemove() {
        // 获取从键盘输入的待删除学生ID字符串
        Scanner console = new Scanner(System.in);
        while (true) {
            // 提示输入待删除的学生的ID
            System.out.println("请输入要删除的学生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);
            break;
        }
    }
    
    
    public void testEntrySet() {
        // 通过entrySet方法,返回Map中的所有键值对
        Set> entrySet = students.entrySet();
        for (Entry entry : entrySet) {
            System.out.println("取得键:" + entry.getKey());
            System.out.println("对应的值为:" + entry.getValue().name);
        }
    }
    
    
    public static void main(String[] args) {
        MapTest mt = new MapTest();
        mt.testPut();
        mt.testKeySet();
        mt.testRemove();
//        mt.testEntrySet();
//        mt.testModify();
//        mt.testEntrySet();
//        mt.testContainsKeyOrValue();//
    }
 
}

 

 

修改Map中的学生
put
V put(K keyV value)
将指定的值与此映射中的指定键关联(可选操作)。如果此映射以前包含一个该键的映射关系,则用指定值替换旧值(当且仅当 m.containsKev(k)返回true时,才能说映射 m包含键k的映射关系)。

参数:
key-与指定值关联的键 value-与指定键关联的值

返回:
   以前与key关联的值,如果没有针对key的映射关系,则返回null。(如果该实现支持null值,则返回null也可能表示此映射以前将ull与key关联)。

抛出:

UnsupportedOperationException-如果此映射不支持put操作
ClassCastException-如果指定键或值的类不允许将其存储在此映射中
NullPointerException-如果指定键或值为null,并目此映射不允许null键或值
IllegalArgumentException-如果指定键或值的某些属性不允许将其存储在此映射中

 

package com.imooc.collection;
 
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
 
public class MapTest {
 
    
    public Map students;
    
    
    public MapTest() {
        this.students = new HashMap();
    }
    
    
    public void testPut() {
        // 创建一个Scanner对象,用来获取输入的学生ID和姓名
        Scanner console = new Scanner(System.in);
        int i = 0;
        while (i < 3) {
            System.out.println("请输入学生ID:");
            String ID = console.next();
            // 判断该ID是否被占用
            Student st = students.get(ID);
            if (st == null) {
                // 提示输入学生姓名
                System.out.println("请输入学生姓名:");
                String name = console.next();
                // 创建新的学生对象
                Student newStudent = new Student(ID, name);
                // 通过调用students的put方法,添加ID-学生映射
                students.put(ID, newStudent);
                System.out.println("成功添加学生:" + students.get(ID).name);
                i++;
            } else {
                System.out.println("该学生ID已被占用!");
                continue;
            }
        }
    }
    
    
    public void testKeySet() {
        // 通过keySet方法,返回Map中的所有“键”的Set集合
        Set keySet = students.keySet();
        // 取得students的容量
        System.out.println("总共有:" + students.size() + "个学生!");
        // 遍历keySet,取得每一个键,再调用get方法取得每个键对应的value
        for (String stuId : keySet) {
            Student st = students.get(stuId);
            if (st != null)
                System.out.println("学生:" + st.name);
        }
    }
    
    
    public void testRemove() {
        // 获取从键盘输入的待删除学生ID字符串
        Scanner console = new Scanner(System.in);
        while (true) {
            // 提示输入待删除的学生的ID
            System.out.println("请输入要删除的学生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);
            break;
        }
    }
    
    
    public void testEntrySet() {
        // 通过entrySet方法,返回Map中的所有键值对
        Set> entrySet = students.entrySet();
        for (Entry entry : entrySet) {
            System.out.println("取得键:" + entry.getKey());
            System.out.println("对应的值为:" + entry.getValue().name);
        }
    }
    
    
    public void testModify() {
        // 提示输入要修改的学生ID
        System.out.println("请输入要修改的学生ID:");
        // 创建一个Scanner对象,去获取从键盘上输入的学生ID字符串
        Scanner console = new Scanner(System.in);
        while (true) {
            // 取得从键盘输入的学生ID
            String stuID = console.next();
            // 从students中查找该学生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(stuID, newStudent);
            System.out.println("修改成功!");
            break;
        }
    }
 
    
    public static void main(String[] args) {
        MapTest mt = new MapTest();
        mt.testPut();
        mt.testKeySet();
//        mt.testRemove();
//        mt.testEntrySet();
        mt.testModify();
//        mt.testEntrySet();
    }
 
}

判断list中课程是否存在

 

 

package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
 
public class SetTest {
 
    public List coursesToSelect;
    
    private Scanner console;
    
    public Student student;
    
    public SetTest() {
        coursesToSelect = new ArrayList();
        console = new Scanner(System.in);
    }
    
    
    public void testAdd() {
        //创建一个课程对象,并通过调用add方法,添加到备选课程List中
        Course cr1 = new Course("1" , "数据结构");
        coursesToSelect.add(cr1);
        Course temp = (Course) coursesToSelect.get(0);
//        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);
        
//        coursesToSelect.add(cr1);
//        Course temp0 = (Course) coursesToSelect.get(2);
//        System.out.println("添加了课程:" + temp.id + ":" + temp.name); 
        
        
        //以下方法会抛出数组下标越界异常
//        Course cr3 = new Course("3", "test");
//        coursesToSelect.add(4, cr3);
        
        Course[] course = {new Course("3", "离散数学"), new Course("4", "汇编语言")};
        coursesToSelect.addAll(Arrays.asList(course));
        Course temp3 = (Course) coursesToSelect.get(2);
        Course temp4 = (Course) coursesToSelect.get(3);
        
//        System.out.println("添加了两门课程:" + temp3.id + ":" + 
//                temp3.name + ";" + temp4.id + ":" + temp4.name);
        
        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.id + ":" + 
//                temp5.name + ";" + temp6.id + ":" + temp6.name);
        
    }
    
    
    public void testForEach() {
        System.out.println("有如下课程待选(通过for each访问):");
        for (Object obj : coursesToSelect) {
            Course cr = (Course) obj;
            System.out.println("课程:" + cr.id + ":" + cr.name);
        }
    }
    
    
    public void testListContains() {
        // 取得备选课程序列的第0个元素
        Course course = coursesToSelect.get(0);
        // 打印输出coursesToSelected是否包含course对象
        System.out.println("取得课程:" + course.name);
        System.out.println("备选课程中是否包含课程:" + course.name + ", " + 
                coursesToSelect.contains(course));
        // 提示输入课程名称
        System.out.println("请输入课程名称:");
        String name = console.next();
        // 创建一个新的课程对象,ID和名称,与course对象完全一样
        Course course2 = new Course();
        course2.name = name;
        System.out.println("新创建课程:" + course2.name);
        System.out.println("备选课程中是否包含课程:" + course2.name + ", " +
                coursesToSelect.contains(course2));
        // 通过indexOf方法来取得某元素的索引位置
        if (coursesToSelect.contains(course2))
            System.out.println("课程:" + course2.name + "的索引位置为:" + 
                    coursesToSelect.indexOf(course2));
    }
    
    
    public static void main(String[] args) {
        SetTest st = new SetTest();
        st.testAdd();
        st.testListContains();
        st.testForEach();
 
 
    }
    
}

 

判断Set中课程是否存在

package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
 
public class SetTest {
 
    public List coursesToSelect;
    
    private Scanner console;
    
    public Student student;
    
    public SetTest() {
        coursesToSelect = new ArrayList();
        console = new Scanner(System.in);
    }
    
    
    public void testAdd() {
        //创建一个课程对象,并通过调用add方法,添加到备选课程List中
        Course cr1 = new Course("1" , "数据结构");
        coursesToSelect.add(cr1);
        Course temp = (Course) coursesToSelect.get(0);
//        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);
        
//        coursesToSelect.add(cr1);
//        Course temp0 = (Course) coursesToSelect.get(2);
//        System.out.println("添加了课程:" + temp.id + ":" + temp.name); 
        
        
        //以下方法会抛出数组下标越界异常
//        Course cr3 = new Course("3", "test");
//        coursesToSelect.add(4, cr3);
        
        Course[] course = {new Course("3", "离散数学"), new Course("4", "汇编语言")};
        coursesToSelect.addAll(Arrays.asList(course));
        Course temp3 = (Course) coursesToSelect.get(2);
        Course temp4 = (Course) coursesToSelect.get(3);
        
//        System.out.println("添加了两门课程:" + temp3.id + ":" + 
//                temp3.name + ";" + temp4.id + ":" + temp4.name);
        
        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.id + ":" + 
//                temp5.name + ";" + temp6.id + ":" + temp6.name);
        
    }
    
    
    public void testForEach() {
        System.out.println("有如下课程待选(通过for each访问):");
        for (Object obj : coursesToSelect) {
            Course cr = (Course) obj;
            System.out.println("课程:" + cr.id + ":" + cr.name);
        }
    }
    
    
    public void testListContains() {
        // 取得备选课程序列的第0个元素
        Course course = coursesToSelect.get(0);
        // 打印输出coursesToSelected是否包含course对象
        System.out.println("取得课程:" + course.name);
        System.out.println("备选课程中是否包含课程:" + course.name + ", " + 
                coursesToSelect.contains(course));
        // 提示输入课程名称
        System.out.println("请输入课程名称:");
        String name = console.next();
        // 创建一个新的课程对象,ID和名称,与course对象完全一样
        Course course2 = new Course();
        course2.name = name;
        System.out.println("新创建课程:" + course2.name);
        System.out.println("备选课程中是否包含课程:" + course2.name + ", " +
                coursesToSelect.contains(course2));
        
    }
    
    
    public void testSetContains() {
        // 提示输入课程名称
        System.out.println("请输入学生已选的课程名称:");
        String name = console.next();
        // 创建一个新的课程对象,ID和名称,与course对象完全一样
        Course course2 = new Course();
        course2.name = name;
        System.out.println("新创建课程:" + course2.name);
        System.out.println("备选课程中是否包含课程:" + course2.name + ", " +
                student.courses.contains(course2));
    }
    
// 创建学生对象并选课
    public void createStudentAndSelectCours() {
        //创建一个学生对象
        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 : coursesToSelect) {
                if(cr.id.equals(courseId)) {
                    student.courses.add(cr);
                    
//                    student.courses.add(null);
//                    student.courses.add(cr);
                }
            }
        }
    }
 
    
    public static void main(String[] args) {
        SetTest st = new SetTest();
        st.testAdd();
//        st.testListContains();
        st.testForEach();
 
        st.createStudentAndSelectCours();
        st.testSetContains();
        
//        st.testForEachForSet(student);
    }
 
    public void testForEachForSet(Student student) {
        //打印输出,学生所选的课程!
        System.out.println("共选择了:" + student.courses.size() + "门课程!");
        for (Course cr : student.courses) {
            System.out.println("选择了课程:" + cr.id + ":" + cr.name);
        }
    }
    
}

 

 获取list中的课程位置

package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
 
public class SetTest {
 
    public List coursesToSelect;
    
    private Scanner console;
    
    public Student student;
    
    public SetTest() {
        coursesToSelect = new ArrayList();
        console = new Scanner(System.in);
    }
    
    
    public void testAdd() {
        //创建一个课程对象,并通过调用add方法,添加到备选课程List中
        Course cr1 = new Course("1" , "数据结构");
        coursesToSelect.add(cr1);
        Course temp = (Course) coursesToSelect.get(0);
//        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);
        
//        coursesToSelect.add(cr1);
//        Course temp0 = (Course) coursesToSelect.get(2);
//        System.out.println("添加了课程:" + temp.id + ":" + temp.name); 
        
        
        //以下方法会抛出数组下标越界异常
//        Course cr3 = new Course("3", "test");
//        coursesToSelect.add(4, cr3);
        
        Course[] course = {new Course("3", "离散数学"), new Course("4", "汇编语言")};
        coursesToSelect.addAll(Arrays.asList(course));
        Course temp3 = (Course) coursesToSelect.get(2);
        Course temp4 = (Course) coursesToSelect.get(3);
        
//        System.out.println("添加了两门课程:" + temp3.id + ":" + 
//                temp3.name + ";" + temp4.id + ":" + temp4.name);
        
        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.id + ":" + 
//                temp5.name + ";" + temp6.id + ":" + temp6.name);
        
    }
    
    
    public void testForEach() {
        System.out.println("有如下课程待选(通过for each访问):");
        for (Object obj : coursesToSelect) {
            Course cr = (Course) obj;
            System.out.println("课程:" + cr.id + ":" + cr.name);
        }
    }
    
    
    public void testListContains() {
        // 取得备选课程序列的第0个元素
        Course course = coursesToSelect.get(0);
        // 打印输出coursesToSelected是否包含course对象
        System.out.println("取得课程:" + course.name);
        System.out.println("备选课程中是否包含课程:" + course.name + ", " + 
                coursesToSelect.contains(course));
        // 提示输入课程名称
        System.out.println("请输入课程名称:");
        String name = console.next();
        // 创建一个新的课程对象,ID和名称,与course对象完全一样
        Course course2 = new Course();
        course2.name = name;
        System.out.println("新创建课程:" + course2.name);
        System.out.println("备选课程中是否包含课程:" + course2.name + ", " +
                coursesToSelect.contains(course2));
        // 通过indexOf方法来取得某元素的索引位置
        if (coursesToSelect.contains(course2))
            System.out.println("课程:" + course2.name + "的索引位置为:" + 
                    coursesToSelect.indexOf(course2));
    }
    
    // 创建学生对象并选课
    public void createStudentAndSelectCours() {
        //创建一个学生对象
        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 : coursesToSelect) {
                if(cr.id.equals(courseId)) {
                    student.courses.add(cr);
                    
//                    student.courses.add(null);
//                    student.courses.add(cr);
                }
            }
        }
    }
    
    
    public void testSetContains() {
        // 提示输入课程名称
        System.out.println("请输入学生已选的课程名称:");
        String name = console.next();
        // 创建一个新的课程对象,ID和名称,与course对象完全一样
        Course course2 = new Course();
        course2.name = name;
        System.out.println("新创建课程:" + course2.name);
        System.out.println("备选课程中是否包含课程:" + course2.name + ", " +
                student.courses.contains(course2));
    }
    
    
    public static void main(String[] args) {
        SetTest st = new SetTest();
        st.testAdd();
        st.testListContains();
        st.testForEach();
 
//        st.createStudentAndSelectCours();
//        st.testSetContains();
 
//        st.testForEachForSet(student);
    }
 
    public void testForEachForSet(Student student) {
        //打印输出,学生所选的课程!
        System.out.println("共选择了:" + student.courses.size() + "门课程!");
        for (Course cr : student.courses) {
            System.out.println("选择了课程:" + cr.id + ":" + cr.name);
        }
    }
    
}

 

判断Map中是否包含指定的key和value

package com.imooc.collection;
 
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
 
public class MapTest {
 
    
    public Map students;
    
    
    public MapTest() {
        this.students = new HashMap();
    }
    
    
    public void testPut() {
        // 创建一个Scanner对象,用来获取输入的学生ID和姓名
        Scanner console = new Scanner(System.in);
        int i = 0;
        while (i < 3) {
            System.out.println("请输入学生ID:");
            String ID = console.next();
            // 判断该ID是否被占用
            Student st = students.get(ID);
            if (st == null) {
                // 提示输入学生姓名
                System.out.println("请输入学生姓名:");
                String name = console.next();
                // 创建新的学生对象
                Student newStudent = new Student(ID, name);
                // 通过调用students的put方法,添加ID-学生映射
                students.put(ID, newStudent);
                System.out.println("成功添加学生:" + students.get(ID).name);
                i++;
            } else {
                System.out.println("该学生ID已被占用!");
                continue;
            }
        }
    }
    
    
    public void testKeySet() {
        // 通过keySet方法,返回Map中的所有“键”的Set集合
        Set keySet = students.keySet();
        // 取得students的容量
        System.out.println("总共有:" + students.size() + "个学生!");
        // 遍历keySet,取得每一个键,再调用get方法取得每个键对应的value
        for (String stuId : keySet) {
            Student st = students.get(stuId);
            if (st != null)
                System.out.println("学生:" + st.name);
        }
    }
    
    
    public void testRemove() {
        // 获取从键盘输入的待删除学生ID字符串
        Scanner console = new Scanner(System.in);
        while (true) {
            // 提示输入待删除的学生的ID
            System.out.println("请输入要删除的学生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);
            break;
        }
    }
    
    
    public void testEntrySet() {
        // 通过entrySet方法,返回Map中的所有键值对
        Set> entrySet = students.entrySet();
        for (Entry entry : entrySet) {
            System.out.println("取得键:" + entry.getKey());
            System.out.println("对应的值为:" + entry.getValue().name);
        }
    }
    
    
    public void testModify() {
        // 提示输入要修改的学生ID
        System.out.println("请输入要修改的学生ID:");
        // 创建一个Scanner对象,去获取从键盘上输入的学生ID字符串
        Scanner console = new Scanner(System.in);
        while (true) {
            // 取得从键盘输入的学生ID
            String stuID = console.next();
            // 从students中查找该学生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(stuID, newStudent);
            System.out.println("修改成功!");
            break;
        }
    }
    
    
    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))
            System.out.println("对应的学生为:" + students.get(id).name);
        // 提示输入学生姓名
        System.out.println("请输入要查询的学生姓名:");
        String name = console.next();
        // 用containsValue()方法,来判断是否包含某个Value值
        if (students.containsValue(new Student(null,name)))
            System.out.println("在学生映射表中,确实包含学生:" + name);
        else
            System.out.println("在学生映射表中不存在该学生!");
    }
    
    
    public static void main(String[] args) {    //主方法
        MapTest mt = new MapTest();
        mt.testPut();    //输入学生ID,判断是否被占用,若未被占用,则输入姓名,创建新学生对象,并且添加到students中
        mt.testKeySet();    //测试Map的keySet方法
//        mt.testRemove();    //测试删除Map中的映射
//        mt.testEntrySet();    //通过entrySet方法来遍历Map
//        mt.testModify();    //利用put方法修改Map中的已有映射
//        mt.testEntrySet();    //通过entrySet方法来遍历Map
        mt.testContainsKeyOrValue();    //测试Map中,是否包含某个Key值或者某个Value值
    }

 

 应用Collections.sort()实现list排序
package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
 

public class CollectionsTest {
 
    
    public void testSort1() {
        List integerList = new ArrayList();
        // 插入十个100以内的不重复随机整数
        Random random = new Random();
        Integer k;
        for (int i = 0; i < 10; i++) {
            do {
                k = random.nextInt(100);
            } 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("----------------排序后-------------------");
        for (Integer integer : integerList) {
            System.out.println("元素:" + integer);
        }
    }
    
    
    public static void main(String[] args) {
        CollectionsTest ct = new CollectionsTest();
        ct.testSort1();
    }
 
}
运行结果如下:
 
 
 
创建String泛型的List,添加三个乱序的String元素,调用sort方法,再次输出排序后的顺序
 
package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
 

public class CollectionsTest {
 
    
    public void testSort1() {
        List integerList = new ArrayList();
        // 插入十个100以内的不重复随机整数
        Random random = new Random();
        Integer k;
        for (int i = 0; i < 10; i++) {
            do {
                k = random.nextInt(100);
            } 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("----------------排序后-------------------");
        for (Integer integer : integerList) {
            System.out.println("元素:" + integer);
        }
    }
    
    
    public void testSort2() {
        List stringList = new ArrayList();
        stringList.add("microsoft");
        stringList.add("google");
        stringList.add("lenovo");
        System.out.println("------------排序前-------------");
        for (String string : stringList) {
            System.out.println("元素:" + string);
        }
        Collections.sort(stringList);
        System.out.println("--------------排序后---------------");
        for (String string : stringList) {
            System.out.println("元素:" + string);
        }
    }
    
    
    public static void main(String[] args) {
        CollectionsTest ct = new CollectionsTest();
//        ct.testSort1();
        ct.testSort2();
 
    }
 
}

尝试对学生序列排序 

 

 

Comparable&Comparator简介

6-8实现学生序列排序

package com.imooc.collection;
 
import java.util.Comparator;
 
public class StudentComparator implements Comparator {
 
    @Override
    public int compare(Student o1, Student o2) {
        // TODO Auto-generated method stub
        return o1.name.compareTo(o2.name);
    }
 
}
对其他类型泛型的List进行排序,以Student为例。
 
package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
 

public class CollectionsTest {
 
    
    public void testSort1() {
        List integerList = new ArrayList();
        // 插入十个100以内的不重复随机整数
        Random random = new Random();
        Integer k;
        for (int i = 0; i < 10; i++) {
            do {
                k = random.nextInt(100);
            } 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("----------------排序后-------------------");
        for (Integer integer : integerList) {
            System.out.println("元素:" + integer);
        }
    }
    
    
    public void testSort2() {
        List stringList = new ArrayList();
        stringList.add("microsoft");
        stringList.add("google");
        stringList.add("lenovo");
        System.out.println("------------排序前-------------");
        for (String string : stringList) {
            System.out.println("元素:" + string);
        }
        Collections.sort(stringList);
        System.out.println("--------------排序后---------------");
        for (String string : stringList) {
            System.out.println("元素:" + string);
        }
    }
    
    
    public void testSort3() {
        List studentList = 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"));
        studentList.add(new Student(10000 + "", "Beyonce"));
        System.out.println("--------------排序前---------------");
        for (Student student : studentList) {
            System.out.println("学生:" + student.id + ":" + student.name);
        }
        Collections.sort(studentList);
        System.out.println("----------------排序后------------------");
        for (Student student : studentList) {
            System.out.println("学生:" + student.id + ":" + student.name);
        }
        Collections.sort(studentList, new StudentComparator());
        System.out.println("----------------按照姓名排序后-----------------");
        for (Student student : studentList) {
            System.out.println("学生:" + student.id + ":" + student.name);
        }
    }
    
    
    public static void main(String[] args) {
        CollectionsTest ct = new CollectionsTest();
//        ct.testSort1();
//        ct.testSort2();
        ct.testSort3();
    }
 
}

 

 

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/937623.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号