JAVA学习代码——集合版选课

封装学生类：Student.java

package 集合_学生选课;

import java.util.HashSet;
import java.util.Set;

/**
 * 学生类 
 * @author 一抹灬茶香
 */
public class Student {
	private String id;
	private String name;
//	private Set course;// 定义Set类型的course， 导入set所在包
	private Set<Course>course;
	public Student() {

	}

	public Student(String id, String name) {
		super();
		this.id = id;
		this.name = name;
		// 在构造方法中把所选课程的属性course初始化，不能直接实例化Set，因为Set是
		// 一个接口，通过HashSet()来实例化，HashSet是Set接口的有个重要实现类
//		this.course = new HashSet();
		this.course = new HashSet<Course>();
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public <Course>Set getCourse() {
		return course;
	}

	public void setCourse(Set course) {
		this.course = course;
	}

}

封装课程类：Course.java

package 集合_学生选课;

/**
 * 课程类
 * @author 一抹灬茶香 在实际开发过程中，把所有的属性私有化，通过get/set来访问属性
 */
public class Course {
	private String id;
	private String name;

	public Course() {

	}

	public Course(String id, String name) {
		super();
		this.id = id;
		this.name = name;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

Set版选课：SetTest.java

package 集合_学生选课;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;

/**
 * 1.Set接口及其实现类HashSet
 * 		Set是元素无序并且不可以重复的集合，被称为集
 * 		HashSet：哈希集，是Set的一个重要实现类
 * 2.Set中没有set()替换指定位置元素的方法：因为无序,get()同set()
 * 3.set中可以添加null：set.add(null);但是一般没意义
 * 4.set中添加某个对象多次，只会保留一个该对象（的引用），并且保留的是第一次添加的那个
 */

/**
 * 案例功能说明： 1.提供备选课程 
 * 2.创建学生对象，并给改学生添加三门课程（添加在学生的Course——Set类型的属性中）
 * @显示备选课程
 * @循环三次，每次输入课程ID
 * @往学生的courses属性中添加与输入的ID匹配的课程
 * @输出学生选择的课程
 */

public class SetTest {
	public List<Course> coursesToSelect;
	static Set<Course> st2 = new HashSet<Course>();// 静态常量

	public SetTest() {
		coursesToSelect = new ArrayList<Course>();// 初始化
	}

	public void testAdd() {
		Course cr1 = new Course("1", "数据结构");
		coursesToSelect.add(cr1);
		Course cr2 = new Course("2", "C语言");
		coursesToSelect.add(cr2);
		Course[] course2 = { new Course("3", "大学物理"), new Course("4", "大学英语") };
		coursesToSelect.addAll(Arrays.asList(course2));
	}

	// 通过foreach方法访问集合元素
	public void testForeach() {
		System.out.println("有如下课程待选（通过foreach访问）：");
		for (Object obj : coursesToSelect) {
			Course cr = (Course) obj;
			System.out.println("课程： " + cr.getId() + ":" + cr.getName());
		}
	}

	public void testForeachForSet(Student student) {
		// 打印输出学生所选课程
		for (Course cr : st2) {//st2小明所选课程的集合
			System.out.println("选择了课程：" + cr.getId() + ":" + cr.getName());
		}
	}

	public static void main(String[] args) {
		// 在Student中定义中和构造方法中加入泛型
		SetTest st = new SetTest();
		st.testAdd();
		st.testForeach();
		// 创建一个学生对象
		Student student = new Student("1", "小明");
		System.out.println("欢迎学生： " + student.getName() + "选课！");
		// 创建一个Scanner对象，用于接收从键盘输入的课程ID
		Scanner console = new Scanner(System.in);// console：控制台。可以为别的sc，a，b等
		for (int i = 0; i < 3; i++) {
			System.out.println("请输入课程ID：");
			String courseId = console.next();
			for (Course cr : st.coursesToSelect) {

				// 判断cr的id 是否相等：课程的id是一个字符串是一个对象（不是引用）所以调用equals判断
				if ((cr.getId()).equals(courseId)) {
					student.getCourse().add(cr);
					st2 = student.getCourse();
					// System.out.println("选择了课程：" + cr.getId() + ":" +
					// cr.getName());
				}
			}
		}
		st.testForeachForSet(student);// 循环完成后调用方法打印输出
	}
}

List版选课：ListTest.java

package 集合_学生选课;

/**
 * 备选课程类
 */
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class ListTest {
	/**
	 * 用于存放备选课程的List List有序，可重复
	 */
	private List coursesToSelect;// 备选课程，List类型

	public ListTest() {
		// 初始化coursesToSelect，List不能直接实例化，用List的实现类ArrayList来实例化
		this.coursesToSelect = new ArrayList();
	}

	// 用于往coursesToSelect中添加备选课程
	public void testAdd() {
		// =============方法一：add()方法
		// 创建一个课程对象，并通过调用add方法，添加到备选课程List中
		Course cr1 = new Course("1", "数据结构");
		coursesToSelect.add(cr1);
		// 通过List的get方法将元素取出。 对象存入集合都变成Object类型，取出时需要类型转换
		Course temp1 = (Course) coursesToSelect.get(0);// get(0)，插到0位置
		System.out.println("添加了课程:   " + temp1.getId() + "  :" + temp1.getName());
		// System.out.println("添加了课程"+temp.getId()+":"+temp.getName());//当前面定义为public是，不需get/set方法

		// =============方法二：add(int index,value)方法
		Course cr2 = new Course("2", "C语言");
		// 调用add方法添加元素到指定位置：第0位置
		coursesToSelect.add(0, cr2);
		Course temp2 = (Course) coursesToSelect.get(0);
		System.out.println("添加了课程:   " + temp2.getId() + "  :" + temp2.getName());
		// >>>>>>>>>>>>>>>>>>>>>>>>重复添加《《《《《《《《《《《《
		coursesToSelect.add(cr1);
		Course temp0 = (Course) coursesToSelect.get(2);// 添加的位置在cr1和cr2之间，为第2位置
		System.out.println("添加了课程:   " + temp0.getId() + "  :" + temp0.getName());

		// List现在的长度:List.size()为2，放入位置为4，报出：数组下标越界异常
		// Course cr3 = new Course("3", "TEST");
		// coursesToSelect.add(4, cr3);
		// Course temp3 = (Course) coursesToSelect.get(4);

		// 创建Course类型的对象数组，添加两个元素
		Course[] course = { new Course("3", "离散数学"), new Course("4", "汇编语言") };

		// =============添加方法二：addAll()方法
		// 通过工具类Arrays.asList()将course数组转变为List
		coursesToSelect.addAll(Arrays.asList(course));
		// 打印输出前将课程从集合2、3位置中取出
		Course temp3 = (Course) coursesToSelect.get(3);
		Course temp4 = (Course) coursesToSelect.get(4);
		System.out.println("添加了两门课程:   " + temp3.getId() + "  :" + temp3.getName() + ";" + temp4.getId() + "  :"
				+ temp4.getName());
		// =============添加方法三：addAll(in index,value)方法
		Course[] course2 = { new Course("5", "大学物理"), new Course("6", "大学英语") };
		coursesToSelect.addAll(2, Arrays.asList(course2));// 放入第2位置
		Course temp5 = (Course) coursesToSelect.get(2);
		Course temp6 = (Course) coursesToSelect.get(3);
		System.out.println("添加了两门课程:   " + temp5.getId() + "  :" + temp5.getName() + ";" + temp6.getId() + "  :"
				+ temp6.getName());
	}

	public List getCoursesToSelect() {
		return coursesToSelect;
	}

	public void setCoursesToSelect(List coursesToSelect) {
		this.coursesToSelect = coursesToSelect;
	}

	/**
	 * 取得List中的元素的方法
	 * 
	 * @param args
	 */
	public void testGet() {
		// 为了一次遍历List中的每一个元素，需要取得List的长度：List.size()
		int size = coursesToSelect.size();// 定义整型size接收List长度
		System.out.println("有如下课程待选(通过for循环)：");
		// ----------for循环遍历-----------
		for (int i = 0; i < size; i++) {
			coursesToSelect.get(i);
			Course cr = (Course) coursesToSelect.get(i);
			System.out.println("课程： " + cr.getId() + ":" + cr.getName());
		}
	}

	/**
	 * 通过迭代器Iterator来遍历LIst中的每一个元素
	 * 在Collection接口中定义的迭代器Iterator方法，Iterator本来也是一个接口
	 * 迭代器只具有遍历集合中元素的能力，不具备存储元素的能力，依赖集合存在，不能独立存在
	 */
	public void testIterator() {
		// 通过集合的iterator方法，取得迭代器的实例
		Iterator it = coursesToSelect.iterator();
		System.out.println("有如下课程待选（通过迭代器）：");
		while (it.hasNext()) {// it.hasNext()：如果有元素返回ture，否则false
			Course cr = (Course) it.next();
			System.out.println("课程： " + cr.getId() + ":" + cr.getName());
		}
	}

	/**
	 * 1.通过foreach方法访问集合元素
	 * 2.foreach语句是for语句的特殊简化版本,在遍历数组、集合方面，foreach为开发人员提供了极大的方便。
	 * 		但是foreach语句并不能完全取代for语句，
	 * 		然而，任何的foreach语句都可以改写为for语句版本。foreach并不是一个关键字，习惯上将这种特殊的for语句格式称之为“foreach”
	 * 		语句。从英文 字面意思理解foreach也就是“for 每一个”的意思。实际上也就是这个意思。
	 * 
	 * 3.foreach的语句格式： for(元素类型t 元素变量x : 遍历对象obj){ 引用了x的java语句; }
	 * 
	 * 4.foreach语句的局限性:如果要引用数组或者集合的索引，则foreach语句无法做到，foreach仅仅老老实实地遍历数组或者集合一遍。
	 */
	public void testForeach() {
		System.out.println("有如下课程待选（通过foreach访问）：");
		// Object obj：定义一个Object型变量
		// coursesToSelect：需要遍历的集合
		// 遍历集合中的每一个元素，取出来作为Object类型的变量
		// 为什么是Object？元素存入集合时，类型被忽略，集合那它当Object使用
		for (Object obj : coursesToSelect) {
			Course cr = (Course) obj;
			System.out.println("课程： " + cr.getId() + ":" + cr.getName());

		}
	}
	/**
	 * 修改Lsit中的元素
	 * @param args
	 */
	public void testModify(){
		coursesToSelect.set(4,new Course("7", "毛概"));
	}
	/**
	 * 删除Lsit中的元素
	 * remove();//可以放入元素或者 位置（长度之内，否者报出下标越界异常）
	 * removeAll();从某个集合中将另一个集合完全删除
	 *
	 */
	public void testRemove(){
		//remove()删除
//		Course cr=(Course)coursesToSelect.get(4);
//		System.out.println("我是课程："+cr.getId()+"："+cr.getName()+"我即将被删除");
//		coursesToSelect.remove(cr);
//		System.out.println("即将删除4位置的课程");
//		coursesToSelect.remove(4);
		
		//removeAll()删除
		Course[]courses={(Course)coursesToSelect.get(4),(Course)coursesToSelect.get(5)};
		//调用removeAll()方法，并通过Arrays工具类把course数组转变为集合作为参数传递进去
		coursesToSelect.removeAll(Arrays.asList(courses));
		System.out.println("即将删除4位置和5位置的课程");
		System.out.println("成功删除课程");
		testForeach();
	}
	/**	
	 * 测试方法时往list中添加一个课程类型的对象，取出时候也是强转为课程类型后继续向下操作。
	 * 那如果我在添加的时候不是添加的课程类型的对象会出现什么情况？
	 * ====往list中添加一些奇怪的东西
	 * public void testType(){
	 *		System.out.println("能否往list中添加一些奇怪的东西呢？");
	 *		coursesToSelect.add("我不是课程，我只是一个字符串");
	 *		//在主函数中调用	lt.testType();lt.testForeach();两个方法后报错
	 *		//错误原因：String类型不能强转为Course类型
	 *	}
	 *===============此时利用泛型可以很好的解决
	 */
	
	//<<<<<<<--------------泛型--------
	/**1.泛型：集合中的元素可以是任意类型的对象（对象的引用）
	 * 2.泛型与集合的区别：集合：如果把某个对象放入集合，则会忽略他的类型，把它当做Object处理，取出时也为Object类型
	 * 		泛型：泛型则是规定了某个集合只能存放特定类型的对象。并在编译期间进行类型检查，可以直接按指定类型获取元素
	 * 3.见TestGenneric类：泛型测试类
	 */

	// --------------主函数------------
	public static void main(String[] args) {// args可以为任何字符，只是一个字符串名称
		// 在main方法中创建一个ListTest的实例，并在构造方法中把它的coursesToSelect属性初始化
		ListTest lt = new ListTest();
		lt.testAdd();
//		lt.testGet();
//		lt.testIterator();
//		lt.testForeach();
//		lt.testModify();
//		lt.testForeach();
//		lt.testRemove();
	
		
	}

}