Java中的集合框架（下）
- 学生选课——判断Set中课程是否存在
package com.imooc.collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
public class SetTest {
public List<Course>coursesToSelect;
public SetTest(){
coursesToSelect=new ArrayList<Course>();
}
//用于往CourseToSelect中添加备选课程
public void testAdd(){
//创建一个课程对象，并通过调用add方法，添加到备选课程List中
Course c=new Course("1","数据结构");
coursesToSelect.add(c);
Course temp=(Course) coursesToSelect.get(0);
//System.out.println("添加了一门课程"+temp.id+":"+temp.name);
Course c1=new Course("2","C语言");
coursesToSelect.add(0, c1);
Course temp1=(Course) coursesToSelect.get(0);
//System.out.println("添加一门课程："+temp1.id+":"+temp1.name);
Course cq=new Course("1","数据结构");
coursesToSelect.add(cq);
Course temp0=(Course) coursesToSelect.get(2);
//System.out.println("添加了一门课程"+temp0.id+":"+temp0.name);
/*Course c2=new Course("2","Test1");
CourseToSelect.add(4, c2);*/
Course[] course={new Course("3","离散数学"),new Course("4","汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));
Course temp2=(Course) coursesToSelect.get(2);
Course temp3=(Course) coursesToSelect.get(3);
//System.out.println("添加了两门课程："+temp2.id+":"+temp2.name+";"+temp3.id+":"+temp3.name);
Course[] course2={new Course("5","高等数学"),new Course("6","数字逻辑")};
coursesToSelect.addAll(2, Arrays.asList(course2));
Course temp4=(Course) coursesToSelect.get(2);
Course temp5=(Course) coursesToSelect.get(3);
//System.out.println("添加了两门课程："+temp4.id+":"+temp4.name+";"+temp5.id+":"+temp5.name);
}
/* * 取得List中的元素的方法
**/
/*public void testGet(){
System.out.println("有如下课程待选：");
int size=coursesToSelect.size();
for (int i = 0; i < size; i++) {
Course cr=(Course) coursesToSelect.get(i);
System.out.println("课程："+cr.id+":"+cr.name);
}
}
*/
/* * 通过迭代器来遍历List
* */
/*public void testIterator(){
//通过集合iterator方法，取得迭代器实例
Iterator it=coursesToSelect.iterator();
System.out.println("有如下课程待选(通过迭代器访问)：");
while (it.hasNext()) {
Course cr = (Course) it.next();
System.out.println("课程："+cr.id+":"+cr.name);
}
}*/
/*测试List的contains方法*/
public void testListContains(){
//取得被选课程序列的第0个元素
Course course=coursesToSelect.get(0);
//打印输出courseToSelect 是否包含course对象
System.out.println("取得课程"+course.name);
System.out.println("被选课程中是否包含课程"+course.name+","+coursesToSelect.contains(course));
//创建一个新的课程对象，ID和名称，与course对象完全一样
Course course2=new Course(course.id,course.name);
System.out.println("新创建课程："+course2.name);
System.out.println("备选课程中是否包含课程："+course2.name+","+coursesToSelect.contains(course2));
}
/** 通过for each方法访问集合元素
*
* */
/*public void testForEach(){
System.out.println("有如下课程待选(通过 for each访问)：");
for (Object object : coursesToSelect) {
Course cr=(Course) object;
System.out.println("课程："+cr.id+":"+cr.name);
}
}*/
/**
* @param argsS
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
SetTest st=new SetTest();
st.testAdd();
st.testListContains();
/*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;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
public class SetTest {
public List<Course>coursesToSelect;
public SetTest(){
coursesToSelect=new ArrayList<Course>();
}
//用于往CourseToSelect中添加备选课程
public void testAdd(){
//创建一个课程对象，并通过调用add方法，添加到备选课程List中
Course c=new Course("1","数据结构");
coursesToSelect.add(c);
Course temp=(Course) coursesToSelect.get(0);
//System.out.println("添加了一门课程"+temp.id+":"+temp.name);
Course c1=new Course("2","C语言");
coursesToSelect.add(0, c1);
Course temp1=(Course) coursesToSelect.get(0);
//System.out.println("添加一门课程："+temp1.id+":"+temp1.name);
Course cq=new Course("1","数据结构");
coursesToSelect.add(cq);
Course temp0=(Course) coursesToSelect.get(2);
//System.out.println("添加了一门课程"+temp0.id+":"+temp0.name);
/*Course c2=new Course("2","Test1");
CourseToSelect.add(4, c2);*/
Course[] course={new Course("3","离散数学"),new Course("4","汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));
Course temp2=(Course) coursesToSelect.get(2);
Course temp3=(Course) coursesToSelect.get(3);
//System.out.println("添加了两门课程："+temp2.id+":"+temp2.name+";"+temp3.id+":"+temp3.name);
Course[] course2={new Course("5","高等数学"),new Course("6","数字逻辑")};
coursesToSelect.addAll(2, Arrays.asList(course2));
Course temp4=(Course) coursesToSelect.get(2);
Course temp5=(Course) coursesToSelect.get(3);
//System.out.println("添加了两门课程："+temp4.id+":"+temp4.name+";"+temp5.id+":"+temp5.name);
}
/* * 取得List中的元素的方法
**/
/*public void testGet(){
System.out.println("有如下课程待选：");
int size=coursesToSelect.size();
for (int i = 0; i < size; i++) {
Course cr=(Course) coursesToSelect.get(i);
System.out.println("课程："+cr.id+":"+cr.name);
}
}
*/
/* * 通过迭代器来遍历List
* */
/*public void testIterator(){
//通过集合iterator方法，取得迭代器实例
Iterator it=coursesToSelect.iterator();
System.out.println("有如下课程待选(通过迭代器访问)：");
while (it.hasNext()) {
Course cr = (Course) it.next();
System.out.println("课程："+cr.id+":"+cr.name);
}
}*/
/*测试List的contains方法*/
public void testListContains(){
//取得被选课程序列的第0个元素
Course course=coursesToSelect.get(0);
//打印输出courseToSelect 是否包含course对象
System.out.println("取得课程"+course.name);
System.out.println("被选课程中是否包含课程"+course.name+","+coursesToSelect.contains(course));
//创建一个新的课程对象，ID和名称，与course对象完全一样
Course course2=new Course(course.id,course.name);
System.out.println("新创建课程："+course2.name);
System.out.println("备选课程中是否包含课程："+course2.name+","+coursesToSelect.contains(course2));
}
/** 通过for each方法访问集合元素
*
* */
/*public void testForEach(){
System.out.println("有如下课程待选(通过 for each访问)：");
for (Object object : coursesToSelect) {
Course cr=(Course) object;
System.out.println("课程："+cr.id+":"+cr.name);
}
}*/
/**
* @param argsS
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
SetTest st=new SetTest();
st.testAdd();
st.testListContains();
/*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;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
public class SetTest {
public List<Course>coursesToSelect;
private Scanner console;
public SetTest(){
coursesToSelect=new ArrayList<Course>();
console=new Scanner(System.in);
}
//用于往CourseToSelect中添加备选课程
public void testAdd(){
//创建一个课程对象，并通过调用add方法，添加到备选课程List中
Course c=new Course("1","数据结构");
coursesToSelect.add(c);
Course temp=(Course) coursesToSelect.get(0);
//System.out.println("添加了一门课程"+temp.id+":"+temp.name);
Course c1=new Course("2","C语言");
coursesToSelect.add(0, c1);
Course temp1=(Course) coursesToSelect.get(0);
//System.out.println("添加一门课程："+temp1.id+":"+temp1.name);
Course cq=new Course("1","数据结构");
coursesToSelect.add(cq);
Course temp0=(Course) coursesToSelect.get(2);
//System.out.println("添加了一门课程"+temp0.id+":"+temp0.name);
/*Course c2=new Course("2","Test1");
CourseToSelect.add(4, c2);*/
Course[] course={new Course("3","离散数学"),new Course("4","汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));
Course temp2=(Course) coursesToSelect.get(2);
Course temp3=(Course) coursesToSelect.get(3);
//System.out.println("添加了两门课程："+temp2.id+":"+temp2.name+";"+temp3.id+":"+temp3.name);
Course[] course2={new Course("5","高等数学"),new Course("6","数字逻辑")};
coursesToSelect.addAll(2, Arrays.asList(course2));
Course temp4=(Course) coursesToSelect.get(2);
Course temp5=(Course) coursesToSelect.get(3);
//System.out.println("添加了两门课程："+temp4.id+":"+temp4.name+";"+temp5.id+":"+temp5.name);
}
/* * 取得List中的元素的方法
**/
/*public void testGet(){
System.out.println("有如下课程待选：");
int size=coursesToSelect.size();
for (int i = 0; i < size; i++) {
Course cr=(Course) coursesToSelect.get(i);
System.out.println("课程："+cr.id+":"+cr.name);
}
}
*/
/* * 通过迭代器来遍历List
* */
/*public void testIterator(){
//通过集合iterator方法，取得迭代器实例
Iterator it=coursesToSelect.iterator();
System.out.println("有如下课程待选(通过迭代器访问)：");
while (it.hasNext()) {
Course cr = (Course) it.next();
System.out.println("课程："+cr.id+":"+cr.name);
}
}*/
/*测试List的contains方法*/
public void testListContains(){
//取得被选课程序列的第0个元素
Course course=coursesToSelect.get(0);
//打印输出courseToSelect 是否包含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));
}
/** 通过for each方法访问集合元素
*
* */
/*public void testForEach(){
System.out.println("有如下课程待选(通过 for each访问)：");
for (Object object : coursesToSelect) {
Course cr=(Course) object;
System.out.println("课程："+cr.id+":"+cr.name);
}
}*/
/**
* @param argsS
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
SetTest st=new SetTest();
st.testAdd();
st.testListContains();
/*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 Course {
public String id;
public String name;
public Course(String id, String name) {
this.id = id;
this.name = name;
}
public Course() {
}
//重写某个类的 equals方法来判断模板
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof Course)) {
return false;
}
Course course = (Course) obj;
if (this.name == null) {
if (course.name == null) {
return true;
} else {
return false;
}
} else {
if (this.name.equals(course.name)) {
return true;
} else {
return false;
}
}
}
}
运行结果为：
- 学生选课——判断Set中课程是否存在
图片（1）
图片（2）
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() {
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Course))
return false;
Course other = (Course) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
package com.imooc.collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
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);
}
//用于往CourseToSelect中添加备选课程
public void testAdd(){
//创建一个课程对象，并通过调用add方法，添加到备选课程List中
Course c=new Course("1","数据结构");
coursesToSelect.add(c);
Course temp=(Course) coursesToSelect.get(0);
//System.out.println("添加了一门课程"+temp.id+":"+temp.name);
Course c1=new Course("2","C语言");
coursesToSelect.add(0, c1);
Course temp1=(Course) coursesToSelect.get(0);
//System.out.println("添加一门课程："+temp1.id+":"+temp1.name);
Course cq=new Course("1","数据结构");
coursesToSelect.add(cq);
Course temp0=(Course) coursesToSelect.get(2);
//System.out.println("添加了一门课程"+temp0.id+":"+temp0.name);
/*Course c2=new Course("2","Test1");
CourseToSelect.add(4, c2);*/
Course[] course={new Course("3","离散数学"),new Course("4","汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));
Course temp2=(Course) coursesToSelect.get(2);
Course temp3=(Course) coursesToSelect.get(3);
//System.out.println("添加了两门课程："+temp2.id+":"+temp2.name+";"+temp3.id+":"+temp3.name);
Course[] course2={new Course("5","高等数学"),new Course("6","数字逻辑")};
coursesToSelect.addAll(2, Arrays.asList(course2));
Course temp4=(Course) coursesToSelect.get(2);
Course temp5=(Course) coursesToSelect.get(3);
//System.out.println("添加了两门课程："+temp4.id+":"+temp4.name+";"+temp5.id+":"+temp5.name);
}
/* * 取得List中的元素的方法
**/
/*public void testGet(){
System.out.println("有如下课程待选：");
int size=coursesToSelect.size();
for (int i = 0; i < size; i++) {
Course cr=(Course) coursesToSelect.get(i);
System.out.println("课程："+cr.id+":"+cr.name);
}
}
*/
/* * 通过迭代器来遍历List
* */
/*public void testIterator(){
//通过集合iterator方法，取得迭代器实例
Iterator it=coursesToSelect.iterator();
System.out.println("有如下课程待选(通过迭代器访问)：");
while (it.hasNext()) {
Course cr = (Course) it.next();
System.out.println("课程："+cr.id+":"+cr.name);
}
}
*/
/*测试List的contains方法*/
/*public void testListContains(){
//取得被选课程序列的第0个元素
Course course=coursesToSelect.get(0);
//打印输出courseToSelect 是否包含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));
}
*/
/** 通过for each方法访问集合元素
*
* */
public void testForEach(){
System.out.println("有如下课程待选(通过 for each访问)：");
for (Object object : coursesToSelect) {
Course cr=(Course) object;
System.out.println("课程："+cr.id+":"+cr.name);
}
}
//创建学生对象并选课
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的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 argsS
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
SetTest st=new SetTest();
st.testAdd();
//st.testListContains();
st.createStudentAndSelectCours();
st.testSetContains();
/*st.testGet();
st.testIterator();*/
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");
}
}*/
}
运行结果为：
- 学生选课——获取List中课程的位置
package com.imooc.collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
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);
}
//用于往CourseToSelect中添加备选课程
public void testAdd(){
//创建一个课程对象，并通过调用add方法，添加到备选课程List中
Course c=new Course("1","数据结构");
coursesToSelect.add(c);
Course temp=(Course) coursesToSelect.get(0);
//System.out.println("添加了一门课程"+temp.id+":"+temp.name);
Course c1=new Course("2","C语言");
coursesToSelect.add(0, c1);
Course temp1=(Course) coursesToSelect.get(0);
//System.out.println("添加一门课程："+temp1.id+":"+temp1.name);
Course cq=new Course("1","数据结构");
coursesToSelect.add(cq);
Course temp0=(Course) coursesToSelect.get(2);
//System.out.println("添加了一门课程"+temp0.id+":"+temp0.name);
/*Course c2=new Course("2","Test1");
CourseToSelect.add(4, c2);*/
Course[] course={new Course("3","离散数学"),new Course("4","汇编语言")};
coursesToSelect.addAll(Arrays.asList(course));
Course temp2=(Course) coursesToSelect.get(2);
Course temp3=(Course) coursesToSelect.get(3);
//System.out.println("添加了两门课程："+temp2.id+":"+temp2.name+";"+temp3.id+":"+temp3.name);
Course[] course2={new Course("5","高等数学"),new Course("6","数字逻辑")};
coursesToSelect.addAll(2, Arrays.asList(course2));
Course temp4=(Course) coursesToSelect.get(2);
Course temp5=(Course) coursesToSelect.get(3);
//System.out.println("添加了两门课程："+temp4.id+":"+temp4.name+";"+temp5.id+":"+temp5.name);
}
/* * 取得List中的元素的方法
**/
/*public void testGet(){
System.out.println("有如下课程待选：");
int size=coursesToSelect.size();
for (int i = 0; i < size; i++) {
Course cr=(Course) coursesToSelect.get(i);
System.out.println("课程："+cr.id+":"+cr.name);
}
}
*/
/* * 通过迭代器来遍历List
* */
/*public void testIterator(){
//通过集合iterator方法，取得迭代器实例
Iterator it=coursesToSelect.iterator();
System.out.println("有如下课程待选(通过迭代器访问)：");
while (it.hasNext()) {
Course cr = (Course) it.next();
System.out.println("课程："+cr.id+":"+cr.name);
}
}
*/
/*测试List的contains方法*/
public void testListContains(){
//取得被选课程序列的第0个元素
Course course=coursesToSelect.get(0);
//打印输出courseToSelect 是否包含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));
}
}
/** 通过for each方法访问集合元素
*
* */
public void testForEach(){
System.out.println("有如下课程待选(通过 for each访问)：");
for (Object object : coursesToSelect) {
Course cr=(Course) object;
System.out.println("课程："+cr.id+":"+cr.name);
}
}
//创建学生对象并选课
/*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的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 argsS
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
SetTest st=new SetTest();
st.testAdd();
st.testListContains();
//st.createStudentAndSelectCours();
//st.testSetContains();
/*st.testGet();
st.testIterator();*/
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");
}
}*/
}
运行结果为：
- 学生选课——判断Map中是否包含指定的key和value
package com.imooc.collection;
/*
* 学生类
* */
import java.util.HashSet;
import java.util.Set;
public class Student {
public String id;
public String name;
public Set <Course>courses;//泛型<Course>
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Student))
return false;
Student other = (Student) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public Student(String id,String name){
this.id=id;
this.name=name;
this.courses=new HashSet<Course>();
}
}
package com.imooc.collection;
/*
* 学生类
* */
import java.util.HashSet;
import java.util.Set;
public class Student {
public String id;
public String name;
public Set <Course>courses;//泛型<Course>
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Student))
return false;
Student other = (Student) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public Student(String id,String name){
this.id=id;
this.name=name;
this.courses=new HashSet<Course>();
}
}
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，判断是否被占用
* 若薇被占用，则输入姓名，创建新学生对象，并且
* 添加到student中
*/
public void testPut(){
Scanner console=new Scanner(System.in);
int i=0;
while (i<3) {
System.out.println("请输入学生ID");
String ID=console.next();
Student st=students.get(ID);
if (st==null) {
//提示输入学生姓名
System.out.println("请输入学生姓名");
String name=console.next();
//添加新的学生对象
Student newStudent=new Student(ID,name);
students.put(ID,newStudent);
System.out.println("成功添加学生："+students.get(ID).name);
i++;
}else{
System.out.println("该学生ID已被占用");
continue;
}
}
}
/**
* @param args测试Map的keySet方法
*/
public void testKeySet(){
//keySet方法，返回Map中的所有“键”的Set集合
Set<String> keySet=students.keySet();
//取得student的容量
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值
* 用containsValue()方法，来判断是否包含某个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) {
// TODO Auto-generated method stub
MapTest mt=new MapTest();
mt.testPut();
mt.testKeySet();
/*mt.testRemove();
mt.testEntrySet();*/
/*mt.testModify();
mt.testEntrySet();*/
mt.testContainsKeyOrValue();
}
}
运行结果为：
请输入学生ID 1 请输入学生姓名 小明 成功添加学生：小明 请输入学生ID 2 请输入学生姓名 小红 成功添加学生：小红 请输入学生ID 3 请输入学生姓名 小兰 成功添加学生：小兰 总共有：3个学生 学生小兰 学生小红 学生小明 请输入要查询的学生ID 2 您输入的学生ID为：2在学生映射表中是否存在：true 对应的学生为：小红 请输入要查询的学生姓名： 小红 在学生映射表中，确实包含学生：小红
- 应用Collection.sort()实现List排序
Arrays类( java.util.Arrays)
Collections工具类(java.util.Collections)
是Java集合框架中，用来操作集合对象的工具类也是Java集合框架的成员
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> list=new ArrayList<String>();
list.add("microsoft");
list.add("google");
list.add("lenovo");
System.out.println("-----------排序前--------");
for (String string : list) {
System.out.println("元素："+string);
}
Collections.sort(list);
System.out.println("------排序后-------");
for (String string : list) {
System.out.println("元素："+string);
}
}
public static void main(String[] args) {
CollectionsTest co=new CollectionsTest();
//co.testSort1();
co.testSort2();
}
}
运行结果：
- 学生选课——尝试对学生序列排序
- Comparable & Comparator简介
Comparable------默认比较规则
Comparator------临时比较规则
Comparable接口——可比较的
- 实现该接口表示：这个类的实例可以比较大小，可以进行自然排序
- 定义了默认的比较规则
- 其实现类需实现comparaTo()方法
- comparaTo()方法返回正数表示大，负数表示小，0表示相等
Comparator接口——比较工具接口
- 用于定义临时比较规则，而不是默认比较规则
- 其实现类需要实现Compare()方法
- Comparator和Comparable都是Java集合框架的成员
- 学生选课——实现学生序列排序
package com.imooc.collection;
/*
* 学生类
* */
import java.util.HashSet;
import java.util.Set;
public class Student implements Comparable<Student>{
public String id;
public String name;
public Set <Course>courses;//泛型<Course>
@Override
public int compareTo(Student o) {
// TODO Auto-generated method stub
return this.id.compareTo(o.id);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Student))
return false;
Student other = (Student) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public Student(String id,String name){
this.id=id;
this.name=name;
this.courses=new HashSet<Course>();
}
}
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> list=new ArrayList<String>();
list.add("microsoft");
list.add("google");
list.add("lenovo");
System.out.println("-----------排序前--------");
for (String string : list) {
System.out.println("元素："+string);
}
Collections.sort(list);
System.out.println("------排序后-------");
for (String string : list) {
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(1000+"","Beyonc"));
System.out.println("----------排序前------------");
for (Student student : studentList) {
System.out.println("学生："+student.id+"："+student.name);
}
Collections.sort(studentList);
System.out.println();
System.out.println("----------排序后-----------");
for (Student student : studentList) {
System.out.println("学生"+student.id+"："+student.name);
}
}
public static void main(String[] args) {
CollectionsTest co=new CollectionsTest();
//co.testSort1();
//co.testSort2();
co.testSort3();
}
}
运行结果：
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.HashSet;
import java.util.Set;
public class Student implements Comparable<Student>{
public String id;
public String name;
public Set <Course>courses;//泛型<Course>
@Override
public int compareTo(Student o) {
// TODO Auto-generated method stub
return this.id.compareTo(o.id);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Student))
return false;
Student other = (Student) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public Student(String id,String name){
this.id=id;
this.name=name;
this.courses=new HashSet<Course>();
}
}
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> list=new ArrayList<String>();
list.add("microsoft");
list.add("google");
list.add("lenovo");
System.out.println("-----------排序前--------");
for (String string : list) {
System.out.println("元素："+string);
}
Collections.sort(list);
System.out.println("------排序后-------");
for (String string : list) {
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(1000+"","Beyonc"));
System.out.println("----------排序前------------");
for (Student student : studentList) {
System.out.println("学生："+student.id+"："+student.name);
}
Collections.sort(studentList);
System.out.println();
System.out.println("----------排序后-----------");
for (Student student : studentList) {
System.out.println("学生"+student.id+"："+student.name);
}
Collections.sort(studentList,new StudentComparator());
System.out.println("---------按照姓名排序后---------");
for (Student student : studentList) {
System.out.println("学生"+student.id+"："+student.name);
}
}
public static void main(String[] args) {
CollectionsTest co=new CollectionsTest();
//co.testSort1();
//co.testSort2();
co.testSort3();
}
}
运行结果为：
Java中的集合框架（下）的更多相关文章
- 菜鸟日记之 java中的集合框架
java中的集合框架图 如图所示:java中的集合分为两种Collection和Map两种接口 可分为Collection是单列集合和Map的双列集合 Collection单列集合:继承了Iterat ...
- Java中的集合框架-Collection（二）
上一篇<Java中的集合框架-Collection(一)>把Java集合框架中的Collection与List及其常用实现类的功能大致记录了一下,本篇接着记录Collection的另一个子 ...
- Java中的集合框架（上）
Java中的集合框架概述 集合的概念: Java中的集合类:是一种工具类,就像是容器,存储任意数量的具有共同属性的对象. 集合的作用: 1.在类的内部,对数据进行组织: 2.简单的快速的搜索大数据量的 ...
- Java中的集合框架-Collections和Arrays
上一篇<Java中的集合框架-Map>把集合框架中的键值对容器Map中常用的知识记录了一下,本节记录一下集合框架的两个工具类Collections和Arrays 一,Collections ...
- Java中的集合框架-Map
前两篇<Java中的集合框架-Commection(一)>和<Java中的集合框架-Commection(二)>把集合框架中的Collection开发常用知识点作了一下记录,从 ...
- Java中的集合框架
概念与作用 集合概念 现实生活中:很多事物凑在一起 数学中的集合:具有共同属性的事物的总体 java中的集合类:是一种工具类,就像是容器,储存任意数量的具有共同属性的对象 在编程时,常常需要集中存放多 ...
- Java中的集合框架-Collection（一）
一,Collection接口 在日常的开发工作中,我们经常使用数组,但是数组是有很多的局限性的,比如:数组大小固定后不可修改,只能存储基本类型的值等等. 基于数组的这些局限性,Java框架就产生了用于 ...
- JAVA 中的集合框架
java集合框架提供了一套性能优良.使用方便的接口和类,它们位于java.util包中 一.集合与数组 数组:(可以存储基本数据类型)是用来存现对象的一种容器,但是数组的长度固定,不适合在对象数量未知 ...
- Java学习--java中的集合框架、Collection接口、list接口
与数组相比:1.数组的长度固定,而集合的长度可变2.数组只能通过下表访问元素,类型固定,而有的集合可以通过任意类型查找所映射的具体对象 java集合框架:collection(list序列,queue ...
随机推荐
- springboot+多数据源配置
作者:纯洁的微笑 出处:http://www.ityouknow.com/ 起多数据源,一般都来解决那些问题呢,主从模式或者业务比较复杂需要连接不同的分库来支持业务.我们项目是后者的模式,网上找了很多 ...
- python爬虫入门学习
近期写的一个爬虫的Demo,只是简单的用了几个函数.实现了简单的爬取网页的功能(以途牛为例). import urllib2 import re import urlparse import robo ...
- Ignite与Spark集成时，ClassNotFoundException问题解决
参考文章:https://apacheignite-fs.readme.io/docs/installation-deployment Spark application deployment mod ...
- js 数组的常用方法归纳
数组的常用方法归纳 slice(start,end) 传参:start代表从哪里开始截取,end代表截取结束的地方 var a = [1,2,3]a.slice(1);//[2,3] pop() 可以 ...
- CROSS JOIN,NATURAL JOIN
CROSS JOIN:笛卡尔积 NATURAL JOIN:
- windows环境下mysql主从配置
mysql主从配置. 相关理论知识可以百度一下,这里就不多说了,直接说如何配置. 一.环境介绍及说明 主库所在的操作系统:win7 主库的版本:mysql-5.6.24-winx64.zip 主库的i ...
- 指针变量的*p,p以及&p的区别
23/7/2017 决定夯实基础,回顾指针的知识点,该博文转载于CSDN博主百家晓东,小部分修改,外加编译图引证 正文如下: 以下面的情况说明: int a = 5; int* p = &a ...
- iOS 通过UIControl，自定义控件
如:自定义一个可以点击的 图文 #import <UIKit/UIKit.h> @interface UD_Button : UIControl @property(nonatomic,s ...
- 自定义bootstrap样式-9行样式自定义漂亮大气bootstrap导航栏
有人说前端发展太快,框架太多,各有所需,各有所长.看看这幅图,估计都知道这些框架,但是大部分公司中实际要用到的也就那么几个. 发展再快,框架再多.还是得回到原点,不就是Html+Css+JavaScr ...
- Spark源码剖析（七）：Job触发流程原理与源码剖析
引言 我们知道在application中每存在一个action操作就会触发一个job,那么spark底层是怎样触发job的呢?接下来我们用一个wordcount程序来剖析一下job的触发机制. 解析w ...