一　　List是有序可重复的集合

可以进行增删改查，直接看代码

package com.collection;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class ListTest {

 public List courseToList;

 public ListTest(){  
     this.courseToList = new ArrayList();  
 }  
 public void addCourse(){  
     //add方法  
     Course c1 = new Course(1,"语文");  
     courseToList.add(c1);  
     Course temp1 = (Course) courseToList.get(0);  
     System.out.println("添加了课程："+temp1.id+"-"+temp1.name);

     Course c2 = new Course(2,"数学");  
     courseToList.add(c2);  
     Course temp3 = (Course) courseToList.get(1);  
     System.out.println("添加了课程："+temp3.id+"-"+temp3.name);

     Course c3 = new Course(3,"英语");  
     courseToList.add(0,c3);  
     Course temp4 = (Course) courseToList.get(0);  
     System.out.println("添加了课程："+temp4.id+"-"+temp4.name);

     /\*System.out.println(courseToList.size());  
     Course c4 = new Course(4,"物理");  
     //插入时，如果Index值小于0，或大于当前List长度，会报下标越界错误  
     courseToList.add(4,c4);  
     //等于List长度，不会报错  
     courseToList.add(3,c4);\*/

     courseToList.add(3,new Course(4,"理综"));

     //addAll方法  
     Course\[\] c5 = {new Course(5,"化学"),new Course(6,"生物")};  
     courseToList.addAll(Arrays.asList(c5));  
     Course temp5 = (Course) courseToList.get(4);  
     Course temp6 = (Course) courseToList.get(5);  
     System.out.println("添加了两门课程："+temp5.id+"-"+temp5.name+";"+temp6.id+"-"+temp6.name);

     Course\[\] c6 = {new Course(7,"地理"),new Course(8,"历史") };  
     courseToList.addAll(4,Arrays.asList(c6));  
     Course temp7 = (Course) courseToList.get(4);  
     Course temp8 = (Course) courseToList.get(5);  
     System.out.println("添加了两门课程："+temp7.id+"-"+temp7.name+";"+temp8.id+"-"+temp8.name);  
 }

 /\*  
 \* for循环出List中所有元素  
 \* \*/  
 public void testFor(){  
     System.out.println("");  
     System.out.println("for循环课程列表如下：");  
     for(int i = 0;i<courseToList.size();i++){  
         Course c = (Course) courseToList.get(i);  
         System.out.println("课程："+c.id+"-"+c.name);  
     }  
 }

 /\*  
 \* List迭代器循环出List中所有元素  
 \* \*/  
 public void testIt(){  
     System.out.println("");  
     System.out.println("迭代器循环课程列表如下：");  
     Iterator it = (Iterator) courseToList.iterator();  
     while(it.hasNext()){  
         Course c = (Course) it.next();  
         System.out.println("课程："+c.id+"-"+c.name);  
     }  
 }

 /\*  
 \* for each循环出List中所有元素  
 \* \*/  
 public void testForEach(){  
     System.out.println("");  
     System.out.println("forEach循环课程列表如下：");  
     for(Object obj:courseToList){  
         Course c = (Course) obj;  
         System.out.println("课程："+c.id+"-"+c.name);  
     }  
 }

 /\*  
 \* List修改功能  
 \* \*/  
 public void testModify(){  
     System.out.println("");  
     System.out.println("即将修改第4门课");  
     courseToList.set(3,new Course(4,"物理"));  
     System.out.println("第4门课修改完成");  
 }

 /\*  
 \* List删除功能  
 \* \*/  
 public void testDelete(){  
     System.out.println("");  
     //根据键值删除  
     Course c1 = (Course) courseToList.get(3);  
     courseToList.remove(c1);  
     System.out.println("删除课程："+c1.id+"-"+c1.name);  
     testForEach();

     //根据索引下标删除  
     courseToList.remove(3);  
     System.out.println("");  
     System.out.println("删除第4门课程：");  
     testForEach();

     //根据键值批量删除  
     Course\[\] cs1 = {(Course) courseToList.get(3),(Course) courseToList.get(4)};  
     System.out.println("");  
     System.out.println("删除两门课程：");  
     courseToList.removeAll(Arrays.asList(cs1));  
     testForEach();  
 }

 /\*  
 \* 泛型List添加泛型子类型  
 \* \*/  
 public void addChildrenTest(){  
     System.out.println("");  
     ChildrenCourse cc1 = new ChildrenCourse();  
     courseToList.add(cc1);  
     cc1.id = 10;  
     cc1.name = "我是子类型的课程";  
     System.out.println("添加了一门泛型子类型的课程：");  
     testForEach();  
 }  
 /\*  
 \* 泛型不能使用基本类型，但是能使用基本类型的包装类  
 \* 基本类型如：int long boolean  
 \* 基本类型的包装类如：Integer Long Boolean  
 \* \*/  
 public void addBasicType(){  
     System.out.println("");  
     //下面这句会报错  
     //ArrayList<int> basicTest = new ArrayList<int>();  
     ArrayList<Integer> basicTest = new ArrayList<Integer>();  
     basicTest.add(3);  
     System.out.println("整形的泛型List第一个元素为："+basicTest.get(0));  
 }

 public static void main(String\[\] args){  
     ListTest lt = new ListTest();  
     lt.addCourse();  
     lt.testFor();  
     lt.testIt();  
     lt.testModify();  
     lt.testForEach();  
     lt.testDelete();  
     lt.addChildrenTest();  
     lt.addBasicType();  
 }  

}

其中Course类如下：

package com.collection;

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

public class Course {
public int id;
public String name;
public Set Course;

 public Course(int id,String name){  
     this.id = id;  
     this.name = name;  
     this.Course = new HashSet();  
 }  
 public Course(){

 }  

}

运行结果：

添加了课程：1-语文
添加了课程：2-数学
添加了课程：3-英语
添加了两门课程：5-化学;6-生物
添加了两门课程：7-地理;8-历史

for循环课程列表如下：
课程：3-英语
课程：1-语文
课程：2-数学
课程：4-理综
课程：7-地理
课程：8-历史
课程：5-化学
课程：6-生物

迭代器循环课程列表如下：
课程：3-英语
课程：1-语文
课程：2-数学
课程：4-理综
课程：7-地理
课程：8-历史
课程：5-化学
课程：6-生物

即将修改第4门课
第4门课修改完成

forEach循环课程列表如下：
课程：3-英语
课程：1-语文
课程：2-数学
课程：4-物理
课程：7-地理
课程：8-历史
课程：5-化学
课程：6-生物

删除课程：4-物理

forEach循环课程列表如下：
课程：3-英语
课程：1-语文
课程：2-数学
课程：7-地理
课程：8-历史
课程：5-化学
课程：6-生物

删除第4门课程：

forEach循环课程列表如下：
课程：3-英语
课程：1-语文
课程：2-数学
课程：8-历史
课程：5-化学
课程：6-生物

删除两门课程：

forEach循环课程列表如下：
课程：3-英语
课程：1-语文
课程：2-数学
课程：6-生物

添加了一门泛型子类型的课程：

forEach循环课程列表如下：
课程：3-英语
课程：1-语文
课程：2-数学
课程：6-生物
课程：10-我是子类型的课程

整形的泛型List第一个元素为：3

二　　泛型

泛型List中无法添加出泛型类型及其子类型以外的类型
示例：

package com.collection;

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

public class ListTestPro {

 public List<Course> courseToList;

 public ListTestPro(){  
     this.courseToList = new ArrayList<Course>();  
 }

 public void addTest(){  
     Course c1 = new Course(1,"高等数学");  
     courseToList.add(c1);  
     //泛型List中无法添加出泛型类型及其子类型以外的类型  
     //courseToList.add("尝试下添加字串类型到List中");  
     Course\[\] cs1 = {new Course(2,"高等化学"),new Course(3,"大学英语")};  
     courseToList.addAll(Arrays.asList(cs1));  
     for(Course c:courseToList){  
         System.out.println("当前课程："+c.name);  
     }

 }

 public static void main(String\[\] args){  
     ListTestPro ltp = new ListTestPro();  
     ltp.addTest();

 }

}

运行结果：

当前课程：高等数学
当前课程：高等化学
当前课程：大学英语

泛型添加子类型

/*
* 泛型List添加泛型子类型
* */
public void addChildrenTest(){
System.out.println("");
ChildrenCourse cc1 = new ChildrenCourse();
courseToList.add(cc1);
cc1.id = 10;
cc1.name = "我是子类型的课程";
System.out.println("添加了一门泛型子类型的课程：");
testForEach();
}

其中ChildrenCourse类如下：

package com.collection;

public class ChildrenCourse extends Course {
}

运行结果：

添加了一门泛型子类型的课程：

forEach循环课程列表如下：
课程：3-英语
课程：1-语文
课程：2-数学
课程：6-生物
课程：10-我是子类型的课程

基本类型的泛型

/\*  
\* 泛型不能使用基本类型，但是能使用基本类型的包装类  
\* 基本类型如：int long boolean等  
\* 基本类型的包装类如：Integer Long Boolean等  
\* \*/  
public void addBasicType(){  
    System.out.println("");  
    //下面这句会报错  
    //ArrayList<int> basicTest = new ArrayList<int>();  
    ArrayList<Integer> basicTest = new ArrayList<Integer>();  
    basicTest.add(3);  
    System.out.println("整形的泛型List第一个元素为："+basicTest.get(0));  
}

运行结果：

整形的泛型List第一个元素为：3

三　　Set是无序的不可重复集合

set中添加某个对象无论添加多少次，
最终只会保留一个该对象（的引用），
并且，保留的是第一次添加的那个

show me the code :
Student类

package com.collection;

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

public class Student {
public int id;
public String name;

 //set中添加某个对象无论添加多少次，最终只会保留一个该对象（的引用），并且，保留的是第一次添加的那个

 public Set<Course> course = new HashSet<Course>();

 public Student(int id, String name){  
     this.id = id;  
     this.name = name;  
 }

}

　运行类

package com.collection;

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;
import java.util.Scanner;
import java.lang.String;

public class SetTest {

 public List<Course> courseToList = new ArrayList<Course>();

 public void addCourse(){  
     //add方法  
     Course c1 = new Course(1,"语文");  
     courseToList.add(c1);  
     Course temp1 = (Course) courseToList.get(0);  
     System.out.println("添加了课程："+temp1.id+"-"+temp1.name);

     Course c2 = new Course(2,"数学");  
     courseToList.add(c2);  
     Course temp3 = (Course) courseToList.get(1);  
     System.out.println("添加了课程："+temp3.id+"-"+temp3.name);

     Course c3 = new Course(3,"英语");  
     courseToList.add(0,c3);  
     Course temp4 = (Course) courseToList.get(0);  
     System.out.println("添加了课程："+temp4.id+"-"+temp4.name);

     courseToList.add(3,new Course(4,"物理"));

     //addAll方法  
     Course\[\] c5 = {new Course(5,"化学"),new Course(6,"生物")};  
     courseToList.addAll(Arrays.asList(c5));  
     Course temp5 = (Course) courseToList.get(4);  
     Course temp6 = (Course) courseToList.get(5);  
     System.out.println("添加了两门课程："+temp5.id+"-"+temp5.name+";"+temp6.id+"-"+temp6.name);

     Course\[\] c6 = {new Course(7,"地理"),new Course(8,"历史") };  
     courseToList.addAll(4,Arrays.asList(c6));  
     Course temp7 = (Course) courseToList.get(4);  
     Course temp8 = (Course) courseToList.get(5);  
     System.out.println("添加了两门课程："+temp7.id+"-"+temp7.name+";"+temp8.id+"-"+temp8.name);  
 }  
 public void courseForEach(){  
     System.out.println("");  
     System.out.println("目前共有课程如下：");  
     for(Course c : courseToList){  
         System.out.println("当前课程为："+c.id+"-"+c.name);  
     }  
 }

 /\*  
 \* 让同学张三输入课程ID选课程,能选三门  
 \* \*/  
 public void studentSelectCourse(){  
     System.out.println("");  
     Student s\_zhang = new Student(1,"张三");  
     System.out.println("学生"+s\_zhang.name+"开始选课：");

     Scanner console = new Scanner(System.in);  
     for(int i = 0;i < 3 ; i++){  
         String id =  console.next();  
         for(Course c : courseToList){  
             if(id.equals( String.valueOf(c.id))){  
                 s\_zhang.course.add(c);  
                 /\*  
                 \* set中添加某个对象无论添加多少次，  
                 \* 最终只会保留一个该对象（的引用），  
                 \* 并且，保留的是第一次添加的那个  
                 \* \*/  
                 s\_zhang.course.add(c);//set类型无法添加重复的数据  
                 System.out.println("选课程"+c.name+"成功");  
             }  
         }  
     }

     System.out.println("学生"+s\_zhang.name+"共选了"+s\_zhang.course.size()+"门课程，如下：");  
     for(Course c1:s\_zhang.course){  
         System.out.println(c1.id+"-"+c1.name);  
     }  
 }

 public static void main(String\[\] args){  
     SetTest st = new SetTest();  
     st.addCourse();  
     st.courseForEach();  
     st.studentSelectCourse();

 }  

}

运行结果：

添加了课程：1-语文
添加了课程：2-数学
添加了课程：3-英语
添加了两门课程：5-化学;6-生物
添加了两门课程：7-地理;8-历史

目前共有课程如下：
当前课程为：3-英语
当前课程为：1-语文
当前课程为：2-数学
当前课程为：4-物理
当前课程为：7-地理
当前课程为：8-历史
当前课程为：5-化学
当前课程为：6-生物

学生张三开始选课：
4
选课程物理成功
7
选课程地理成功
8
选课程历史成功
学生张三共选了3门课程，如下：
8-历史
7-地理
4-物理