package com.imooc.collection;
import java.util.Set;
import java.util.List;
public class Course{
/*课程类*/
public String id; ← //因为是演示，所以用公有的属性，在实际开发中，要全部私有化
public String name; ← //同上
/*
私有化写法：
private String id;
public String getId(){
return id;
}
public void setId(String id){
this.id=id;
}
*/
public Course(String id,String name){ //含参构造器
this.id=id;
this.name=name;
}
}
//学生类
public class Student{
public String id;
public String name;
public Set courses;
}
public Student(String id;String name;){
this.id=id;
this.name=name;
this.courses=new HashSet(); /*因为Set是一个接口，不能直接将它实例化，所以用HashSet代替*/
}
//备选课程类
public class ListTest{
//用于存放备选课程的List
public List coursesToSelect;
public ListTest(){
this.coursesToSelect=new ArrayList(); /*因为List是一个接口，不能直接将它实例化，所以用ArrayList代替*/
}
//用于往coursesToSelect中添加备选课程
public void testAdd(){
//创建一个课程对象，并通过调用add方法，添加到备选课程List中
Course cr1=new Course("1","数据结构");
coursesToSelect.add(cr1); //coursesToSelect.add(index,element); 这样我们就往List中添加一个元素
/*因为刚才只插进一个元素，而List和数组一样，它的起始位置都是0，也就是说第一个位置就是0，所以就通过get(0)来取得刚才插进去的元素*/
/*当一个对象被添加进集合中去的，会忽略它本来的类型，只把它当做Oblect类型，而当把它取出来的时候，也是一个Object，我们就需要通过类型强转，也就是说，对象存入集合都变成Object类型，取出时需要类型转换*/
Course temp=(Course) coursesToSelect.get(0); //通过List的get()方法把元素取出来
System.out.println("添加了课程："+temp.id+":"+temp.name);
Course cr2=new Course("2","C语言")；
coursesToSelect.add(0,cr2); /*coursesToSelect.add(index,element); 调用第二个add()方法，因为已经添加了cr1，所以coursesToSelect的长度就为1，然后我们指定添加的位置为0，也就是说，在0位置上添加cr2,这样就会把原先第0位置上的cr1挤到第1位置上去*/
Course temp2=(Course) coursesToSelect.get(0); //调用get()方法来取得刚才添加的课程
System.out.println("添加了课程："+temp2.id+":"+temp2.nname);
/*
在调用add()方法的时候，给它传递的位置参数，如果是>它现在的长度，会发生什么情况？
Course cr3=new Course("3","test");
coursesToSelect.add(4,cr3); //coursesToSelect.add(index,element);
输出：（报错）
Exception in thread "main" java.lang.IndexOutOfBoundsException:Index:4,Size:2 数组下标越界异常
at java.util.ArrayList.add(ArrayList.java:367)
at com.imooc.collection.ListTest.testAdd(ListTest.java:38)
at com.imooc.collection.ListTest.main(ListTest.java:43)
*/
Course[] course={new Course("3","离散数学"),new Course("4","汇编语言")};
courseToSelect.addAll(Arrays.asList(course)); //courseToSelect.addAll(Collection c); 把course数组转变成List
Course temp3=(Course) courseToSelect.get(2);
Course temp4=(Course) courseToSelect.get(3);
System.out.println(“添加了两门课程：”+temp3.id+":"+temp3.name+";"+temp4.id+":"+temp4.name);
Course[] course2={new Course("5","高等数学"),new Course("6","大学英语")};
courseToSelect.addAll(2,Arrays.asList(course2));
Course temp5=(Course) coursesToSelect.get(2);
Course temp6=(Course) coursesToSelect.get(3);
System.out.println(“添加了两门课程：”+temp5.id+":"+temp5.name+";"+temp6.id+":"+temp6.name);
}
/*
取得List中的元素的方法 为了要依次遍历数组中的每一个元素，首先要取得List的长度，通过调用List的size()方法→int size()
int size() 返回列表中的元素数，如果列表包含多于Integer.MAX_VALUE个元素，则返回Integer.MAX_VALUE
指定者：
接口 Collection<E> 中的 size
返回：
列表中的元素数
*/
public void testGet(){
int size=coursesToSelect.size();
System.out.println("有如下课程待选：");
for(int i=0;i<size;i++){
Course cr=(Course) coursesToSelect.get(i);
System.out.println(“课程：”+cr.id+":"+cr.name);
}
}
/*
通过迭代器(iterator)来遍历List iterator() : 返回在此collection的元素上进行迭代的迭代器（同时也是一个接口），本身为了便利集合中元素，不具备存储功能，也就是说，迭代器是依赖于某个集合而存在的，本身不能独立的存在，关于元素返回的顺序没有任何保证（除非此collection是某个能提供保证顺序的类实例）。
指定者：
接口 Iterator<E>中的 iterator
返回：
在此collection的元素上进行迭代的Iterator
*/
public void testIterator(){
//通过集合的iterator方法，取得迭代器的实例
Iterator it=coursesToSelect.iterator();
System.out.println("有如下课程待选(通过迭代器访问)：");
while(it.hasNaxt()){ //iterator有一个hasNext()方法
Course cr=(Course) it.next();
System.out.println(“课程：”+cr.id+":"+cr.name);
}
}
/*
通过for each方法访问集合元素 for each方法是迭代器方法的一种简便的写法
*/
public void testForEach(){
System.out.println("有如下课程待选(通过for each访问)：");
for(Object obj:coursesToSelect){ /*先是定义了Object类型的一个变量，后面是要遍历的一个集合，意思是说，去遍历集合中的每一个元素，把它取出来，作为Object类型的一个变量*/
Course cr=(Course) obj;
System.out.println(“课程：”+cr.id+":"+cr.name);
}
}
/*
修改List中的元素--课程修改
*/
public void testModify(){
courseToSelect.set(4,new Course("7","毛概"));
/*
set(int index,E element):用指定元素替换列表中指定位置的元素（可选操作）
参数：index--要替换的元素的索引 element--要在指定位置存储的元素
返回：以前在指定位置存储的元素
在List中定义了一个set()方法，达到修改相应位置上的元素的目的，这set()方法有两个参数，一个参数是索引位置的值，另一个是将要修改的新对象的值，
*/
}
/*
删除List中的元素
remove(int index):移除列表中指定位置的元素【传入指定的索引位置，就能把相应位置上的索引删除，需要说明的是，这个传递进去的索引的位置，它必须是List长度范围之内，如果超出了这个长度范围，就会报数组下标越界异常，若改成 如下，结果相同】
public void testRemove(){
System.out.println(“即将删除4位置上的课程！”);
coursesToSelect.remove(4);
System.out.println(“成功删除课程！");
testForEach(); //重新打印输出coursesToSelect还剩下哪些元素
}
】*/
/*remove(Object o):从此列表中移除第一次出现的指定元素（如果存在）（可选操作）【取得某位置的元素，并把这个元素传到remove()方法中来实现删除】*/
removeAll(Collection<?> c):从此列表中移除指定collection中包含的其所有元素（可选操作）
public void testRemove(){
System.out.println(“即将删除3位置和4位置上的课程！”);
Course[] courses={(Course) coursesToSelect.get(3),(Course) courseToSelect.get(4)};
coursesToSelect.removeAll(Array.asList(courses)); /*通过coursesToSelect.removeAll()方法，并且通过Arrays工具类，把courses数组转化成一个集合，作为参数传递进去*/
System.out.println(“成功删除课程！");
testForEach(); //重新打印输出coursesToSelect还剩下哪些元素
}
public void testRemove(){
Course cr=(Course) Courses coursesToSelect(4); /*通过coursesToSelect的get()方法来取得4索引位置上的课程元素*/
System.out.println(“我是课程：”+cr.id+":"+cr.name+“，我即将被删除”);
coursesToSelect.remove(cr);
System.out.println(“成功删除课程！");
testForEach(); //重新打印输出coursesToSelect还剩下哪些元素
}
/*往List中添加一个奇怪的东西*/
public void testType(){
System.out.println("能否往List中添加一些奇怪的东西呢！？");
coursesToSelect.add("我不是课程，我只是一个无辜的字符串！！");
}
public static void main(String[] args){
ListTest lt=new ListTest();
lt.testAdd();
lt.testGet();
lt.testIterator();
lt.testForEach();
lt.testModify();
lt.testForEach();
lt.testRemove();
lt.testType();
lt.testForEach();
}
}
输出：添加了课程：1：数据结构
添加了课程：2：C语言
添加了两门课程：3：离散数学；4：汇编语言
添加了两门课程：5：高等数学；6：大学英语
有如下课程待选：
课程：2：C语言
课程：1：数据结构
课程：5：高等数学
课程：6：大学英语
课程：3：离散数学
课程：4：汇编语言
有如下课程待选(通过迭代器访问)：
课程：2：C语言
课程：1：数据结构
课程：5：高等数学
课程：6：大学英语
课程：3：离散数学
课程：4：汇编语言
有如下课程待选(通过for each访问)：
课程：2：C语言
课程：1：数据结构
课程：5：高等数学
课程：6：大学英语
课程：3：离散数学
课程：4：汇编语言
有如下课程待选(通过for each访问)：
课程：2：C语言
课程：1：数据结构
课程：5：高等数学
课程：6：大学英语
课程：7：毛概
课程：4：汇编语言
我是课程：7:毛概，我即将被删除
成功删除课程！
有如下课程待选(通过for each访问)：
课程：2：C语言
课程：1：数据结构
课程：5：高等数学
课程：6：大学英语
课程：4：汇编语言
即将删除3位置和4位置上的课程！
成功删除课程！
有如下课程待选(通过for each访问)：
课程：2：C语言
课程：1：数据结构
课程：5：高等数学
报错了
除了这两个add()方法，还有两个addAll()方法有往List中添加元素的功能；List中的课程是可以重复的
这就要用到泛型：
集合中的元素，可以是任意类型的对象（对象的引用）
如果把某个对象放入集合，则会忽略他的类型，而把他当作Object处理
泛型则是规定了某个集合只可以存放特定类型的对象
泛型会在编译期间进行类型检查，可以直接按指定类型获取集合元素