Collection接口之List、泛型

Collection接口

• List、Queue、Set的父接口
• 定义了可用于操作List、Set、Queue的方法——增删改查

List接口及其实现类：ArrayList

• List是元素有序且可重复的集合、被称为序列
• List可以精确的控制每个元素的插入位置、或删除指定位置的元素
• ArrayList——数组序列，是List接口的重要实现类
• ArrayList底层由数组实现

List的增加和遍历方法：

 1 import java.util.*;
 2 class ListDemo3
 3 {
 4     public static void main(String[] args)
 5     {
 6         List list = new ArrayList();
 7         add(list);
 8         //select(list,0);
 9         testIterator(list);
10     }
11     //添加
12     public static void add(List list)
13     {
14         course c1 = new course("1","离散数学");
15         course c2 = new course("2","JDBC");
16         course [] c3 = {new course("3","C语言"),new course("4","高等数学")};
17
18         list.add(c1);
19         list.add(0,c2);//添加到指定位置
20         //addAll要接收一个Collction的具体实例，通过Arrays的asList方法将course数组转为List
21         list.addAll(Arrays.asList(c3));//添加数组
22         list.addAll(0,Arrays.asList(c3));//添加到指定位置（list中的元素是可重复的）
23
24     }
25
26     //查找
27     public static void select(List list,int a)
28     {
29         System.out.println("通过get方法访问:");
30         //一个对象被添加到集合中去时会将其转为Object类型存储到集合中
31         //所以需要将其强转。
32         System.out.println(((course)list.get(a)).name);
33         //通过for循环遍历list中的元素
34         int size = list.size();
35         for(int i=0; i<size; i++)
36         {
37             course c = (course)list.get(i);
38             System.out.println(c.id+"..."+c.name);
39         }
40     }
41     //通过迭代器访问
42     //collection接口中定义了一个Iterator方法，可以返回一个当前
43     //集合对象的迭代器，然后通过迭代器去遍历当前集合中的每一个元素
44     //迭代器是用来遍历集合中元素的，本身不具备任何存储元素的功能
45     //（迭代器依赖与集合存在本身不能独立存在）
46     public static void testIterator(List list)
47     {
48         Iterator it = list.iterator();
49         System.out.println("通过迭代器遍历List:");
50         //Iterator是一个接口，其hasNext方法若还有元素则返回真
51         while (it.hasNext())
52         {
53             //Iterator的next方法返回迭代的下一个元素
54             course c = (course)it.next();
55             System.out.println(c.id+"...."+c.name);
56         }
57     }
58     //通过foreach迭代集合
59     public static void testForEach(List list)
60     {
61         for (Object obj : list)
62         {
63             course c = (course)obj;
64             System.out.println(c.id+"..."+c.name);
65         }
66     }
67 }
68
69 //课程类
70 class course
71 {
72     String id;
73     String name;
74     course(String id, String name)
75     {
76         this.id = id;
77         this.name = name;
78     }
79 }

ListDemo

List的修改和删除方法：

 1 import java.util.*;
 2 class ListDemo4
 3 {
 4     public static void main(String[] args)
 5     {
 6         List list = new ArrayList();
 7         add(list);
 8         change(list);
 9         testForeach(list);
10         testRemove(list,1);
11         testForeach(list);
12     }
13
14     public static void add(List list)
15     {
16         course [] arr =
17             {new course("1","JDBC"),new course("2","MySQL"),new course("3","大神")};
18         list.addAll(Arrays.asList(arr));
19     }
20     //List集合修改的方法
21     public static void change(List list)
22     {
23         list.set(1,new course("3","首席技术官"));
24     }
25     //通过for each遍历集合
26     public static void testForeach(List list)
27     {
28         for(Object obj : list)
29         {
30             course c = (course)obj;
31             System.out.println(c.id+"..."+c.name);
32         }
33     }
34     //List删除的方法
35     public static void testRemove(List list,int id)
36     {
37         //删除单个
38         list.remove(id);
39         System.out.println("删除了课程");
40         //删除单个
41         course c1 = (course)list.get(0);
42         list.remove(c1);
43         //删除多个
44         course [] c = {list.get(0),list.get(1)};
45         list.removeAll(Arrays.asList(c));
46     }
47
48 }
49 //课程类
50 class course
51 {
52     String id;
53     String name;
54     course(String id, String name)
55     {
56         this.id = id;
57         this.name = name;
58     }
59 }

ListDemo

泛型：

• 集合中的元素，可以是任意类型的对象（对象的引用）如果把某个对象放入集合，则会忽略它的类型。而把他当做Object处理
• 泛型则是规定了某个集合只可以存放特定类型的对象。会在编译期间进行类型检查，可以直接按指定类型获取集合元素
• 泛型集合中不能添加泛型规定的类型及其子类型以外的对象。
• 泛型集合可以添加泛型的子类型的对象实例
• 泛型集合中的规定类型不能使用基本数据类型，但可以使用包装类

 1 import java.util.*;
 2 class GenericDemo
 3 {
 4     public static void main(String[] args)
 5     {
 6         //generic();
 7         generic_1();
 8     }
 9     public static void generic()
10     {
11         List<courses> list = new ArrayList<courses>();
12         courses [] arr = {new courses("1","首席技术官"),
13             new courses("2","首席架构师"),new courses("3","项目经理"),new courses("4","独当一面")};
14
15         list.addAll(Arrays.asList(arr));
16         //泛型能添加泛型规定类型的子类型。
17         childCourses cc = new childCourses();
18         cc.id="1";
19         cc.name="时代的终结者";
20         list.add(cc);
21         //因为规定了泛型所以可以直接取出来而不用担心类型。
22         //list.add("adfas");无法添加泛型规定以外的对象
23         for (courses c : list)
24         {
25             System.out.println(c.id+"："+c.name);
26         }
27     }
28     //基本类型必须使用包装类使用泛型
29     public static void generic_1()
30     {
31         List<Integer> list = new ArrayList<Integer>();
32
33         list.add(1);
34         System.out.println("基本类型必须使用包装类作为泛型："+list.get(0));
35     }
36
37 }
38 class courses
39 {
40     String name;
41     String id;
42     courses(String name, String id)
43     {
44         this.name = name;
45         this.id = id;
46     }
47     courses()
48     {
49     }
50 }
51 class childCourses extends courses
52 {
53
54 }

GenericDemo