集合总结

  1 1:对象数组(掌握)
  2     (1)数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。
  3     (2)案例：
  4         用数组存储5个学生对象，并遍历数组。
  5 
  6 2:集合(Collection)(掌握)
  7     (1)集合的由来?
  8         我们学习的是Java -- 面向对象 -- 操作很多对象 -- 存储 -- 容器(数组和StringBuffer) -- 数组
  9         而数组的长度固定，所以不适合做变化的需求，Java就提供了集合供我们使用。
 10     (2)集合和数组的区别?
 11         A:长度区别
 12             数组固定
 13             集合可变
 14         B:内容区别
 15             数组可以是基本类型，也可以是引用类型
 16             集合只能是引用类型
 17         C:元素内容
 18             数组只能存储同一种类型
 19             集合可以存储不同类型(其实集合一般存储的也是同一种类型)
 20     (3)集合的继承体系结构?
 21         由于需求不同，Java就提供了不同的集合类。这多个集合类的数据结构不同，但是它们都是要提供存储和遍历功能的，
 22         我们把它们的共性不断的向上提取，最终就形成了集合的继承体系结构图。
 23         
 24         Collection
 25             |--List
 26                 |--ArrayList
 27                 |--Vector
 28                 |--LinkedList
 29             |--Set
 30                 |--HashSet
 31                 |--TreeSet
 32     (4)Collection的功能概述(自己补齐)
 33         A:添加功能
 34         B:删除功能
 35         C:判断功能
 36         D:获取功能
 37         E:长度功能
 38         F:交集(了解)
 39         G:把集合转数组(了解)
 40     (5)Collection集合的遍历
 41         A:把集合转数组(了解)
 42         B:迭代器(集合专用方式)
 43     (6)迭代器
 44         A:是集合的获取元素的方式。
 45         B:是依赖于集合而存在的。
 46         C:迭代器的原理和源码。
 47             a:为什么定义为了一个接口而不是实现类?
 48             b:看了看迭代器的内部类实现。
 49     (7)Collection集合的案例(遍历方式 迭代器)
 50         集合的操作步骤：
 51             A:创建集合对象
 52             B:创建元素对象
 53             C:把元素添加到集合
 54             D:遍历集合
 55     
 56         A:存储字符串并遍历
 57             import java.util.Collection;
 58             import java.util.ArrayList;
 59             import java.util.Iterator;
 60             
 61             public class CollectionDemo {
 62                 public static void main(String[] args) {
 63                     //创建集合对象
 64                     Collection c = new ArrayList();
 65                     
 66                     //创建并添加元素
 67                     c.add("hello");
 68                     c.add("world");
 69                     c.add("java");
 70                     
 71                     //遍历集合
 72                     Iterator it = c.iterator();
 73                     while(it.hasNext()) {
 74                         String s =(String) it.next();
 75                         System.out.println(s);
 76                     }
 77                 }
 78             }
 79         
 80         B:存储自定义对象并遍历
 81             public class Student {
 82                 private String name;
 83                 private int age;
 84                 
 85                 public Student(){}
 86                 
 87                 public Student(String name,int age) {
 88                     this.name = name;
 89                     this.age = age;
 90                 }
 91                 
 92                 //getXxx()/setXxx()
 93             }
 94             
 95             import java.util.Collection;
 96             import java.util.ArrayList;
 97             import java.util.Iterator;
 98             
 99             public class StudentDemo {
100                 public static void main(String[] args) {
101                     //创建集合对象
102                     Collection c = new ArrayList();
103                     
104                     //创建学生对象
105                     Student s1 = new Student("林青霞",27);
106                     Student s2 = new Student("风清扬",30);
107                     Student s3 = new Student("刘意",30);
108                     Student s4 = new Student("武鑫",25);
109                     Student s5 = new Student("刘晓曲",16);
110                     
111                     //添加元素
112                     c.add(s1);
113                     c.add(s2);
114                     c.add(s3);
115                     c.add(s4);
116                     c.add(s5);
117                     
118                     //遍历集合
119                     Iterator it = c.iterator();
120                     while(it.hasNext()) {
121                         Student s = (Student)it.next();
122                         System.out.println(s.getName()+"---"+s.getAge());
123                     }
124                 }
125             }
126 
127 3:集合(List)(掌握)
128     (1)List是Collection的子接口
129         特点：有序(存储顺序和取出顺序一致)，可重复。
130     (2)List的特有功能：(自己补齐)
131         A:添加功能
132         B:删除功能
133         C:获取功能
134         D:迭代器功能
135         E:修改功能
136     (3)List集合的特有遍历功能
137         A:由size()和get()结合。
138         B:代码演示
139                     //创建集合对象
140                     List list = new ArrayList();
141                     
142                     //创建并添加元素
143                     list.add("hello");
144                     list.add("world");
145                     list.add("java");
146                     
147                     //遍历集合
148                     Iterator it = list.iterator();
149                     while(it.hasNext()) {
150                         String s =(String) it.next();
151                         System.out.println(s);
152                     }
153                     System.out.println("----------");
154                     
155                     for(int x=0; x<list.size(); x++) {
156                         String s =(String) list.get(x);
157                         System.out.println(s);
158                     }
159     (4)列表迭代器的特有功能；(了解)
160         可以逆向遍历，但是要先正向遍历，所以无意义，基本不使用。
161     (5)并发修改异常
162         A:出现的现象
163             迭代器遍历集合，集合修改集合元素
164         B:原因
165             迭代器是依赖于集合的，而集合的改变迭代器并不知道。
166         C:解决方案
167             a:迭代器遍历，迭代器修改(ListIterator)
168                 元素添加在刚才迭代的位置
169             b:集合遍历，集合修改(size()和get())
170                 元素添加在集合的末尾
171     (6)常见数据结构
172         A:栈 先进后出
173         B:队列 先进先出
174         C:数组 查询快，增删慢
175         D:链表 查询慢，增删快
176     (7)List的子类特点(面试题)
177         ArrayList
178             底层数据结构是数组，查询快，增删慢。
179             线程不安全，效率高。
180         Vector
181             底层数据结构是数组，查询快，增删慢。
182             线程安全，效率低。
183         LinkedList
184             底层数据结构是链表，查询慢，增删快。
185             线程不安全，效率高。
186             
187         到底使用谁呢?看需求?
188         分析：
189             要安全吗?
190                 要：Vector(即使要，也不使用这个，后面再说)
191                 不要：ArrayList或者LinkedList
192                     查询多；ArrayList
193                     增删多：LinkedList
194                     
195         什么都不知道，就用ArrayList。
196     (8)List集合的案例(遍历方式 迭代器和普通for)
197         A:存储字符串并遍历
198         B:存储自定义对象并遍历