第四章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));
}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方法
}
}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);
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
