• 学生选课——判断Set中课程是否存在

  1. package com.imooc.collection;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Scanner;
  8.  
  9. public class SetTest {
  10.  
  11. public List<Course>coursesToSelect;
  12. public SetTest(){
  13. coursesToSelect=new ArrayList<Course>();
  14. }
  15.  
  16. //用于往CourseToSelect中添加备选课程
  17. public void testAdd(){
  18. //创建一个课程对象,并通过调用add方法,添加到备选课程List中
  19. Course c=new Course("1","数据结构");
  20. coursesToSelect.add(c);
  21. Course temp=(Course) coursesToSelect.get(0);
  22. //System.out.println("添加了一门课程"+temp.id+":"+temp.name);
  23.  
  24. Course c1=new Course("2","C语言");
  25. coursesToSelect.add(0, c1);
  26. Course temp1=(Course) coursesToSelect.get(0);
  27. //System.out.println("添加一门课程:"+temp1.id+":"+temp1.name);
  28.  
  29. Course cq=new Course("1","数据结构");
  30. coursesToSelect.add(cq);
  31. Course temp0=(Course) coursesToSelect.get(2);
  32. //System.out.println("添加了一门课程"+temp0.id+":"+temp0.name);
  33.  
  34. /*Course c2=new Course("2","Test1");
  35. CourseToSelect.add(4, c2);*/
  36. Course[] course={new Course("3","离散数学"),new Course("4","汇编语言")};
  37. coursesToSelect.addAll(Arrays.asList(course));
  38. Course temp2=(Course) coursesToSelect.get(2);
  39. Course temp3=(Course) coursesToSelect.get(3);
  40. //System.out.println("添加了两门课程:"+temp2.id+":"+temp2.name+";"+temp3.id+":"+temp3.name);
  41.  
  42. Course[] course2={new Course("5","高等数学"),new Course("6","数字逻辑")};
  43. coursesToSelect.addAll(2, Arrays.asList(course2));
  44. Course temp4=(Course) coursesToSelect.get(2);
  45. Course temp5=(Course) coursesToSelect.get(3);
  46. //System.out.println("添加了两门课程:"+temp4.id+":"+temp4.name+";"+temp5.id+":"+temp5.name);
  47.  
  48. }
  49.  
  50. /* * 取得List中的元素的方法
  51. **/
  52. /*public void testGet(){
  53. System.out.println("有如下课程待选:");
  54. int size=coursesToSelect.size();
  55. for (int i = 0; i < size; i++) {
  56. Course cr=(Course) coursesToSelect.get(i);
  57. System.out.println("课程:"+cr.id+":"+cr.name);
  58. }
  59. }
  60. */
  61.  
  62. /* * 通过迭代器来遍历List
  63. * */
  64. /*public void testIterator(){
  65. //通过集合iterator方法,取得迭代器实例
  66. Iterator it=coursesToSelect.iterator();
  67. System.out.println("有如下课程待选(通过迭代器访问):");
  68. while (it.hasNext()) {
  69. Course cr = (Course) it.next();
  70. System.out.println("课程:"+cr.id+":"+cr.name);
  71. }
  72. }*/
  73.  
  74. /*测试List的contains方法*/
  75. public void testListContains(){
  76. //取得被选课程序列的第0个元素
  77. Course course=coursesToSelect.get(0);
  78. //打印输出courseToSelect 是否包含course对象
  79. System.out.println("取得课程"+course.name);
  80. System.out.println("被选课程中是否包含课程"+course.name+","+coursesToSelect.contains(course));
  81. //创建一个新的课程对象,ID和名称,与course对象完全一样
  82. Course course2=new Course(course.id,course.name);
  83. System.out.println("新创建课程:"+course2.name);
  84. System.out.println("备选课程中是否包含课程:"+course2.name+","+coursesToSelect.contains(course2));
  85.  
  86. }
  87.  
  88. /** 通过for each方法访问集合元素
  89. *
  90. * */
  91.  
  92. /*public void testForEach(){
  93. System.out.println("有如下课程待选(通过 for each访问):");
  94. for (Object object : coursesToSelect) {
  95. Course cr=(Course) object;
  96. System.out.println("课程:"+cr.id+":"+cr.name);
  97. }
  98. }*/
  99.  
  100. /**
  101. * @param argsS
  102. */
  103. public static void main(String[] args) {
  104. // TODO Auto-generated method stub
  105. SetTest st=new SetTest();
  106. st.testAdd();
  107. st.testListContains();
  108.  
  109. /*st.testForEach();
  110. //创建一个学生对象
  111. Student student=new Student("1","小明");
  112. System.out.println("欢迎学生"+student.name+"选课");
  113. //创建一个Scanner对象,用来接收从键盘输入的课程ID
  114. Scanner console=new Scanner(System.in);
  115. for (int i = 0; i < 3; i++) {
  116. System.out.println("请输入课程ID");
  117. String courseId=console.next();
  118. for (Course cr : st.coursesToSelect) {
  119. if (cr.id.equals(courseId)) {
  120. student.courses.add(cr);
  121. Set中添加某个对象,无论添加杜少次,
  122. * 最终只会保留一个该对象(的引用)
  123. * 并且,保留的是第一次添加的那一个
  124. //student.courses.add(null);
  125. //student.courses.add(cr);
  126. }
  127. }
  128. }
  129. st.testForEachForSet(student); */
  130. }
  131.  
  132. /*public void testForEachForSet(Student student){
  133. //打印输出,学生所选的课程
  134. System.out.println("共选择了"+student.courses.size()+"门课程!");
  135. for(Course cr:student.courses){
  136. System.out.println("选择了课程"+cr.id+":"+"cr.name");
  137.  
  138. }
  139.  
  140. }*/
  141. }

第一种方法:

  1. package com.imooc.collection;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Scanner;
  8.  
  9. public class SetTest {
  10.  
  11. public List<Course>coursesToSelect;
  12. public SetTest(){
  13. coursesToSelect=new ArrayList<Course>();
  14. }
  15.  
  16. //用于往CourseToSelect中添加备选课程
  17. public void testAdd(){
  18. //创建一个课程对象,并通过调用add方法,添加到备选课程List中
  19. Course c=new Course("1","数据结构");
  20. coursesToSelect.add(c);
  21. Course temp=(Course) coursesToSelect.get(0);
  22. //System.out.println("添加了一门课程"+temp.id+":"+temp.name);
  23.  
  24. Course c1=new Course("2","C语言");
  25. coursesToSelect.add(0, c1);
  26. Course temp1=(Course) coursesToSelect.get(0);
  27. //System.out.println("添加一门课程:"+temp1.id+":"+temp1.name);
  28.  
  29. Course cq=new Course("1","数据结构");
  30. coursesToSelect.add(cq);
  31. Course temp0=(Course) coursesToSelect.get(2);
  32. //System.out.println("添加了一门课程"+temp0.id+":"+temp0.name);
  33.  
  34. /*Course c2=new Course("2","Test1");
  35. CourseToSelect.add(4, c2);*/
  36. Course[] course={new Course("3","离散数学"),new Course("4","汇编语言")};
  37. coursesToSelect.addAll(Arrays.asList(course));
  38. Course temp2=(Course) coursesToSelect.get(2);
  39. Course temp3=(Course) coursesToSelect.get(3);
  40. //System.out.println("添加了两门课程:"+temp2.id+":"+temp2.name+";"+temp3.id+":"+temp3.name);
  41.  
  42. Course[] course2={new Course("5","高等数学"),new Course("6","数字逻辑")};
  43. coursesToSelect.addAll(2, Arrays.asList(course2));
  44. Course temp4=(Course) coursesToSelect.get(2);
  45. Course temp5=(Course) coursesToSelect.get(3);
  46. //System.out.println("添加了两门课程:"+temp4.id+":"+temp4.name+";"+temp5.id+":"+temp5.name);
  47.  
  48. }
  49.  
  50. /* * 取得List中的元素的方法
  51. **/
  52. /*public void testGet(){
  53. System.out.println("有如下课程待选:");
  54. int size=coursesToSelect.size();
  55. for (int i = 0; i < size; i++) {
  56. Course cr=(Course) coursesToSelect.get(i);
  57. System.out.println("课程:"+cr.id+":"+cr.name);
  58. }
  59. }
  60. */
  61.  
  62. /* * 通过迭代器来遍历List
  63. * */
  64. /*public void testIterator(){
  65. //通过集合iterator方法,取得迭代器实例
  66. Iterator it=coursesToSelect.iterator();
  67. System.out.println("有如下课程待选(通过迭代器访问):");
  68. while (it.hasNext()) {
  69. Course cr = (Course) it.next();
  70. System.out.println("课程:"+cr.id+":"+cr.name);
  71. }
  72. }*/
  73.  
  74. /*测试List的contains方法*/
  75. public void testListContains(){
  76. //取得被选课程序列的第0个元素
  77. Course course=coursesToSelect.get(0);
  78. //打印输出courseToSelect 是否包含course对象
  79. System.out.println("取得课程"+course.name);
  80. System.out.println("被选课程中是否包含课程"+course.name+","+coursesToSelect.contains(course));
  81. //创建一个新的课程对象,ID和名称,与course对象完全一样
  82. Course course2=new Course(course.id,course.name);
  83. System.out.println("新创建课程:"+course2.name);
  84. System.out.println("备选课程中是否包含课程:"+course2.name+","+coursesToSelect.contains(course2));
  85.  
  86. }
  87.  
  88. /** 通过for each方法访问集合元素
  89. *
  90. * */
  91.  
  92. /*public void testForEach(){
  93. System.out.println("有如下课程待选(通过 for each访问):");
  94. for (Object object : coursesToSelect) {
  95. Course cr=(Course) object;
  96. System.out.println("课程:"+cr.id+":"+cr.name);
  97. }
  98. }*/
  99.  
  100. /**
  101. * @param argsS
  102. */
  103. public static void main(String[] args) {
  104. // TODO Auto-generated method stub
  105. SetTest st=new SetTest();
  106. st.testAdd();
  107. st.testListContains();
  108.  
  109. /*st.testForEach();
  110. //创建一个学生对象
  111. Student student=new Student("1","小明");
  112. System.out.println("欢迎学生"+student.name+"选课");
  113. //创建一个Scanner对象,用来接收从键盘输入的课程ID
  114. Scanner console=new Scanner(System.in);
  115. for (int i = 0; i < 3; i++) {
  116. System.out.println("请输入课程ID");
  117. String courseId=console.next();
  118. for (Course cr : st.coursesToSelect) {
  119. if (cr.id.equals(courseId)) {
  120. student.courses.add(cr);
  121. Set中添加某个对象,无论添加杜少次,
  122. * 最终只会保留一个该对象(的引用)
  123. * 并且,保留的是第一次添加的那一个
  124. //student.courses.add(null);
  125. //student.courses.add(cr);
  126. }
  127. }
  128. }
  129. st.testForEachForSet(student); */
  130. }
  131.  
  132. /*public void testForEachForSet(Student student){
  133. //打印输出,学生所选的课程
  134. System.out.println("共选择了"+student.courses.size()+"门课程!");
  135. for(Course cr:student.courses){
  136. System.out.println("选择了课程"+cr.id+":"+"cr.name");
  137.  
  138. }
  139.  
  140. }*/
  141. }

第二种方法

  1. package com.imooc.collection;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Scanner;
  8.  
  9. public class SetTest {
  10.  
  11. public List<Course>coursesToSelect;
  12.  
  13. private Scanner console;
  14.  
  15. public SetTest(){
  16. coursesToSelect=new ArrayList<Course>();
  17. console=new Scanner(System.in);
  18. }
  19.  
  20. //用于往CourseToSelect中添加备选课程
  21. public void testAdd(){
  22. //创建一个课程对象,并通过调用add方法,添加到备选课程List中
  23. Course c=new Course("1","数据结构");
  24. coursesToSelect.add(c);
  25. Course temp=(Course) coursesToSelect.get(0);
  26. //System.out.println("添加了一门课程"+temp.id+":"+temp.name);
  27.  
  28. Course c1=new Course("2","C语言");
  29. coursesToSelect.add(0, c1);
  30. Course temp1=(Course) coursesToSelect.get(0);
  31. //System.out.println("添加一门课程:"+temp1.id+":"+temp1.name);
  32.  
  33. Course cq=new Course("1","数据结构");
  34. coursesToSelect.add(cq);
  35. Course temp0=(Course) coursesToSelect.get(2);
  36. //System.out.println("添加了一门课程"+temp0.id+":"+temp0.name);
  37.  
  38. /*Course c2=new Course("2","Test1");
  39. CourseToSelect.add(4, c2);*/
  40. Course[] course={new Course("3","离散数学"),new Course("4","汇编语言")};
  41. coursesToSelect.addAll(Arrays.asList(course));
  42. Course temp2=(Course) coursesToSelect.get(2);
  43. Course temp3=(Course) coursesToSelect.get(3);
  44. //System.out.println("添加了两门课程:"+temp2.id+":"+temp2.name+";"+temp3.id+":"+temp3.name);
  45.  
  46. Course[] course2={new Course("5","高等数学"),new Course("6","数字逻辑")};
  47. coursesToSelect.addAll(2, Arrays.asList(course2));
  48. Course temp4=(Course) coursesToSelect.get(2);
  49. Course temp5=(Course) coursesToSelect.get(3);
  50. //System.out.println("添加了两门课程:"+temp4.id+":"+temp4.name+";"+temp5.id+":"+temp5.name);
  51.  
  52. }
  53.  
  54. /* * 取得List中的元素的方法
  55. **/
  56. /*public void testGet(){
  57. System.out.println("有如下课程待选:");
  58. int size=coursesToSelect.size();
  59. for (int i = 0; i < size; i++) {
  60. Course cr=(Course) coursesToSelect.get(i);
  61. System.out.println("课程:"+cr.id+":"+cr.name);
  62. }
  63. }
  64. */
  65.  
  66. /* * 通过迭代器来遍历List
  67. * */
  68. /*public void testIterator(){
  69. //通过集合iterator方法,取得迭代器实例
  70. Iterator it=coursesToSelect.iterator();
  71. System.out.println("有如下课程待选(通过迭代器访问):");
  72. while (it.hasNext()) {
  73. Course cr = (Course) it.next();
  74. System.out.println("课程:"+cr.id+":"+cr.name);
  75. }
  76. }*/
  77.  
  78. /*测试List的contains方法*/
  79. public void testListContains(){
  80. //取得被选课程序列的第0个元素
  81. Course course=coursesToSelect.get(0);
  82. //打印输出courseToSelect 是否包含course对象
  83. System.out.println("取得课程"+course.name);
  84. System.out.println("被选课程中是否包含课程"+course.name+","+coursesToSelect.contains(course));
  85.  
  86. //提示输入课程名称
  87. System.out.println("请输入课程名称");
  88. String name=console.next();
  89. //创建一个新的课程对象,ID和名称,与course对象完全一样
  90. Course course2=new Course();//无参构造方法
  91. course2.name=name;
  92. System.out.println("新创建课程:"+course2.name);
  93. System.out.println("备选课程中是否包含课程:"+course2.name+","+coursesToSelect.contains(course2));
  94.  
  95. }
  96.  
  97. /** 通过for each方法访问集合元素
  98. *
  99. * */
  100.  
  101. /*public void testForEach(){
  102. System.out.println("有如下课程待选(通过 for each访问):");
  103. for (Object object : coursesToSelect) {
  104. Course cr=(Course) object;
  105. System.out.println("课程:"+cr.id+":"+cr.name);
  106. }
  107. }*/
  108.  
  109. /**
  110. * @param argsS
  111. */
  112. public static void main(String[] args) {
  113. // TODO Auto-generated method stub
  114. SetTest st=new SetTest();
  115. st.testAdd();
  116. st.testListContains();
  117.  
  118. /*st.testForEach();
  119. //创建一个学生对象
  120. Student student=new Student("1","小明");
  121. System.out.println("欢迎学生"+student.name+"选课");
  122. //创建一个Scanner对象,用来接收从键盘输入的课程ID
  123. Scanner console=new Scanner(System.in);
  124. for (int i = 0; i < 3; i++) {
  125. System.out.println("请输入课程ID");
  126. String courseId=console.next();
  127. for (Course cr : st.coursesToSelect) {
  128. if (cr.id.equals(courseId)) {
  129. student.courses.add(cr);
  130. Set中添加某个对象,无论添加杜少次,
  131. * 最终只会保留一个该对象(的引用)
  132. * 并且,保留的是第一次添加的那一个
  133. //student.courses.add(null);
  134. //student.courses.add(cr);
  135. }
  136. }
  137. }
  138. st.testForEachForSet(student); */
  139. }
  140.  
  141. /*public void testForEachForSet(Student student){
  142. //打印输出,学生所选的课程
  143. System.out.println("共选择了"+student.courses.size()+"门课程!");
  144. for(Course cr:student.courses){
  145. System.out.println("选择了课程"+cr.id+":"+"cr.name");
  146.  
  147. }
  148.  
  149. }*/
  150. }

测试

  1. package com.imooc.collection;
  2.  
  3. /*
  4. * 课程类
  5. * */
  6. public class Course {
  7. public String id;
  8. public String name;
  9.  
  10. public Course(String id, String name) {
  11. this.id = id;
  12. this.name = name;
  13. }
  14.  
  15. public Course() {
  16.  
  17. }
  18.  
  19. //重写某个类的 equals方法来判断模板
  20. @Override
  21. public boolean equals(Object obj) {
  22.  
  23. if (this == obj) {
  24. return true;
  25. }
  26.  
  27. if (obj == null) {
  28. return false;
  29. }
  30.  
  31. if (!(obj instanceof Course)) {
  32. return false;
  33. }
  34.  
  35. Course course = (Course) obj;
  36. if (this.name == null) {
  37. if (course.name == null) {
  38. return true;
  39. } else {
  40. return false;
  41. }
  42. } else {
  43. if (this.name.equals(course.name)) {
  44. return true;
  45. } else {
  46. return false;
  47. }
  48.  
  49. }
  50.  
  51. }
  52.  
  53. }

运行结果为:

  • 学生选课——判断Set中课程是否存在

                                                                          图片(1)

                                                                                图片(2)

  1. package com.imooc.collection;
  2.  
  3. /*
  4. * 课程类
  5. * */
  6. public class Course {
  7. public String id;
  8. public String name;
  9.  
  10. public Course(String id, String name) {
  11. this.id = id;
  12. this.name = name;
  13. }
  14.  
  15. public Course() {
  16.  
  17. }
  18.  
  19. @Override
  20. public int hashCode() {
  21. final int prime = 31;
  22. int result = 1;
  23. result = prime * result + ((name == null) ? 0 : name.hashCode());
  24. return result;
  25. }
  26.  
  27. @Override
  28. public boolean equals(Object obj) {
  29. if (this == obj)
  30. return true;
  31. if (obj == null)
  32. return false;
  33. if (!(obj instanceof Course))
  34. return false;
  35. Course other = (Course) obj;
  36. if (name == null) {
  37. if (other.name != null)
  38. return false;
  39. } else if (!name.equals(other.name))
  40. return false;
  41. return true;
  42. }
  43.  
  44. }
  1. package com.imooc.collection;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Scanner;
  8.  
  9. public class SetTest {
  10.  
  11. public List<Course>coursesToSelect;
  12.  
  13. private Scanner console;
  14. public Student student;
  15. public SetTest(){
  16. coursesToSelect=new ArrayList<Course>();
  17. console=new Scanner(System.in);
  18. }
  19.  
  20. //用于往CourseToSelect中添加备选课程
  21. public void testAdd(){
  22. //创建一个课程对象,并通过调用add方法,添加到备选课程List中
  23. Course c=new Course("1","数据结构");
  24. coursesToSelect.add(c);
  25. Course temp=(Course) coursesToSelect.get(0);
  26. //System.out.println("添加了一门课程"+temp.id+":"+temp.name);
  27.  
  28. Course c1=new Course("2","C语言");
  29. coursesToSelect.add(0, c1);
  30. Course temp1=(Course) coursesToSelect.get(0);
  31. //System.out.println("添加一门课程:"+temp1.id+":"+temp1.name);
  32.  
  33. Course cq=new Course("1","数据结构");
  34. coursesToSelect.add(cq);
  35. Course temp0=(Course) coursesToSelect.get(2);
  36. //System.out.println("添加了一门课程"+temp0.id+":"+temp0.name);
  37.  
  38. /*Course c2=new Course("2","Test1");
  39. CourseToSelect.add(4, c2);*/
  40. Course[] course={new Course("3","离散数学"),new Course("4","汇编语言")};
  41. coursesToSelect.addAll(Arrays.asList(course));
  42. Course temp2=(Course) coursesToSelect.get(2);
  43. Course temp3=(Course) coursesToSelect.get(3);
  44. //System.out.println("添加了两门课程:"+temp2.id+":"+temp2.name+";"+temp3.id+":"+temp3.name);
  45.  
  46. Course[] course2={new Course("5","高等数学"),new Course("6","数字逻辑")};
  47. coursesToSelect.addAll(2, Arrays.asList(course2));
  48. Course temp4=(Course) coursesToSelect.get(2);
  49. Course temp5=(Course) coursesToSelect.get(3);
  50. //System.out.println("添加了两门课程:"+temp4.id+":"+temp4.name+";"+temp5.id+":"+temp5.name);
  51.  
  52. }
  53.  
  54. /* * 取得List中的元素的方法
  55. **/
  56. /*public void testGet(){
  57. System.out.println("有如下课程待选:");
  58. int size=coursesToSelect.size();
  59. for (int i = 0; i < size; i++) {
  60. Course cr=(Course) coursesToSelect.get(i);
  61. System.out.println("课程:"+cr.id+":"+cr.name);
  62. }
  63. }
  64. */
  65.  
  66. /* * 通过迭代器来遍历List
  67. * */
  68. /*public void testIterator(){
  69. //通过集合iterator方法,取得迭代器实例
  70. Iterator it=coursesToSelect.iterator();
  71. System.out.println("有如下课程待选(通过迭代器访问):");
  72. while (it.hasNext()) {
  73. Course cr = (Course) it.next();
  74. System.out.println("课程:"+cr.id+":"+cr.name);
  75. }
  76. }
  77. */
  78.  
  79. /*测试List的contains方法*/
  80. /*public void testListContains(){
  81. //取得被选课程序列的第0个元素
  82. Course course=coursesToSelect.get(0);
  83. //打印输出courseToSelect 是否包含course对象
  84. System.out.println("取得课程"+course.name);
  85. System.out.println("被选课程中是否包含课程"+course.name+","+coursesToSelect.contains(course));
  86.  
  87. //提示输入课程名称
  88. System.out.println("请输入课程名称");
  89. String name=console.next();
  90. //创建一个新的课程对象,ID和名称,与course对象完全一样
  91. Course course2=new Course();//无参构造方法
  92. course2.name=name;
  93. System.out.println("新创建课程:"+course2.name);
  94. System.out.println("备选课程中是否包含课程:"+course2.name+","+coursesToSelect.contains(course2));
  95.  
  96. }
  97. */
  98.  
  99. /** 通过for each方法访问集合元素
  100. *
  101. * */
  102.  
  103. public void testForEach(){
  104. System.out.println("有如下课程待选(通过 for each访问):");
  105. for (Object object : coursesToSelect) {
  106. Course cr=(Course) object;
  107. System.out.println("课程:"+cr.id+":"+cr.name);
  108. }
  109. }
  110.  
  111. //创建学生对象并选课
  112. public void createStudentAndSelectCours() {
  113. // 创建一个学生对象
  114. student = new Student("1", "小明");
  115. System.out.println("欢迎学生" + student.name + "选课");
  116. // 创建一个Scanner对象,用来接收从键盘输入的课程ID
  117. Scanner console = new Scanner(System.in);
  118. for (int i = 0; i < 3; i++) {
  119. System.out.println("请输入课程ID");
  120. String courseId = console.next();
  121. for (Course cr : coursesToSelect) {
  122. if (cr.id.equals(courseId)) {
  123. student.courses.add(cr);
  124. }
  125. }
  126. }
  127.  
  128. }
  129.  
  130. /*测试Set的contains方法*/
  131. public void testSetContains() {
  132. // 提示输入课程名称
  133. System.out.println("请输入课程名称");
  134. String name = console.next();
  135. // 创建一个新的课程对象,ID和名称,与course对象完全一样
  136. Course course2 = new Course();// 无参构造方法
  137. course2.name = name;
  138. System.out.println("新创建课程:" + course2.name);
  139. System.out.println("备选课程中是否包含课程:" + course2.name + ","
  140. + student.courses.contains(course2));
  141.  
  142. }
  143.  
  144. /**
  145. * @param argsS
  146. */
  147. public static void main(String[] args) {
  148. // TODO Auto-generated method stub
  149. SetTest st=new SetTest();
  150. st.testAdd();
  151. //st.testListContains();
  152. st.createStudentAndSelectCours();
  153. st.testSetContains();
  154. /*st.testGet();
  155. st.testIterator();*/
  156.  
  157. st.testForEach();
  158. //创建一个学生对象
  159. /*Student student=new Student("1","小明");
  160. System.out.println("欢迎学生"+student.name+"选课");
  161. //创建一个Scanner对象,用来接收从键盘输入的课程ID
  162. Scanner console=new Scanner(System.in);
  163. for (int i = 0; i < 3; i++) {
  164. System.out.println("请输入课程ID");
  165. String courseId=console.next();
  166. for (Course cr : st.coursesToSelect) {
  167. if (cr.id.equals(courseId)) {
  168. student.courses.add(cr);
  169. Set中添加某个对象,无论添加杜少次,
  170. * 最终只会保留一个该对象(的引用)
  171. * 并且,保留的是第一次添加的那一个
  172. //student.courses.add(null);
  173. //student.courses.add(cr);
  174. }
  175. }
  176. }
  177. st.testForEachForSet(student); */
  178. }
  179.  
  180. /*public void testForEachForSet(Student student){
  181. //打印输出,学生所选的课程
  182. System.out.println("共选择了"+student.courses.size()+"门课程!");
  183. for(Course cr:student.courses){
  184. System.out.println("选择了课程"+cr.id+":"+"cr.name");
  185.  
  186. }
  187.  
  188. }*/
  189. }

运行结果为:

  • 学生选课——获取List中课程的位置

  1. package com.imooc.collection;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.Iterator;
  6. import java.util.List;
  7. import java.util.Scanner;
  8.  
  9. public class SetTest {
  10.  
  11. public List<Course>coursesToSelect;
  12.  
  13. private Scanner console;
  14. public Student student;
  15. public SetTest(){
  16. coursesToSelect=new ArrayList<Course>();
  17. console=new Scanner(System.in);
  18. }
  19.  
  20. //用于往CourseToSelect中添加备选课程
  21. public void testAdd(){
  22. //创建一个课程对象,并通过调用add方法,添加到备选课程List中
  23. Course c=new Course("1","数据结构");
  24. coursesToSelect.add(c);
  25. Course temp=(Course) coursesToSelect.get(0);
  26. //System.out.println("添加了一门课程"+temp.id+":"+temp.name);
  27.  
  28. Course c1=new Course("2","C语言");
  29. coursesToSelect.add(0, c1);
  30. Course temp1=(Course) coursesToSelect.get(0);
  31. //System.out.println("添加一门课程:"+temp1.id+":"+temp1.name);
  32.  
  33. Course cq=new Course("1","数据结构");
  34. coursesToSelect.add(cq);
  35. Course temp0=(Course) coursesToSelect.get(2);
  36. //System.out.println("添加了一门课程"+temp0.id+":"+temp0.name);
  37.  
  38. /*Course c2=new Course("2","Test1");
  39. CourseToSelect.add(4, c2);*/
  40. Course[] course={new Course("3","离散数学"),new Course("4","汇编语言")};
  41. coursesToSelect.addAll(Arrays.asList(course));
  42. Course temp2=(Course) coursesToSelect.get(2);
  43. Course temp3=(Course) coursesToSelect.get(3);
  44. //System.out.println("添加了两门课程:"+temp2.id+":"+temp2.name+";"+temp3.id+":"+temp3.name);
  45.  
  46. Course[] course2={new Course("5","高等数学"),new Course("6","数字逻辑")};
  47. coursesToSelect.addAll(2, Arrays.asList(course2));
  48. Course temp4=(Course) coursesToSelect.get(2);
  49. Course temp5=(Course) coursesToSelect.get(3);
  50. //System.out.println("添加了两门课程:"+temp4.id+":"+temp4.name+";"+temp5.id+":"+temp5.name);
  51.  
  52. }
  53.  
  54. /* * 取得List中的元素的方法
  55. **/
  56. /*public void testGet(){
  57. System.out.println("有如下课程待选:");
  58. int size=coursesToSelect.size();
  59. for (int i = 0; i < size; i++) {
  60. Course cr=(Course) coursesToSelect.get(i);
  61. System.out.println("课程:"+cr.id+":"+cr.name);
  62. }
  63. }
  64. */
  65.  
  66. /* * 通过迭代器来遍历List
  67. * */
  68. /*public void testIterator(){
  69. //通过集合iterator方法,取得迭代器实例
  70. Iterator it=coursesToSelect.iterator();
  71. System.out.println("有如下课程待选(通过迭代器访问):");
  72. while (it.hasNext()) {
  73. Course cr = (Course) it.next();
  74. System.out.println("课程:"+cr.id+":"+cr.name);
  75. }
  76. }
  77. */
  78.  
  79. /*测试List的contains方法*/
  80. public void testListContains(){
  81. //取得被选课程序列的第0个元素
  82. Course course=coursesToSelect.get(0);
  83. //打印输出courseToSelect 是否包含course对象
  84. System.out.println("取得课程"+course.name);
  85. System.out.println("被选课程中是否包含课程"+course.name+","+coursesToSelect.contains(course));
  86.  
  87. //提示输入课程名称
  88. System.out.println("请输入课程名称");
  89. String name=console.next();
  90. //创建一个新的课程对象,ID和名称,与course对象完全一样
  91. Course course2=new Course();//无参构造方法
  92. course2.name=name;
  93. System.out.println("新创建课程:"+course2.name);
  94. System.out.println("备选课程中是否包含课程:"+course2.name+","+coursesToSelect.contains(course2));
  95.  
  96. //通过indexOf方法来取得某元素的索引位置
  97. if (coursesToSelect.contains(course2)) {
  98. System.out.println("课程:"+course2.name+"的索引位置为:"+coursesToSelect.indexOf(course2));
  99. }
  100. }
  101.  
  102. /** 通过for each方法访问集合元素
  103. *
  104. * */
  105.  
  106. public void testForEach(){
  107. System.out.println("有如下课程待选(通过 for each访问):");
  108. for (Object object : coursesToSelect) {
  109. Course cr=(Course) object;
  110. System.out.println("课程:"+cr.id+":"+cr.name);
  111. }
  112. }
  113.  
  114. //创建学生对象并选课
  115. /*public void createStudentAndSelectCours() {
  116. // 创建一个学生对象
  117. student = new Student("1", "小明");
  118. System.out.println("欢迎学生" + student.name + "选课");
  119. // 创建一个Scanner对象,用来接收从键盘输入的课程ID
  120. Scanner console = new Scanner(System.in);
  121. for (int i = 0; i < 3; i++) {
  122. System.out.println("请输入课程ID");
  123. String courseId = console.next();
  124. for (Course cr : coursesToSelect) {
  125. if (cr.id.equals(courseId)) {
  126. student.courses.add(cr);
  127. }
  128. }
  129. }
  130.  
  131. }*/
  132.  
  133. /*测试Set的contains方法*/
  134. /*public void testSetContains() {
  135. // 提示输入课程名称
  136. System.out.println("请输入课程名称");
  137. String name = console.next();
  138. // 创建一个新的课程对象,ID和名称,与course对象完全一样
  139. Course course2 = new Course();// 无参构造方法
  140. course2.name = name;
  141. System.out.println("新创建课程:" + course2.name);
  142. System.out.println("备选课程中是否包含课程:" + course2.name + ","
  143. + student.courses.contains(course2));
  144.  
  145. }
  146. */
  147.  
  148. /**
  149. * @param argsS
  150. */
  151. public static void main(String[] args) {
  152. // TODO Auto-generated method stub
  153. SetTest st=new SetTest();
  154. st.testAdd();
  155. st.testListContains();
  156. //st.createStudentAndSelectCours();
  157. //st.testSetContains();
  158. /*st.testGet();
  159. st.testIterator();*/
  160.  
  161. st.testForEach();
  162. //创建一个学生对象
  163. /*Student student=new Student("1","小明");
  164. System.out.println("欢迎学生"+student.name+"选课");
  165. //创建一个Scanner对象,用来接收从键盘输入的课程ID
  166. Scanner console=new Scanner(System.in);
  167. for (int i = 0; i < 3; i++) {
  168. System.out.println("请输入课程ID");
  169. String courseId=console.next();
  170. for (Course cr : st.coursesToSelect) {
  171. if (cr.id.equals(courseId)) {
  172. student.courses.add(cr);
  173. Set中添加某个对象,无论添加杜少次,
  174. * 最终只会保留一个该对象(的引用)
  175. * 并且,保留的是第一次添加的那一个
  176. //student.courses.add(null);
  177. //student.courses.add(cr);
  178. }
  179. }
  180. }
  181. st.testForEachForSet(student); */
  182. }
  183.  
  184. /*public void testForEachForSet(Student student){
  185. //打印输出,学生所选的课程
  186. System.out.println("共选择了"+student.courses.size()+"门课程!");
  187. for(Course cr:student.courses){
  188. System.out.println("选择了课程"+cr.id+":"+"cr.name");
  189.  
  190. }
  191.  
  192. }*/
  193. }

运行结果为:

  • 学生选课——判断Map中是否包含指定的key和value
  1. package com.imooc.collection;
  2. /*
  3. * 学生类
  4. * */
  5. import java.util.HashSet;
  6. import java.util.Set;
  7.  
  8. public class Student {
  9. public String id;
  10. public String name;
  11. public Set <Course>courses;//泛型<Course>
  12. @Override
  13. public int hashCode() {
  14. final int prime = 31;
  15. int result = 1;
  16. result = prime * result + ((name == null) ? 0 : name.hashCode());
  17. return result;
  18. }
  19. @Override
  20. public boolean equals(Object obj) {
  21. if (this == obj)
  22. return true;
  23. if (obj == null)
  24. return false;
  25. if (!(obj instanceof Student))
  26. return false;
  27. Student other = (Student) obj;
  28. if (name == null) {
  29. if (other.name != null)
  30. return false;
  31. } else if (!name.equals(other.name))
  32. return false;
  33. return true;
  34. }
  35. public Student(String id,String name){
  36. this.id=id;
  37. this.name=name;
  38. this.courses=new HashSet<Course>();
  39. }
  40.  
  41. }
  1. package com.imooc.collection;
  2. /*
  3. * 学生类
  4. * */
  5. import java.util.HashSet;
  6. import java.util.Set;
  7.  
  8. public class Student {
  9. public String id;
  10. public String name;
  11. public Set <Course>courses;//泛型<Course>
  12. @Override
  13. public int hashCode() {
  14. final int prime = 31;
  15. int result = 1;
  16. result = prime * result + ((name == null) ? 0 : name.hashCode());
  17. return result;
  18. }
  19. @Override
  20. public boolean equals(Object obj) {
  21. if (this == obj)
  22. return true;
  23. if (obj == null)
  24. return false;
  25. if (!(obj instanceof Student))
  26. return false;
  27. Student other = (Student) obj;
  28. if (name == null) {
  29. if (other.name != null)
  30. return false;
  31. } else if (!name.equals(other.name))
  32. return false;
  33. return true;
  34. }
  35. public Student(String id,String name){
  36. this.id=id;
  37. this.name=name;
  38. this.courses=new HashSet<Course>();
  39. }
  40.  
  41. }
  1. package com.imooc.collection;
  2.  
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Map.Entry;
  6. import java.util.Scanner;
  7. import java.util.Set;
  8.  
  9. public class MapTest {
  10. //用来承装学生类型对象
  11. public Map<String,Student>students;
  12. /*在构造器中初始化students属性*/
  13. public MapTest(){
  14. this.students=new HashMap<String,Student>();
  15. }
  16. /**
  17. * 测试添加:输入学生ID,判断是否被占用
  18. * 若薇被占用,则输入姓名,创建新学生对象,并且
  19. * 添加到student中
  20. */
  21. public void testPut(){
  22. Scanner console=new Scanner(System.in);
  23. int i=0;
  24. while (i<3) {
  25. System.out.println("请输入学生ID");
  26. String ID=console.next();
  27. Student st=students.get(ID);
  28. if (st==null) {
  29. //提示输入学生姓名
  30. System.out.println("请输入学生姓名");
  31. String name=console.next();
  32. //添加新的学生对象
  33. Student newStudent=new Student(ID,name);
  34. students.put(ID,newStudent);
  35. System.out.println("成功添加学生:"+students.get(ID).name);
  36. i++;
  37. }else{
  38. System.out.println("该学生ID已被占用");
  39. continue;
  40. }
  41. }
  42. }
  43. /**
  44. * @param args测试Map的keySet方法
  45. */
  46.  
  47. public void testKeySet(){
  48. //keySet方法,返回Map中的所有“键”的Set集合
  49. Set<String> keySet=students.keySet();
  50. //取得student的容量
  51. System.out.println("总共有:"+students.size()+"个学生");
  52. //遍历keySet,取得每一个键,再调用get方法取得每个键对应的value
  53. for (String stuId : keySet) {
  54. Student st=students.get(stuId);
  55. if (st!=null) {
  56. System.out.println("学生"+st.name);
  57. }
  58.  
  59. }
  60. }
  61.  
  62. /**
  63. * 测试删除Map中的映射
  64. */
  65. public void testRemove(){
  66.  
  67. //获取从键盘输入待删除学生ID字符串
  68. Scanner console=new Scanner(System.in);
  69. while (true) {
  70. //提示输入待删除的学生ID
  71. System.out.println("请输入要删除的学生ID");
  72. String ID=console.next();
  73. //判断该ID是否有对应的学生对象
  74. Student st=students.get(ID);
  75. if (st==null) {
  76. //提示输入的ID并不存在
  77. System.out.println("该ID不存在");
  78. continue;
  79. }
  80. students.remove(ID);
  81. System.out.println("成功删除学生"+st.name);
  82. break;
  83. }
  84. }
  85. /**
  86. * 通过entrySet方法来遍历Map
  87. */
  88. public void testEntrySet(){
  89. //通过entrySet方法,返回Map中的所有键值对
  90. Set<Entry<String,Student>> entrySet=students.entrySet();
  91. for (Entry<String, Student> entry : entrySet) {
  92. System.out.println("取得键"+entry.getKey());
  93. System.out.println("对应的职为:"+entry.getValue().name);
  94. }
  95. }
  96.  
  97. /**
  98. * 利用put方法修改Map中的已有映射
  99. */
  100. public void testModify(){
  101. //提示输入要修改的学生ID
  102. System.out.println("请输入要修改的学生ID:");
  103. //创建Scanner对象,去获取从键盘上输入的学生ID字符串
  104. Scanner console=new Scanner(System.in);
  105. while(true){
  106. //取得从键盘上输入的学生ID
  107. String stuID=console.next();
  108. //从students中查找该学生ID对应的学生对象
  109. Student student=students.get(stuID);
  110. if (student==null) {
  111. System.out.println("该ID不存在,重新输入!");
  112. continue;
  113. }
  114. //提示当前对应的学生对象的姓名
  115. System.out.println("当前该学生ID,所对应的学生为:"+student.name);
  116. //提示输入新的学生姓名,来修改已有的映射
  117. System.out.println("请输入新的学生姓名");
  118. String name=console.next();
  119. Student newStudent=new Student(stuID,name);
  120. students.put(stuID,newStudent);
  121. System.out.println("修改成功!");
  122. break;
  123. }
  124. }
  125.  
  126. /**
  127. * 测试Map中,是否包含某个key值或者某个value值
  128. * 用containsValue()方法,来判断是否包含某个value值
  129. */
  130. public void testContainsKeyOrValue(){
  131. //提示输入学生id
  132. System.out.println("请输入要查询的学生ID");
  133. Scanner console=new Scanner(System.in);
  134. String id=console.next();
  135. //在Map中,用containsKey()方法,来判断是否包含某个key值
  136. System.out.println("您输入的学生ID为:"+id+"在学生映射表中是否存在:"+students.containsKey(id));
  137. if (students.containsKey(id)) {
  138. System.out.println("对应的学生为:"+students.get(id).name);
  139. }
  140.  
  141. //提示输入学生姓名
  142. System.out.println("请输入要查询的学生姓名:");
  143. String name=console.next();
  144. //用containsValue()方法,来判断是否包含某个Value值
  145. if (students.containsValue(new Student(null,name))) {
  146. System.out.println("在学生映射表中,确实包含学生:"+name);
  147. }else{
  148. System.out.println("在学生映射表中不存在该学生!");
  149. }
  150. }
  151.  
  152. /**
  153. * @param args
  154. */
  155. public static void main(String[] args) {
  156. // TODO Auto-generated method stub
  157. MapTest mt=new MapTest();
  158. mt.testPut();
  159. mt.testKeySet();
  160. /*mt.testRemove();
  161. mt.testEntrySet();*/
  162. /*mt.testModify();
  163. mt.testEntrySet();*/
  164. mt.testContainsKeyOrValue();
  165. }
  166.  
  167. }

运行结果为:

  1. 请输入学生ID
  2. 1
  3. 请输入学生姓名
  4. 小明
  5. 成功添加学生:小明
  6. 请输入学生ID
  7. 2
  8. 请输入学生姓名
  9. 小红
  10. 成功添加学生:小红
  11. 请输入学生ID
  12. 3
  13. 请输入学生姓名
  14. 小兰
  15. 成功添加学生:小兰
  16. 总共有:3个学生
  17. 学生小兰
  18. 学生小红
  19. 学生小明
  20. 请输入要查询的学生ID
  21. 2
  22. 您输入的学生ID为:2在学生映射表中是否存在:true
  23. 对应的学生为:小红
  24. 请输入要查询的学生姓名:
  25. 小红
  26. 在学生映射表中,确实包含学生:小红
  • 应用Collection.sort()实现List排序

Arrays类( java.util.Arrays)

Collections工具类(java.util.Collections)

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

sort() (排序)方法

  1. package com.imooc.collection;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.List;
  6. import java.util.Random;
  7.  
  8. /**
  9. *将要完成:
  10. *1.通过Collections.sort()方法,对Integer泛型的List进行排序;
  11. *2.对String泛型的List进行排序
  12. *3.对其他类型泛型的List进行排序,以student为例。
  13. */
  14. public class CollectionsTest {
  15.  
  16. /**
  17. *1. 通过Collections.sort()方法,对Integer泛型的List进行排序;
  18. * 创建一个Integer泛型的List,插入十个100以内的不重复随机整数,
  19. * 调用Collections.sort()方法对其进行排序
  20. */
  21. public void testSort1(){
  22. List<Integer> integerList=new ArrayList<Integer>();
  23. //插入十个100以内的不重复随机整数
  24. Random random=new Random();
  25. Integer k;
  26. for (int i = 0; i < 10; i++) {
  27. do{
  28. k=random.nextInt(100);
  29. }while(integerList.contains(k));
  30. integerList.add(k);
  31. System.out.println("成功添加整数:"+k);
  32. }
  33. System.out.println("----------排序之前-----------");
  34. for (Integer integer : integerList) {
  35. System.out.println("元素:"+integer);
  36. }
  37. Collections.sort(integerList);
  38. System.out.println("-----------排序之后-----------");
  39. for (Integer integer : integerList) {
  40. System.out.println("元素:"+integer);
  41. }
  42. }
  43.  
  44. /*
  45. *2.对String泛型的List进行排序
  46. *创建String泛型的List,添加三个乱序的String元素
  47. *调用sort()方法,再次输出排序后的顺序
  48. */
  49. public void testSort2(){
  50. List<String> list=new ArrayList<String>();
  51. list.add("microsoft");
  52. list.add("google");
  53. list.add("lenovo");
  54. System.out.println("-----------排序前--------");
  55. for (String string : list) {
  56. System.out.println("元素:"+string);
  57. }
  58. Collections.sort(list);
  59. System.out.println("------排序后-------");
  60. for (String string : list) {
  61. System.out.println("元素:"+string);
  62. }
  63. }
  64.  
  65. public static void main(String[] args) {
  66. CollectionsTest co=new CollectionsTest();
  67. //co.testSort1();
  68. co.testSort2();
  69. }
  70.  
  71. }

运行结果:

  • 学生选课——尝试对学生序列排序
  • Comparable & Comparator简介

Comparable------默认比较规则

Comparator------临时比较规则

Comparable接口——可比较的

  1. 实现该接口表示:这个类的实例可以比较大小,可以进行自然排序
  2. 定义了默认的比较规则
  3. 其实现类需实现comparaTo()方法
  4. comparaTo()方法返回正数表示大,负数表示小,0表示相等

Comparator接口——比较工具接口

  1. 用于定义临时比较规则,而不是默认比较规则
  2. 其实现类需要实现Compare()方法
  3. Comparator和Comparable都是Java集合框架的成员

  • 学生选课——实现学生序列排序
  1. package com.imooc.collection;
  2. /*
  3. * 学生类
  4. * */
  5. import java.util.HashSet;
  6. import java.util.Set;
  7.  
  8. public class Student implements Comparable<Student>{
  9. public String id;
  10. public String name;
  11. public Set <Course>courses;//泛型<Course>
  12.  
  13. @Override
  14. public int compareTo(Student o) {
  15. // TODO Auto-generated method stub
  16. return this.id.compareTo(o.id);
  17. }
  18.  
  19. @Override
  20. public int hashCode() {
  21. final int prime = 31;
  22. int result = 1;
  23. result = prime * result + ((name == null) ? 0 : name.hashCode());
  24. return result;
  25. }
  26. @Override
  27. public boolean equals(Object obj) {
  28. if (this == obj)
  29. return true;
  30. if (obj == null)
  31. return false;
  32. if (!(obj instanceof Student))
  33. return false;
  34. Student other = (Student) obj;
  35. if (name == null) {
  36. if (other.name != null)
  37. return false;
  38. } else if (!name.equals(other.name))
  39. return false;
  40. return true;
  41. }
  42. public Student(String id,String name){
  43. this.id=id;
  44. this.name=name;
  45. this.courses=new HashSet<Course>();
  46. }
  47.  
  48. }
  1. package com.imooc.collection;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.List;
  6. import java.util.Random;
  7.  
  8. /**
  9. *将要完成:
  10. *1.通过Collections.sort()方法,对Integer泛型的List进行排序;
  11. *2.对String泛型的List进行排序
  12. *3.对其他类型泛型的List进行排序,以student为例。
  13. */
  14. public class CollectionsTest {
  15.  
  16. /**
  17. *1. 通过Collections.sort()方法,对Integer泛型的List进行排序;
  18. * 创建一个Integer泛型的List,插入十个100以内的不重复随机整数,
  19. * 调用Collections.sort()方法对其进行排序
  20. */
  21. /*public void testSort1(){
  22. List<Integer> integerList=new ArrayList<Integer>();
  23. //插入十个100以内的不重复随机整数
  24. Random random=new Random();
  25. Integer k;
  26. for (int i = 0; i < 10; i++) {
  27. do{
  28. k=random.nextInt(100);
  29. }while(integerList.contains(k));
  30. integerList.add(k);
  31. System.out.println("成功添加整数:"+k);
  32. }
  33. System.out.println("----------排序之前-----------");
  34. for (Integer integer : integerList) {
  35. System.out.println("元素:"+integer);
  36. }
  37. Collections.sort(integerList);
  38. System.out.println("-----------排序之后-----------");
  39. for (Integer integer : integerList) {
  40. System.out.println("元素:"+integer);
  41. }
  42. }*/
  43.  
  44. /*
  45. *2.对String泛型的List进行排序
  46. *创建String泛型的List,添加三个乱序的String元素
  47. *调用sort()方法,再次输出排序后的顺序
  48. */
  49. /*public void testSort2(){
  50. List<String> list=new ArrayList<String>();
  51. list.add("microsoft");
  52. list.add("google");
  53. list.add("lenovo");
  54. System.out.println("-----------排序前--------");
  55. for (String string : list) {
  56. System.out.println("元素:"+string);
  57. }
  58. Collections.sort(list);
  59. System.out.println("------排序后-------");
  60. for (String string : list) {
  61. System.out.println("元素:"+string);
  62. }
  63. }
  64. */
  65.  
  66. /**
  67. * 3.对其他类型泛型的List进行排序,以student为例。
  68. *
  69. * */
  70. public void testSort3(){
  71. List<Student> studentList=new ArrayList<Student>();
  72. Random random=new Random();
  73. studentList.add(new Student(random.nextInt(1000)+"","Mike"));
  74. studentList.add(new Student(random.nextInt(1000)+"","Angela"));
  75. studentList.add(new Student(random.nextInt(1000)+"","Lucy"));
  76. studentList.add(new Student(1000+"","Beyonc"));
  77. System.out.println("----------排序前------------");
  78. for (Student student : studentList) {
  79. System.out.println("学生:"+student.id+":"+student.name);
  80. }
  81. Collections.sort(studentList);
  82. System.out.println();
  83. System.out.println("----------排序后-----------");
  84. for (Student student : studentList) {
  85. System.out.println("学生"+student.id+":"+student.name);
  86. }
  87. }
  88.  
  89. public static void main(String[] args) {
  90. CollectionsTest co=new CollectionsTest();
  91. //co.testSort1();
  92. //co.testSort2();
  93. co.testSort3();
  94. }
  95.  
  96. }

运行结果:

  1. package com.imooc.collection;
  2.  
  3. import java.util.Comparator;
  4.  
  5. public class StudentComparator implements Comparator<Student> {
  6.  
  7. @Override
  8. public int compare(Student o1, Student o2) {
  9. // TODO Auto-generated method stub
  10.  
  11. return o1.name.compareTo(o2.name);
  12. }
  13.  
  14. }
  1. package com.imooc.collection;
  2. /*
  3. * 学生类
  4. * */
  5. import java.util.HashSet;
  6. import java.util.Set;
  7.  
  8. public class Student implements Comparable<Student>{
  9. public String id;
  10. public String name;
  11. public Set <Course>courses;//泛型<Course>
  12.  
  13. @Override
  14. public int compareTo(Student o) {
  15. // TODO Auto-generated method stub
  16. return this.id.compareTo(o.id);
  17. }
  18.  
  19. @Override
  20. public int hashCode() {
  21. final int prime = 31;
  22. int result = 1;
  23. result = prime * result + ((name == null) ? 0 : name.hashCode());
  24. return result;
  25. }
  26. @Override
  27. public boolean equals(Object obj) {
  28. if (this == obj)
  29. return true;
  30. if (obj == null)
  31. return false;
  32. if (!(obj instanceof Student))
  33. return false;
  34. Student other = (Student) obj;
  35. if (name == null) {
  36. if (other.name != null)
  37. return false;
  38. } else if (!name.equals(other.name))
  39. return false;
  40. return true;
  41. }
  42. public Student(String id,String name){
  43. this.id=id;
  44. this.name=name;
  45. this.courses=new HashSet<Course>();
  46. }
  47.  
  48. }
  1. package com.imooc.collection;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.List;
  6. import java.util.Random;
  7.  
  8. /**
  9. *将要完成:
  10. *1.通过Collections.sort()方法,对Integer泛型的List进行排序;
  11. *2.对String泛型的List进行排序
  12. *3.对其他类型泛型的List进行排序,以student为例。
  13. */
  14. public class CollectionsTest {
  15.  
  16. /**
  17. *1. 通过Collections.sort()方法,对Integer泛型的List进行排序;
  18. * 创建一个Integer泛型的List,插入十个100以内的不重复随机整数,
  19. * 调用Collections.sort()方法对其进行排序
  20. */
  21. /*public void testSort1(){
  22. List<Integer> integerList=new ArrayList<Integer>();
  23. //插入十个100以内的不重复随机整数
  24. Random random=new Random();
  25. Integer k;
  26. for (int i = 0; i < 10; i++) {
  27. do{
  28. k=random.nextInt(100);
  29. }while(integerList.contains(k));
  30. integerList.add(k);
  31. System.out.println("成功添加整数:"+k);
  32. }
  33. System.out.println("----------排序之前-----------");
  34. for (Integer integer : integerList) {
  35. System.out.println("元素:"+integer);
  36. }
  37. Collections.sort(integerList);
  38. System.out.println("-----------排序之后-----------");
  39. for (Integer integer : integerList) {
  40. System.out.println("元素:"+integer);
  41. }
  42. }*/
  43.  
  44. /*
  45. *2.对String泛型的List进行排序
  46. *创建String泛型的List,添加三个乱序的String元素
  47. *调用sort()方法,再次输出排序后的顺序
  48. */
  49. /*public void testSort2(){
  50. List<String> list=new ArrayList<String>();
  51. list.add("microsoft");
  52. list.add("google");
  53. list.add("lenovo");
  54. System.out.println("-----------排序前--------");
  55. for (String string : list) {
  56. System.out.println("元素:"+string);
  57. }
  58. Collections.sort(list);
  59. System.out.println("------排序后-------");
  60. for (String string : list) {
  61. System.out.println("元素:"+string);
  62. }
  63. }
  64. */
  65.  
  66. /**
  67. * 3.对其他类型泛型的List进行排序,以student为例。
  68. *
  69. * */
  70. public void testSort3(){
  71. List<Student> studentList=new ArrayList<Student>();
  72. Random random=new Random();
  73. studentList.add(new Student(random.nextInt(1000)+"","Mike"));
  74. studentList.add(new Student(random.nextInt(1000)+"","Angela"));
  75. studentList.add(new Student(random.nextInt(1000)+"","Lucy"));
  76. studentList.add(new Student(1000+"","Beyonc"));
  77. System.out.println("----------排序前------------");
  78. for (Student student : studentList) {
  79. System.out.println("学生:"+student.id+":"+student.name);
  80. }
  81. Collections.sort(studentList);
  82. System.out.println();
  83. System.out.println("----------排序后-----------");
  84. for (Student student : studentList) {
  85. System.out.println("学生"+student.id+":"+student.name);
  86. }
  87.  
  88. Collections.sort(studentList,new StudentComparator());
  89. System.out.println("---------按照姓名排序后---------");
  90. for (Student student : studentList) {
  91. System.out.println("学生"+student.id+":"+student.name);
  92. }
  93. }
  94.  
  95. public static void main(String[] args) {
  96. CollectionsTest co=new CollectionsTest();
  97. //co.testSort1();
  98. //co.testSort2();
  99. co.testSort3();
  100. }
  101.  
  102. }

运行结果为:

Java中的集合框架(下)的更多相关文章

  1. 菜鸟日记之 java中的集合框架

    java中的集合框架图 如图所示:java中的集合分为两种Collection和Map两种接口 可分为Collection是单列集合和Map的双列集合 Collection单列集合:继承了Iterat ...

  2. Java中的集合框架-Collection(二)

    上一篇<Java中的集合框架-Collection(一)>把Java集合框架中的Collection与List及其常用实现类的功能大致记录了一下,本篇接着记录Collection的另一个子 ...

  3. Java中的集合框架(上)

    Java中的集合框架概述 集合的概念: Java中的集合类:是一种工具类,就像是容器,存储任意数量的具有共同属性的对象. 集合的作用: 1.在类的内部,对数据进行组织: 2.简单的快速的搜索大数据量的 ...

  4. Java中的集合框架-Collections和Arrays

    上一篇<Java中的集合框架-Map>把集合框架中的键值对容器Map中常用的知识记录了一下,本节记录一下集合框架的两个工具类Collections和Arrays 一,Collections ...

  5. Java中的集合框架-Map

    前两篇<Java中的集合框架-Commection(一)>和<Java中的集合框架-Commection(二)>把集合框架中的Collection开发常用知识点作了一下记录,从 ...

  6. Java中的集合框架

    概念与作用 集合概念 现实生活中:很多事物凑在一起 数学中的集合:具有共同属性的事物的总体 java中的集合类:是一种工具类,就像是容器,储存任意数量的具有共同属性的对象 在编程时,常常需要集中存放多 ...

  7. Java中的集合框架-Collection(一)

    一,Collection接口 在日常的开发工作中,我们经常使用数组,但是数组是有很多的局限性的,比如:数组大小固定后不可修改,只能存储基本类型的值等等. 基于数组的这些局限性,Java框架就产生了用于 ...

  8. JAVA 中的集合框架

    java集合框架提供了一套性能优良.使用方便的接口和类,它们位于java.util包中 一.集合与数组 数组:(可以存储基本数据类型)是用来存现对象的一种容器,但是数组的长度固定,不适合在对象数量未知 ...

  9. Java学习--java中的集合框架、Collection接口、list接口

    与数组相比:1.数组的长度固定,而集合的长度可变2.数组只能通过下表访问元素,类型固定,而有的集合可以通过任意类型查找所映射的具体对象 java集合框架:collection(list序列,queue ...

随机推荐

  1. javascript 面向对象设计之 Function 普通类

    var test = "Class01"; function Class01(privateValue, publicValue) { var _this = this; if ( ...

  2. 关于在Windows下Composer下载安装Yii2.0

    先是composer的安装,主要有两个方式,一个直接下载安装包安装,Composer-steup.exe文件,第二种直接下载composer.phar文件,用php去运行这个文件可以一样起到作用,之后 ...

  3. 晒下我在2017年所阅读的JavaScript书单

    前言 学习是一个持续不断的过程,在互联网技术里畅游的程序猿们,对学习的渴望更是难以穷尽.2017即将逝去,2018已经漏出曙光,回顾这一年,在学习的路上收获还是颇丰的,下面就晒一晒2017年我所学习的 ...

  4. python每天进步一点点

    1. apply, 可以调用函数和参数,如apply(Fun,(xxx,xxx)) 2. Format, 很好处理字符串的对齐命名,其他进制,打印等. 3. input(),接受输入 4. str() ...

  5. DataBase MongoDB集群方案介绍

    MongoDB集群方案介绍 一.什么是mongodb集群? 是指由多台mongodb服务器组成的服务器集群,称之为mongodb集群. 二.mongodb集群搭建的方式: 1.Replica Set  ...

  6. Macaca环境搭建踩坑总结

    1.使用命令 npm i macaca-android -g 安装一直不成功,使用Macaca  doctor 一直没有显示出android C:\Users\ABC>npm i macaca- ...

  7. 程序猿的日常——HashMap的相关知识

    背景知识 哈希冲突 哈希是指通过某种方法把数据转变成特定的数值,数值根据mod对应到不同的单元上.比如在Java中,字符串就是通过每个字符的编码来计算.数字是本身对应的值等等,不过就算是再好的哈希方法 ...

  8. Life in Changsha 第二次scrum冲刺

    第二次冲刺   第二次冲刺任务 设计留言板功能. 用户故事 用户打开“生活在长大”的界面 程序首页展示校园服务,论坛等相关信息 用户选择留言板 程序界面跳转 用户查看留言,并可以输入留言内容 提交后留 ...

  9. TreeMap 源码分析

    简介 TreeMap最早出现在JDK 1.2中,是 Java 集合框架中比较重要一个的实现.TreeMap 底层基于红黑树实现,可保证在log(n)时间复杂度内完成 containsKey.get.p ...

  10. tomcat配置https协议

    tomcat配置https协议 1.找到本地jdk底下的bin目录,bin目录底下存在文件keytool.exe(在bin目录下空白处,按住shift右击,打开命令窗口,如下图) 2.在cmd的命令窗 ...