第十七次作业

最新推荐文章于 2023-12-15 23:17:37 发布

秦小小是boos

最新推荐文章于 2023-12-15 23:17:37 发布

阅读量92

点赞数

分类专栏：作业文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_62534787/article/details/124849687

版权

作业专栏收录该内容

20 篇文章 0 订阅

订阅专栏

集合框架

概念与作用

体系结构

实际应用

主要概念：

package com.imooc.collection;
import java.util.*;
/*
 *用于存放备选课程的list /
 */
public class ListTest {
	public List coursesToSelect;
	public ListTest() {
		this.coursesToSelect=new ArrayList();
		
	}
	/*
	 * 用于往coursesToSelect中添加备选课程/
	 */
	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);
	}
	public static void main(String[] args) {
		ListTest lt=new ListTest();
		lt.testAdd();
	}

}

运行结果

添加其他课程方法

package com.imooc.collection;
import java.util.*;
/*
 *用于存放备选课程的list /
 */
/**
 * 备选课程类
 * @author Administrator
 *
 */
	public class ListTest {
 
 /**
  * 用于存放备选课程的List
  */
		public List coursesToSelect;
		public ListTest() {
			this.coursesToSelect = new ArrayList();
 }
 /**
  * 用于往coursesToSelect中添加备选课程
  */
		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);
		}
 /**
  * 取得List中的元素的方法
  * @param args
  */
		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);
			}
		}
 
 /**
  * 通过迭代器来遍历List
  * @param args
  */
		public void testIterator() {
  //通过集合的iterator方法，取得迭代器的实例
			Iterator<Course> it = coursesToSelect.iterator();
			System.out.println("有如下课程待选(通过迭代器访问)：");
			while(it.hasNext()) {
				Course cr = it.next();
				System.out.println("课程：" + cr.id + ":" + cr.name);
			}
 }
 /**
  * 通过for each方法访问集合元素
  * @param args
  */
		public void testForEach() {
			System.out.println("有如下课程待选(通过for each访问)：");
			for (Object obj : coursesToSelect) {
				Course cr = (Course) obj;
				System.out.println("课程：" + cr.id + ":" + cr.name);
			}
 }
 
 /**
  * 修改List中的元素
  * @param args
  */
		public void testModify() {
			coursesToSelect.set(4, new Course("7", "毛概"));
		}
 
 /**
  * 删除List中的元素
  * @param args
  */
		public void testRemove() {
			//  Course cr = (Course) coursesToSelect.get(4);
			System.out.println("即将删除4位置和5位置上的课程！");
			Course[] courses = {(Course) coursesToSelect.get(4), (Course) coursesToSelect.get(5)};
			coursesToSelect.removeAll(Arrays.asList(courses));
			//  coursesToSelect.remove(4);
			System.out.println("成功删除课程！");
			testForEach();
		}
 
 /**
  * 往List中添加一些奇怪的东西
  * @param args
  */
		public void testType() {
			System.out.println("能否往List中添加一些奇怪的东西呢！？");
			coursesToSelect.add("我不是课程，我只是一个无辜的字符串！！");
		}
 
		public static void main( String[] args) {
			ListTest lt = new ListTest();
			lt.testAdd();
			lt.testType();
			lt.testForEach();
			//  lt.testGet();
			//  lt.testIterator();
			//  lt.testForEach();
			//  lt.testModify();
			//  lt.testForEach();
			//  lt.testRemove();
		}
}

运行结果

package com.imooc.collection;
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;
	this.name=name;
	this.courses=new HashSet();
	}

}

package com.imooc.collection;
/*
 * 课程类/
 */
	public class Course {
		public String id;
		public String name;
		public Course(String id, String name) {
			this.id = id ;
			this.name = name;
			}
		public Course() {
 }
}

package com.imooc.collection;

	import java.util.*;
	
	public class SetTest {
		public List<Course> coursesToSelect;
		public SetTest() {
			coursesToSelect = new ArrayList<Course>();
		} 
 /**
  * 用于往coursesToSelect中添加备选课程
  */
		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);
		}
 
 /**
  * 通过for each方法访问集合元素
  * 
  * @param args
  */
		public void testForEach() {
			System.out.println("有如下课程待选(通过for each访问)：");
			for (Object obj : coursesToSelect) {
				Course cr = (Course) obj;
				System.out.println("课程：" + cr.id + ":" + cr.name);	
			}
		}
 
 /**
  * @param args
  */
		public static void main(String[] args) {
			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) {
					if (cr.id.equals(courseId)) {
						student.courses.add(cr);	
 /**
  * Set中，添加某个对象，无论添加多少次， 最终只会保留一个该对象（的引用）， 并且，保留的是第一次添加的那一个
  */
						// student.courses.add(null);
						student.courses.add(cr);
					}
				}
			}
			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);
			}
		} 
	}

运行结果

先继承父类

package com.imooc.collection;

public class ChildCourse extends Course{

}

通过Set集合管理课程

package com.imooc.collection;

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","大学语文");
			courses.add(cr1);
			//泛型集合中，不能添加泛型规定的类型及其子类型以外的对象，否则会报错！
			//  courses.add("能否添加一些奇怪的东西呢？？");
			Course cr2 = new Course("2","Java基础");
			courses.add(cr2);
		}	
/**
  * 测试循环遍历
  */
		public void testForEach() {
			for (Course cr : courses) {
				System.out.println(cr.id + ":" + cr.name);
			}
 }
 
 /**
  * 泛型结合可以添加泛型的子类型的对象实例
  */
		public void testChild() {
			ChildCourse ccr=new ChildCourse();
			ccr.id = "3";
			ccr.name = "我是子类型的课程对象实例~~";
			courses.add(ccr);
		}
 
 /**
  * 泛型不能使用基本类型
  */
		public void testBasicType() {
			List<Integer> list = new ArrayList<Integer>();
			list.add(1);
			System.out.println("基本类型必须使用包装类作为泛型！" + list.get(0));
		}
 
 /**
  * @param args
  */
		public static void main(String[] args) {
			TestGeneric tg = new TestGeneric();
			tg.testAdd();
			tg.testForEach();
			tg.testChild();
			tg.testForEach();
			tg.testBasicType();
		}
 
}

运行结果

srt接口

Map和HashMap简介

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

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

键(key值)不可重复，value值可以

每个键最多只能映射到一个值

Map接口提供了分别返回key值集合、value值集合以及Entry(键值对)集合的方法
Map支持泛型，形式如:Map<KV>

HashMap类

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

案例功能说明

通过Map<String,Student>进行学生信息管理其中key为学生ID，value为学生对象
通过键盘输入学生信息
对集合中的学生信息进行增、删、改、查操作

使用Map添加学生

package com.imooc.collection;

import java.util.*;
 
	public class MapTest {
 /**
  * 用来承装学生类型对象
  */
		public Map<String, Student> students;
 
 /**
  * 在构造器中初始化students属性
  */
		public MapTest() {
			this.students = new HashMap<String, Student>();
		}
/**
  * 测试添加：输入学生ID，判断是否被占用
  * 若未被占用，则输入姓名，创建新学生对象，并且
  * 添加到students中
  */
		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;
				}
			}
		}
 
 /**
  * 测试Map的keySet方法
  */
		public void testKeySet() {
			// 通过keySet方法，返回Map中的所有“键”的Set集合
			Set<String> 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);
  }	
 }
 
 /**
  * 通过entrySet方法来遍历Map
  */
		public void testEntrySet() {
			// 通过entrySet方法，返回Map中的所有键值对
			Set<Entry<String, Student>> entrySet = students.entrySet();
			for (Entry<String, Student> entry : entrySet) {
				System.out.println("取得键：" + entry.getKey());
				System.out.println("对应的值为：" + entry.getValue().name);
			}
 }
 
 /**
  * @param args
  */
		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<String, Student> students;
 
 /**
  * 在构造器中初始化students属性
  */
		public MapTest() {
			this.students = new HashMap<String, Student>();
		}
		
 /**
  * 测试添加：输入学生ID，判断是否被占用
  * 若未被占用，则输入姓名，创建新学生对象，并且
  * 添加到students中
  */
		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;
				}
			}
		}
 
 /**
  * 测试Map的keySet方法
  */
		public void testKeySet() {
			// 通过keySet方法，返回Map中的所有“键”的Set集合
			Set<String> 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);
			}
		}
 
 /**
  * 测试删除Map中的映射
  */
		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;
			}
		}
 
 /**
  * 通过entrySet方法来遍历Map
  */
		public void testEntrySet() {
			// 通过entrySet方法，返回Map中的所有键值对
			Set<Entry<String, Student>> entrySet = students.entrySet();	
			for (Entry<String, Student> entry : entrySet) {
				System.out.println("取得键：" + entry.getKey());
				System.out.println("对应的值为：" + entry.getValue().name);
			}
		}
 
 /**
  * @param args
  */
		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<String, Student> students;
 
 /**
  * 在构造器中初始化students属性
  */
		public MapTest() {
			this.students = new HashMap<String, Student>();	
		}	
 
 /**
  * 测试添加：输入学生ID，判断是否被占用
  * 若未被占用，则输入姓名，创建新学生对象，并且
  * 添加到students中
  */
		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;
				}
			}
 }
 
 /**
  * 测试Map的keySet方法
  */
		public void testKeySet() {
			// 通过keySet方法，返回Map中的所有“键”的Set集合
			Set<String> 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);
			}
		}
 
 /**
  * 测试删除Map中的映射
  */
		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;
			}
		}
 
 /**
  * 通过entrySet方法来遍历Map
  */
		public void testEntrySet() {
			// 通过entrySet方法，返回Map中的所有键值对
			Set<Entry<String, Student>> entrySet = students.entrySet();
			for (Entry<String, Student> entry : entrySet) {
				System.out.println("取得键：" + entry.getKey());
				System.out.println("对应的值为：" + entry.getValue().name);
			}
		}
 
 /**
  * 利用put方法修改Map中的已有映射
  */
		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;
			}
 }
 
 /**
  * @param args
  */
		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<Course> coursesToSelect;
	private Scanner console;
	 	public Student student;
	 
	 	public SetTest() {
	 		coursesToSelect = new ArrayList<Course>();
	 		console = new Scanner(System.in);
	 	}
	 
	 /**
	  * 用于往coursesToSelect中添加备选课程
	  */
	 	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);
	 		
	 	}
	 
	 /**
	  * 通过for each方法访问集合元素
	  * @param args
	  */
	 	public void testForEach() {
	 		System.out.println("有如下课程待选(通过for each访问)：");
	 		for (Object obj : coursesToSelect) {
	 			Course cr = (Course) obj;
	 			System.out.println("课程：" + cr.id + ":" + cr.name);
	 		}
	 	}
	 	
 	/**
	  * 测试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));
	 		// 提示输入课程名称
	 		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));
	 	}
	 	
	 /**
	  * @param args
	  */
	 	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<Course> coursesToSelect;
		private Scanner console;
 
		public Student student;
 
		public SetTest() {
			coursesToSelect = new ArrayList<Course>();
			console = new Scanner(System.in);
		}
 
 /**
  * 用于往coursesToSelect中添加备选课程
  */
		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);
  
 }
 
 /**
  * 通过for each方法访问集合元素
  * @param args
  */
		public void testForEach() {
			System.out.println("有如下课程待选(通过for each访问)：");
			for (Object obj : coursesToSelect) {
				Course cr = (Course) obj;
				System.out.println("课程：" + cr.id + ":" + cr.name);
			}
 }
 
 /**
  * 测试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));
			// 提示输入课程名称
			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));
			
 }
 
 /**
  * 测试Set的contains方法
  */
		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);
	/**
      * Set中，添加某个对象，无论添加多少次，
      * 最终只会保留一个该对象（的引用），
      * 并且，保留的是第一次添加的那一个
      */
//     student.courses.add(null);
//     student.courses.add(cr);
    }
   }
  }
 }
 
 /**
  * @param args
  */
		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<Course> coursesToSelect;
		private Scanner console;
		public Student student;
		public SetTest() {
			coursesToSelect = new ArrayList<Course>();
			console = new Scanner(System.in);
		}
 
 /**
  * 用于往coursesToSelect中添加备选课程
  */
		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);
			
		}
		
 /**
  * 通过for each方法访问集合元素
  * @param args
  */
		public void testForEach() {
			System.out.println("有如下课程待选(通过for each访问)：");
			for (Object obj : coursesToSelect) {
				Course cr = (Course) obj;		
				System.out.println("课程：" + cr.id + ":" + cr.name);
  }	
 }
 
 /**
  * 测试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));
			// 提示输入课程名称
			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);
     /**
      * Set中，添加某个对象，无论添加多少次，
      * 最终只会保留一个该对象（的引用），
      * 并且，保留的是第一次添加的那一个
      */
//     student.courses.add(null);
//     student.courses.add(cr);
    }
   }
  }
 }
 
 /**
  * 测试Set的contains方法
  */
		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));
		}
 
 /**
  * @param args
  */
		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<String, Student> students;
 
 /**
  * 在构造器中初始化students属性
  */
		public MapTest() {
			this.students = new HashMap<String, Student>();
		}
		
 /**
  * 测试添加：输入学生ID，判断是否被占用
  * 若未被占用，则输入姓名，创建新学生对象，并且
  * 添加到students中
  */
		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;
				}
			}
		}
 
 /**
  * 测试Map的keySet方法
  */
		public void testKeySet() {
			// 通过keySet方法，返回Map中的所有“键”的Set集合
			Set<String> 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);
				}
		}
 
 /**
  * 测试删除Map中的映射
  */
		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;
			}
 }
 
 /**
  * 通过entrySet方法来遍历Map
  */
		public void testEntrySet() {
			// 通过entrySet方法，返回Map中的所有键值对
			Set<Entry<String, Student>> entrySet = students.entrySet();
			for (Entry<String, Student> entry : entrySet) {
				System.out.println("取得键：" + entry.getKey());
				System.out.println("对应的值为：" + entry.getValue().name);
			}
 }
 
 /**
  * 利用put方法修改Map中的已有映射
  */
		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;
  }
		}
 
 /**
  * 测试Map中，是否包含某个Key值或者某个Value值
  */
		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("在学生映射表中不存在该学生！");
		}
 
 /**
  * @param args
  */
		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排序

Collections工具类

sort()排序方法

package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
 
/**
 * 将要完成：
 * 1.通过Collections.sort()方法，对Integer泛型的List进行排序；
 * 2.对String泛型的List进行排序；
 * 3.对其他类型泛型的List进行排序，以Student为例。
 */
	public class CollectionsTest {
 
 /**
  * 1.通过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++) {
				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);
			}
		}	
 
 /**
  * @param args
  */
		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;
 
/**
 * 将要完成：
 * 1.通过Collections.sort()方法，对Integer泛型的List进行排序；
 * 2.对String泛型的List进行排序；
 * 3.对其他类型泛型的List进行排序，以Student为例。
 */
	public class CollectionsTest {
 
 /**
  * 1.通过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++) {
				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);
			}
		}
 
 /**
  * 2.对String泛型的List进行排序；
  * 创建String泛型的List，添加三个乱序的String元素，
  * 调用sort方法，再次输出排序后的顺序
  */
		public void testSort2() {
			List<String> stringList = new ArrayList<String>();
			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);
			}
		}
 
 /**
  * @param args
  */
		public static void main(String[] args) {
			CollectionsTest ct = new CollectionsTest();
			//  ct.testSort1();
			ct.testSort2();
 
 }
 
}

运行结果

Comparable和Comparator简介

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

定义了默认的比较规则
其实现类需实现compareTo()方法
compareTo()方法返回正数表示大，负数表示小，0表示相等

Comparator接口——比较工具接口
用于定义临时比较规则，而不是默认人比较规则

其实现类需要实现compare()方法
Comparator和Comparable都是J ava集合框架的成员

实现学生序列排序

创建StudentComparator类，实现

Comparator<Student>接口：

package com.imooc.collection;
 
import java.util.Comparator;
 
	public class StudentComparator implements Comparator<Student> {
 
		@Override
		public int compare(Student o1, Student o2) {
			// TODO Auto-generated method stub
			return o1.name.compareTo(o2.name);
		}
	}

package com.imooc.collection;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
 
/**
 * 将要完成：
 * 1.通过Collections.sort()方法，对Integer泛型的List进行排序；
 * 2.对String泛型的List进行排序；
 * 3.对其他类型泛型的List进行排序，以Student为例。
 */
	public class CollectionsTest {
 
 /**
  * 1.通过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++) {
				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);
			}
		}
 
 /**
  * 2.对String泛型的List进行排序；
  * 创建String泛型的List，添加三个乱序的String元素，
  * 调用sort方法，再次输出排序后的顺序
  */
		public void testSort2() {
			List<String> stringList = new ArrayList<String>();
			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);
  }
 }
 
 /**
  * 3.对其他类型泛型的List进行排序，以Student为例。
  */
		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"));
			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);
			}
		}
 
 /**
  * @param args
  */
		public static void main(String[] args) {
			CollectionsTest ct = new CollectionsTest();
			//  ct.testSort1();
			//  ct.testSort2();
			ct.testSort3();	
 }	
 
}

运行结果

秦小小是boos

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第十七次作业

集合框架概念与作用体系结构实际应用主要概念：package com.imooc.collection;import java.util.*;/* *用于存放备选课程的list / */public class ListTest { public List coursesToSelect; public ListTest() { this.coursesToSelect=new ArrayList(); } /* * 用于往co..
复制链接

扫一扫