学生选课系统

集合框架

概念与作用

概念

现实生活中：很多的事物凑在一起

数学中的集合：具有共同属性的事物的总体

Java中的集合类：是一种工具类，就像是容器，存储任意数量的具有共同属性的对象

作用

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

集合与数组的对比

• 数组的长度固定，集合长度可变
• 数组只能通过下标访问元素，类型固定，而有的集合可以通过任意类型查找所有映射的具体对象

体系结构

Collection接口、子接口以及实现类

Collection接口

• 是List、Set和Queue的方法的父接口
• 定义了可用于操作List、Set和Queue的方法——增删改查

List接口及其实现类——ArrayList

• List是元素有序并且可以重复的集合，被称为序列
• List可以精确的控制每个元素的插入位置，或删除某个位置元素
• ArrayList——数组序列，是List的一个重要实现类
• ArrayList底层是由数组实现的

学生选课

创建学生类和课程类

创建项目imooc_collection_map_demo;

创建课程类

1. package imooc_collection_map_demo;

2. /*

3. * 课程类

4. */

5. public class Course {

7. public String id;

9. public String name;

11. public Course(String id,String name) {

12. this.id=id;

13. this.name=name;

14. }

15. }

创建学生类

1. package imooc_collection_map_demo;

3. import java.util.HashSet;

4. import java.util.Set;

6. /*

7. * 学生类

8. */

9. public class Student {

10. public String id;

12. public String name;

14. public Set courses;

16. public Student(String id,String name) {

17. this.id=id;

18. this.name=name;

19. this.courses=new HashSet();

20. }

21. }

添加课程

1. package imooc_collection_map_demo;

3. import java.util.ArrayList;

4. import java.util.List;

5. /*

6. * 备选课程类

7. */

8. public class ListTest {

9. /*

10. * 用于存放备选课程的List

11. */

12. public List coursesToSelect; //创建属性

13. public ListTest() { //构造方法

14. this.coursesToSelect =new ArrayList();

16. }

17. /*

18. * 用于往coursesToSelect中添加备选课程

19. */

20. public void testAdd() {

21. //创建一个课程对象，并通过调用add方法，添加到备选课程List中

22. Course cr1=new Course("1","数据结构");

23. coursesToSelect.add(cr1);

24. //当一个对象存入集合都变成Object类型取出时需要类型转换

25. Course temp = (Course) coursesToSelect.get(0);

26. System.out.println("添加了课程："+temp.id+":"+temp.name);

27. }

28. public static void main (String[]args) {

29. ListTest It = new ListTest();

30. It.testAdd();

31. }

32. }

运行结果：

两个add的使用如下：

1. package imooc_collection_map_demo;

3. import java.util.ArrayList;

4. import java.util.List;

5. /*

6. * 备选课程类

7. */

8. public class ListTest {

9. /*

10. * 用于存放备选课程的List

11. */

12. public List coursesToSelect; //创建属性

13. public ListTest() { //构造方法

14. this.coursesToSelect =new ArrayList();

16. }

17. /*

18. * 用于往coursesToSelect中添加备选课程

19. */

20. public void testAdd() {

21. //创建一个课程对象，并通过调用add方法，添加到备选课程List中

22. Course cr1=new Course("1","数据结构");

23. coursesToSelect.add(cr1);

24. //当一个对象存入集合都变成Object类型取出时需要类型转换

25. Course temp = (Course) coursesToSelect.get(0);

26. System.out.println("添加了课程："+temp.id+":"+temp.name);

27. Course cr2 =new Course("2","C语言");

28. coursesToSelect.add(0, cr2);

29. Course temp2=(Course)coursesToSelect.get(0);

30. System.out.println("添加了课程："+temp2.id+":"+temp2.name);

31. }

33. public static void main (String[]args) {

34. ListTest It = new ListTest();

35. It.testAdd();

36. }

37. }

运行结果如下：

 如果数组下标越界异常将会报错

另外的方法

addAll（具体实例）

方法一

1. package imooc_collection_map_demo;

3. import java.util.ArrayList;

4. import java.util.Arrays;

5. import java.util.List;

6. /*

7. * 备选课程类

8. */

9. public class ListTest {

10. /*

11. * 用于存放备选课程的List

12. */

13. public List coursesToSelect; //创建属性

14. public ListTest() { //构造方法

15. this.coursesToSelect =new ArrayList();

17. }

18. /*

19. * 用于往coursesToSelect中添加备选课程

20. */

21. public void testAdd() {

22. //创建一个课程对象，并通过调用add方法，添加到备选课程List中

23. Course cr1=new Course("1","数据结构");

24. coursesToSelect.add(cr1);

25. //当一个对象存入集合都变成Object类型取出时需要类型转换

26. Course temp = (Course) coursesToSelect.get(0);

27. System.out.println("添加了课程："+temp.id+":"+temp.name);

28. Course cr2 =new Course("2","C语言");

29. coursesToSelect.add(0, cr2);

30. Course temp2=(Course)coursesToSelect.get(0);

31. System.out.println("添加了课程："+temp2.id+":"+temp2.name);

32. //以下方法会抛出数组下标越界异常

33. //Course cr3=new Course("3","test");

34. //coursesToSelect.add(4,cr3);

36. Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};

37. coursesToSelect.addAll(Arrays.asList(course));

38. Course temp3 =(Course)coursesToSelect.get(2);

39. Course temp4 =(Course)coursesToSelect.get(3);

40. System.out.println("添加了两门课程："+temp3.id+":"+temp3.name+";"+temp4.id+":"+temp4.name);

41. }

42. public static void main (String[]args) {

43. ListTest It = new ListTest();

44. It.testAdd();

45. }

46. }

运行结果如下：

方法二

1. package imooc_collection_map_demo;

3. import java.util.ArrayList;

4. import java.util.Arrays;

5. import java.util.List;

6. /*

7. * 备选课程类

8. */

9. public class ListTest {

10. /*

11. * 用于存放备选课程的List

12. */

13. public List coursesToSelect; //创建属性

14. public ListTest() { //构造方法

15. this.coursesToSelect =new ArrayList();

17. }

18. /*

19. * 用于往coursesToSelect中添加备选课程

20. */

21. public void testAdd() {

22. //创建一个课程对象，并通过调用add方法，添加到备选课程List中

23. Course cr1=new Course("1","数据结构");

24. coursesToSelect.add(cr1);

25. //当一个对象存入集合都变成Object类型取出时需要类型转换

26. Course temp = (Course) coursesToSelect.get(0);

27. System.out.println("添加了课程："+temp.id+":"+temp.name);

28. Course cr2 =new Course("2","C语言");

29. coursesToSelect.add(0, cr2);

30. Course temp2=(Course)coursesToSelect.get(0);

31. System.out.println("添加了课程："+temp2.id+":"+temp2.name);

32. //以下方法会抛出数组下标越界异常

33. //Course cr3=new Course("3","test");

34. //coursesToSelect.add(4,cr3);

36. Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};

37. coursesToSelect.addAll(Arrays.asList(course));

38. Course temp3 =(Course)coursesToSelect.get(2);

39. Course temp4 =(Course)coursesToSelect.get(3);

40. System.out.println("添加了两门课程："+temp3.id+":"+temp3.name+";"+temp4.id+":"+temp4.name);

41. Course[] course2 = {new Course("5","高等数学"),new Course("6","大学英语")};

42. coursesToSelect.addAll(2, Arrays.asList(course2));

43. Course temp5 =(Course) coursesToSelect.get(2);

44. Course temp6 =(Course) coursesToSelect.get(3);

45. System.out.println("添加了两门课程："+temp5.id+":"+temp5.name+";"+temp6.id+":"+temp6.name);

46. }

47. public static void main (String[]args) {

48. ListTest It = new ListTest();

49. It.testAdd();

50. }

51. }

运行结果如下：

课程查询

 

list中元素可以重复

代码：

1. public void testAdd() {

2. //创建一个课程对象，并通过调用add方法，添加到备选课程List中

3. Course cr1=new Course("1","数据结构");

4. coursesToSelect.add(cr1);

5. //当一个对象存入集合都变成Object类型取出时需要类型转换

6. Course temp = (Course) coursesToSelect.get(0);

7. System.out.println("添加了课程："+temp.id+":"+temp.name);

9. Course cr2 =new Course("2","C语言");

10. coursesToSelect.add(0, cr2);

11. Course temp2=(Course)coursesToSelect.get(0);

12. System.out.println("添加了课程："+temp2.id+":"+temp2.name);

14. coursesToSelect.add(cr1);

15. Course temp0 = (Course) coursesToSelect.get(2);

16. System.out.println("添加了课程："+temp.id+":"+temp.name);

17. //以下方法会抛出数组下标越界异常

18. //Course cr3=new Course("3","test");

19. //coursesToSelect.add(4,cr3);

21. Course[] course = {new Course("3","离散数学"),new Course("4","汇编语言")};

22. coursesToSelect.addAll(Arrays.asList(course));

23. Course temp3 =(Course)coursesToSelect.get(3);

24. Course temp4 =(Course)coursesToSelect.get(4);

25. System.out.println("添加了两门课程："+temp3.id+":"+temp3.name+";"+temp4.id+":"+temp4.name);

26. Course[] course2 = {new Course("5","高等数学"),new Course("6","大学英语")};

27. coursesToSelect.addAll(2, Arrays.asList(course2));

28. Course temp5 =(Course) coursesToSelect.get(2);

29. Course temp6 =(Course) coursesToSelect.get(3);

30. System.out.println("添加了两门课程："+temp5.id+":"+temp5.name+";"+temp6.id+":"+temp6.name);

31. }

运行结果： 

通过迭代器遍历集合中的元素

iterator方法

代码：

1. /*

2. * 通过迭代器来遍历list

3. */

4. public void testIterator() {

5. //通过集合的iterator方法，取得迭代器的实例

6. Iterator it = coursesToSelect.iterator();

7. System.out.println("有如下课程待选(通过迭代器访问)：");

8. while(it.hasNext()) {

9. Course cr = (Course)it.next();

10. System.out.println("课程："+cr.id+":"+cr.name);

11. }

12. }

13. public static void main (String[]args) {

14. ListTest It = new ListTest();

15. It.testAdd();

16. It.testGet();

17. It.testIterator();

18. }

19. }

 运行结果：

迭代器只是遍历集合中元素的，不具备任何存储元素的功能 

for each方法

代码：

1. /*

2. * 通过for each方法访问集合元素

3. */

4. public void testForEach() {

5. System.out.println("有如下课程待选(通过for each访问)：");

6. for(Object obj:coursesToSelect) {

7. Course cr =(Course) obj;

8. System.out.println("课程："+cr.id+":"+cr.name);

9. }

10. }

11. public static void main (String[]args) {

12. ListTest It = new ListTest();

13. It.testAdd();

14. It.testGet();

15. It.testIterator();

16. It.testForEach();

17. }

18. }

运行结果：

课程修改

修改list中的元素

代码：

1. /*

2. * 修改List中的元素

3. */

4. public void testModify() {

6. coursesToSelect.set(4, new Course("7","毛概"));

7. }

8. public static void main (String[]args) {

9. ListTest It = new ListTest();

10. It.testAdd();

11. It.testGet();

12. It.testIterator();

13. It.testForEach();

14. It.testModify();

15. It.testForEach();

16. }

17. }

 运行结果：

课程删除

删除方法

remove方法 （取得某个位置的元素）

代码：

1. /*

2. * 删除List中的元素

3. */

4. public void testRemove() {

5. Course cr =(Course) coursesToSelect.get(4);

6. System.out.println("我是课程："+cr.id+":"+cr.name+"我即将被删除");

7. coursesToSelect.remove(cr);

8. System.out.println("成功删除课程！");

9. testForEach();

10. }

11. public static void main (String[]args) {

12. ListTest It = new ListTest();

13. It.testAdd();

14. It.testGet();

15. It.testIterator();

16. It.testForEach();

17. It.testModify();

18. It.testForEach();

19. It.testRemove();

20. }

21. }

 运行结果：

remove方法（传入指令索引位置） 

1. public void testRemove() {

2. //Course cr =(Course) coursesToSelect.get(4);

3. System.out.println("即将删除4位置上的课程");

4. coursesToSelect.remove(4);

5. System.out.println("成功删除课程！");

6. testForEach();

7. }

8. public static void main (String[]args) {

9. ListTest It = new ListTest();

10. It.testAdd();

11. It.testGet();

12. It.testIterator();

13. It.testForEach();

14. It.testModify();

15. It.testForEach();

16. It.testRemove();

17. }

18. }

 运行结果和上一个方法一样

 removeALL方法

代码：

1. /*

2. * 删除List中的元素

3. */

4. public void testRemove() {

5. //Course cr =(Course) coursesToSelect.get(4);

6. System.out.println("即将删除4位置和5位置上的课程");

7. Course[] courses = {(Course)coursesToSelect.get(4),(Course)coursesToSelect.get(5)};

8. coursesToSelect.removeAll(Arrays.asList(courses));

9. //coursesToSelect.remove(4);

10. System.out.println("成功删除课程！");

11. testForEach();

12. }

13. public static void main (String[]args) {

14. ListTest It = new ListTest();

15. It.testAdd();

16. It.testGet();

17. It.testIterator();

18. It.testForEach();

19. It.testModify();

20. It.testForEach();

21. It.testRemove();

22. }

 运行结果：

代码：

1. /*

2. * 往List中添加一些奇怪的东西

3. */

4. public void testType() {

5. System.out.println("能否往List中添加一些奇怪的东西呢！？");

6. coursesToSelect.add("我不是课程，我只是一个无辜的字符串!!");

7. }

8. public static void main (String[]args) {

9. ListTest It = new ListTest();

10. It.testAdd();

11. It.testAdd();

12. It.testType();

13. It.testForEach();

14. //It.testGet();

15. //It.testIterator();

16. //It.testForEach();

17. //It.testModify();

18. //It.testForEach();

19. //It.testRemove();

20. }

21. }

运行结果：

泛型

集合中的元素，可以是任意类型的对象（对象的引用）；如果把某个对象放入集合，则会忽略他的类型，而把Object处理。

      泛型则是规定了某个集合只可以存放特定类型的对象，会在编译期间进行类型检查，可以直接按指定类型获取集合元素。

注意：

• 泛型集合可以添加泛型的子类型的对象实例
•  泛型不能使用基本类型
• 泛型集合中，不能添加泛型规定的类型及其子类类型以外的对象，否则会报错
   

1. public class ChildCourse extends Course {

4. }

1. import java.util.ArrayList;

2. import java.util.List;

4. public class TestGeneric {

5. /*

6. * 带有泛型——Course，的List类型属性

7. */

8. public List<Course>courses;

10. public TestGeneric() {

11. this.courses=new ArrayList<Course>();

12. }

14. /*

15. *测试添加

16. */

17. public void testAdd() {

18. Course cr1=new Course("1","大学语文");

19. courses.add(cr1);

20. //泛型集合中，不能添加泛型规定的类型及其子类类型以外的对象，否则会报错！

21. //courses.add("能否添加一些奇怪的东西?");

22. Course cr2=new Course("2","Java基础");

23. courses.add(cr2);

24. }

26. /*

27. * 测试循环遍历

28. */

29. public void testForeach() {

30. for(Course cr:courses) {

31. System.out.println(cr.id+":"+cr.name);

32. }

33. }

35. /*

36. * 泛型集合可以添加泛型的子类型的对象实例

37. */

38. public void testChild() {

39. ChildCourse ccr=new ChildCourse();

40. ccr.id="3";

41. ccr.name="我是子类型的课程对象实例~";

42. courses.add(ccr);

43. }

46. /*

47. * 泛型不能使用基本类型

48. */

49. public void testBasicType() {

50. List<Integer>list=new ArrayList<Integer>();

51. list.add(1);

52. System.out.println("基本类型必须使用包装类作为泛型！"+list.get(0));

53. }

56. public static void main(String[] args) {

57. TestGeneric tg=new TestGeneric();

58. tg.testAdd();

59. tg.testForeach();

60. tg.testChild();

61. tg.testForeach();

62. tg.testBasicType();

64. }

65. }

运行结果：

Set接口及其实现类

 

1. Set是元素无序并且不可以重复的集合，被称为集合
2. HashSet——哈希集，是Set的一个重要实现类 
3. Set中，添加某个对象，无论添加多少次， 最终只会保留一个该对象（的引用）， 并且保留的是第一次添加的那个

代码：

1. import java.util.ArrayList;

2. import java.util.Arrays;

3. import java.util.List;

4. import java.util.Scanner;

6. public class SetTest {

8. public List<Course>coursesToSelect;

10. public SetTest() {

11. coursesToSelect=new ArrayList<Course>();

12. }

14. public void testAdd() {

15. Course cr1=new Course("1","数据结构");

16. coursesToSelect.add(cr1);

17. Course temp=(Course)coursesToSelect.get(0);

20. Course cr2=new Course("2","C语言");

21. coursesToSelect.add(0,cr2);

22. Course temp2=(Course)coursesToSelect.get(0);

27. Course[] course={new Course("3","离散数学"),new Course("4","汇编语言")};

28. coursesToSelect.addAll(Arrays.asList(course));

29. Course temp3=(Course)coursesToSelect.get(2);

30. Course temp4=(Course)coursesToSelect.get(3);

31. System.out.println("添加了课程："+temp3.id+":"+temp3.name+";"

32. +temp4.id+":"+temp4.name);

34. Course[] course2={new Course("5","高等数学"),new Course("6","大学英语")};

35. coursesToSelect.addAll(2,Arrays.asList(course2));

36. Course temp5=(Course)coursesToSelect.get(2);

37. Course temp6=(Course)coursesToSelect.get(3);

39. }

42. /*

43. * 通过foreach方法访问集合元素

44. */

45. public void testForeach() {

46. System.out.println("有如下课程待选(通过foreach访问)：");

47. for(Object obj:coursesToSelect) {

48. Course cr=(Course)obj;

49. System.out.println("课程："+cr.id+":"+cr.name);

50. }

51. }

54. public static void main(String[] args) {

55. SetTest st=new SetTest();

56. st.testAdd();

57. st.testForeach();

58. //创建一个学生对象

59. Student student=new Student("1","小明");

60. System.out.println("欢迎学生："+student.name+"选课！");

61. //创建一个Scanner对象，用来接受从键盘输入的课程ID

62. Scanner console=new Scanner(System.in);

64. for(int i=0;i<3;i++) {

65. System.out.println("请输入课程ID");

66. String courseId=console.next();

67. for(Course cr:st.coursesToSelect) {

68. if(cr.id.equals(courseId)) {

69. student.courses.add(cr);

70. /*

71. * Set中，添加某个对象，无论添加多少次

72. * 最终只会保留一个该对象（的引用）

73. * 并且，保留的是第一次添加的那个

74. */

75. }

76. }

77. }

79. st.testForeachSet(student);

80. }

82. public void testForeachSet(Student student) {

83. //打印出输出，学生所选课程！

84. for(Course cr:student.courses) {

85. System.out.println("选择了课程："+cr.id+":"+cr.name);

86. }

88. }

89. }

运行结果：

Map&HashMap

Map接口

• Map提供了一种映射关系，其中的元素是以键值对(key-value)的形式存储的，能够实现根据key快速查找value
• Map中的键值对以Entry类型的对象实例形式存在
• 键（key值）不可以重复，value值可以
• 每个键最多只能映射到一个值
• Map接口提供了分别返回key值集合、value值集合以及Entry(j键值对）集合的方法
• Map支持泛型，形式如：Map<K,V>
   

HashMap

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

1. import java.util.HashMap;

2. import java.util.Map;

3. import java.util.Scanner;

4. import java.util.Set;

6. public class MapTest {

8. /*用来承装学生类型对象

9. *

10. */

11. public Map<String,Student>students;

12. public Student newStudent;

14. /*

15. * 构造器中初始化student属性

16. */

17. public MapTest() {

18. this.students=new HashMap<String,Student>();

19. }

21. /*

22. * 测试添加：输入学生ID，判断是否被占用

23. * 若未被占用，则输入姓名，创建新学生，并且

24. * 添加到student中

25. */

26. public void testPut() {

27. //创建一个Scanner对象，用来获取输入的学生ID和姓名

28. Scanner console=new Scanner(System.in);

29. int i=0;

30. while(i<3) {

31. System.out.println("请输入学生ID：");

32. String ID=console.next();

33. //判断该ID是否被占用

34. Student st=students.get(ID);

35. if(st==null) {

36. //提示输入学生姓名

37. System.out.println("请输入学生姓名：");

38. String name=console.next();

39. //创建新的学生对象

40. Student newStuent=new Student(ID,name);

41. //通过调用students的put方法，添加ID-学生映射

42. students.put(ID,newStudent);

43. System.out.println("成功添加学生："+students.get(ID).name);

44. i++;

45. }else {

46. System.out.println("该学生ID已被占用！");

47. continue;

48. }

49. }

50. }

52. /*

53. * 测试Map的keySet方法

54. */

55. public void testKeySet() {

56. //通过keySet方法，返回Map中的所有"键”的Set集合

57. Set<String>keySet=students.keySet();

58. //取得students的容量

59. System.out.println("总共有："+students.size()+"个学生！");

60. //

62. //遍历keySet,取得每一个键，再调用get方法取得每个键对应的value

63. for(String stuId:keySet) {

64. Student st=students.get(stuId);

65. if(st!=null)

66. System.out.println("学生："+st.name);

67. }

68. }

70. /*

71. * 测试删除Map中的映射

72. */

73. public void testRemove() {

74. //提示输入待删除的学生的ID

75. System.out.println("请输入要删除的学生ID！");

76. //获取从键盘输入的待删除学生ID字符串

77. Scanner console=new Scanner(System.in);

78. while(true) {

79. //提示输入待删除的学生的ID

80. System.out.println("请输入要删除的学生ID！");

81. String ID=console.next();

82. //判断该ID是否有对应的学生对象

83. Student st=students.get(ID);

84. if(st==null) {

85. //提示输入的ID并不存在

86. System.out.println("该ID不存在");

87. continue;

88. }

89. students.remove(ID);

90. System.out.println("成功删除学生："+st.name);

91. break;

92. }

93. }

95. /*

96. * 通过entrySet方法来遍历Map

97. */

98. public void testEntrySet() {

99. //通过entrySet方法，返回Map中的所有键值对

100. Set<Entry<String,Student>>entrySet=students.entrySet();

101. for(Entry<String,Student>entry:entrySey());

102. System.out.println("取得键："+entry.getKey());

103. System.out.println("对应的值为："+entry.getValue());

104. }

106. /*

107. * 利用put方法修改Map中的已有映射

108. */

109. public void testModify() {

110. //提示输入要修改的学生ID

111. System.out.println("请输入要修改的学生ID：");

112. //创建一个Scanner对象，去获取从键盘输入的学生ID字符串

113. Scanner console=new Scanner(System.in);

114. while(true) {

115. //提示输入待删除的学生的ID

116. String ID=console.next();

117. //判断该ID是否有对应的学生对象

118. Student student=students.get(ID);

119. if(student==null) {

120. //提示输入的ID并不存在

121. System.out.println("该ID不存在！请重新输入！");

122. continue;

123. }

124. //提示当前对应的学生对象的姓名

125. System.out.println("当前该学生ID，所对应的学生为："+student.name);

126. String name=console.next();

127. Student newStudent=new Student(stuID,name);

128. students.put(stuID, newStudent);

129. System.out.println("修改成功！");

130. break;

132. }

133. }

134. public static void main(String[] args) {

135. MapTest mt=new MapTest();

136. mt.testPut();

137. mt.testKeySet();

138. mt.testRemove();

139. mt.testEntrySet();

140. mt.testModify();

141. mt.testEntrySet();

143. }

144. }

判断List中课程是否存在 

判断Set中课程是否存在

判断Map中是否包含某个key值或者某个value值

Collections工具类 

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

sort()(排序）方法

代码：

1. import java.util.ArrayList;

2. import java.util.Collections;

3. import java.util.List;

4. import java.util.Random;

6. /*

7. * 将要完成：

8. * 1、通过Collections.sort()方法，对Integer泛型的List进行排序；

9. * 2、对String泛型的List进行排序；

10. * 3、对其他类型泛型的List进序，以Student为例。

11. */

12. public class CollectionsTest {

14. /*

15. * 1、通过Collections.sort()方法，对Integer泛型的List进行排序；

16. * 创建一个Integer泛型的List,插入十个100以内的不重复随机整数，

17. * 调用Collections.sort()方法对其进行排序

18. */

19. public void testSort1() {

20. List<Integer>integerList=new ArrayList<Integer>();

21. //插入十个1001以内的不重复随机数

22. Random random=new Random();

23. Integer k;

24. for(int i=0;i<10;i++) {

25. do {

26. k=random.nextInt(100);

27. }while(integerList.contains(k));

28. integerList.add(k);

29. System.out.println("成功添加整数："+k);

30. }

31. System.out.println("-------排序前-------");

32. for(Integer integer:integerList) {

33. System.out.println("元素："+integer);

34. }

35. Collections.sort(integerList);

36. System.out.println("-------排序后-------");

37. for(Integer integer:integerList) {

38. System.out.println("元素："+integer);

39. }

40. }

42. /*

43. * 2、对String泛型的List进行排序；

44. * 创建String泛型List,添加三个乱序的String元素，

45. * 调用sort方法，再次输出排序后的顺序

46. */

47. public void testSort2() {

48. List<String>stringList=new ArrayList<String>();

49. stringList.add("microsoft");

50. stringList.add("google");

51. stringList.add("lenovo");

52. System.out.println("------排序前------");

53. for(String string:stringList) {

54. System.out.println("元素："+string);

55. }

56. Collections.sort(stringList);

57. System.out.println("------排序后------");

58. for(String string:stringList) {

59. System.out.println("元素："+string);

61. }

62. }

63. public static void main(String[] args) {

64. CollectionsTest ct=new CollectionsTest();

65. ct.testSort1();

66. ct.testSort2();

67. }

68. }

运行结果：

 Comparable接口——可比较的

• 实现该接口表示：这个类的实例可以比较大小，可以进行自然排序
• 定义了默认的比较规则
• 其实现实需要实现compara To()方法
• compara To()方法返回正数表示大，负数表示小，0表示相等

Comparator接口——比较工具接口

• 用于定于临时比较规则，而不是默认比较规则
• 其实现类需要实现compara ()方法
•  Comparator和Comparable都是Java集合框架的成员